University Professor
University of Milano-Bicocca, Computer Science Department, Italy.
Oliviero Riganelli
I am a professor and researcher at the University of Milano-Bicocca. My passion lies in empowering developers to create software that instills trust and confidence in its users. With a Ph.D. in Computer Science and Complex Systems, my primary research focuses on software engineering, particularly software testing and analysis. I delve into the intricate world of software development, dedicated to enhancing its correctness and quality. I strive to elevate software systems to their full potential by pioneering innovative methodologies and leveraging cutting-edge technologies. Specifically, I work on techniques to automatically ensure the software functions as intended, improving both the software itself and its development process. My impactful contributions have been published in prestigious journals and conferences, demonstrating my commitment to advancing the field of software engineering.
Positions
-
Present 2015
-
2021 2007
Co-founder of University Spin-Off
University of Camerino, e-Lios, Italy
-
2015 2014
Postdoctoral Researcher
University of Lugano, Faculty of Informatics, Switzerland.
-
2014 2009
Postdoctoral Researcher
University of Milano Bicocca, Computer Science Department, Italy.
-
2008 2006
Visiting Researcher
Stony Brook University, Computer Science Department, United States.
Education & Training
-
Ph.D. 2009
Ph.D. in Computer Science and Complex systems
University of Camerino
-
M.Sc. 2005
M.Sc. in Computer Science
University of Camerino
-
B.Sc. 2003
B.Sc. in Computer Science
University of Camerino
Research
Research Summary
In the field of software engineering, my research mainly focuses on software testing, software analysis, and self-adaptive systems. By rigorously exploring these areas, my goal is to deepen the understanding of software behavior, improve system reliability, and facilitate the development of high-quality software products.
Software testing is a common practice adopted by software engineers to validate software systems. Testing of modern systems requires a lot of developer effort and testing costs often prevent engineers from exhaustively validating their systems. My research focuses on the enhancement of software testing practices through the automation of software testing activities. Specifically, I concentrate on automatically generating tests that align with the domain of the software under test. This involves creating tests that accurately reflect the functionality of the software, ensuring that it behaves as expected. Through this approach, the aim is to improve testing efficiency and reduce manual intervention, ultimately optimizing resource utilization in software testing.
Software analysis is a fundamental practice in software engineering that aims to comprehend the structure, behavior, and characteristics of software. It involves examining both static (source code) and dynamic (execution traces) information. My research dives deep into various analysis methodologies, extracting comprehensive insights about software systems. These insights are invaluable for verifying software functionality and achieving critical objectives in software engineering, such as enhancing system reliability and optimizing performance. By leveraging software analysis techniques, my research contributes to creating more robust, efficient, and reliable software products.
Self-adaptive systems are systems which automatically adjust their behavior in response to changing conditions of their work environments. The goal of this research is to manage the growing complexity of modern systems and enrich them with capabilities that occur in biological systems such as self-configuration, self-optimization, self-healing and self- protection. In particular, my research focuses on enhancing software systems' resilience through self-repair and self-healing mechanisms. By developing automated fault detection and correction algorithms, as well as integrating runtime verification techniques, I aim to create software systems capable of autonomously detecting and remedying faults in real-time. Ultimately, this research contributes to the development of more reliable and resilient software systems that can operate effectively in dynamic environments.
Interests
- Software Engineering
- Software Testing
- Software Analysis
- Self-Adaptive Systems
Publications
This is a selection of my publications which are potentially of broad interest. If you are looking for a specific publication not on this list, or need more detailed information on these topics, please contact me at oliviero.riganelli@unimib.it. For a more comprehensive list, you can also visit my Google Scholar profile.
Most of the papers available from this page appear in print, and the corresponding copyright is held by the publisher. While the papers can be used for personal use, redistribution or reprinting for commercial purposes is prohibited.
Filter by type:
Sort by year:
Monitoring Probe Deployment Patterns for Cloud-Native Applications: Definition and Empirical Assessment
Journal Paper
IEEE Transactions on Services Computing, 2024.
Abstract
Monitoring is a key feature to enhance systems with the capability to anticipate, detect, predict, and mitigate failures, while providing Quality of Service (QoS) monitoring and Service Level Agreements (SLAs) guarantee. Monitoring frameworks can serve these purposes by deploying probes according to many possible patterns that have different features, for instance in terms of efficiency and privacy. So far, these probe deployment patterns have not been systematically defined, analyzed and assessed. Thus, engineers who design and configure their monitoring systems have to take decisions only based on partial knowledge and personal experience. This paper addresses this knowledge gap, by presenting a systematic analysis of 11 probe deployment patterns, their known uses, and implementations. We assess these patterns qualitatively, and quantitatively using both VMs and containers. Results show the targets have negligible resource consumption (e.g., less than 1% CPU usage), while the probe holder consumption is mainly significant in relation to memory consumption, reaching up to 10 GiB in our experiments. Our findings suggest that reusing probes and holders among users can generally enhance efficiency and scalability when direct access to the monitored target is not an option. We generate a set of best practices that can assist engineers in configuring their monitoring systems. Finally, we showcase the application of certain patterns through three practical usage scenarios, which feature diverse technologies and requirements.
Automatic testing of runtime enforcers with Test4Enforcers
Journal Paper
Journal of Systems and Software, Volume 210, 2024.
Abstract
Users regularly use apps to access services in a range of domains, such as health, productivity, entertainment, and business. The safety and correctness of the runtime behavior of these apps is thus a key concern for users. Indeed, unreliable apps may generate dissatisfaction, frustration and issues to users. Runtime enforcement techniques can be used to implement software enforcers that monitor executions and apply corrective actions when needed, potentially preventing misbehaviors and failures. However, enforcers might be faulty themselves, applying the wrong actions or missing to apply the right actions. To address this problem, this paper presents Test4Enforcers, an approach to automatically test software enforces. Test4Enforcers relies on an enforcement model describing the strategy that shall be applied at runtime to correct misbehaviors. Test4Enforcers first uses the enforcement model to derive a specification of the test cases that shall be executed to validate any software enforcer implemented from the given model. Then, it automatically turns the test specification into a set of concrete test cases that can be executed against apps augmented with the enforcers. We evaluated Test4Enforces with a set of 3,135 faults injected in the enforcers derived from 13 enforcement models. Results show that Test4Enforcers can automatically reveal 64% of the faults, while existing approaches relying on crash detection can only reveal 6% of the faults. Test4Enforcers is also practical since testing an enforcer required 9 min, in the worst case.
Analyzing Prompt Influence on Automated Method Generation: An Empirical Study with Copilot
Conference Paper
In Proc. of tthe 32nd IEEE/ACM International Conference on Program Comprehension (ICPC), 2024.
Abstract
Generative AI is changing the way developers interact with software systems, providing services that can produce and deliver new content, crafted to satisfy the actual needs of developers. For instance, developers can ask for new code directly from within their IDEs by writing natural language prompts, and integrated services based on generative AI, such as Copilot, immediately respond to prompts by providing ready-to-use code snippets. Formulating the prompt appropriately, and incorporating the useful information while avoiding any information overload, can be an important factor in obtaining the right piece of code. The task of designing good prompts is known as prompt engineering. In this paper, we systematically investigate the influence of eight prompt features on the style and the content of prompts, on the level of correctness, complexity, size, and similarity to the developers' code of the generated code. We specifically consider the task of using Copilot with 124,800 prompts obtained by systematically combining the eight considered prompt features to generate the implementation of 200 Java methods. Results show how some prompt features, such as the presence of examples and the summary of the purpose of the method, can significantly influence the quality of the result.
Generating Java Methods: An Empirical Assessment of Four AI-Based Code Assistants
Conference Paper
In Proc. of tthe 32nd IEEE/ACM International Conference on Program Comprehension (ICPC), 2024.
Abstract
AI-based code assistants are promising tools that can facilitate and speed up code development. They exploit machine learning algorithms and natural language processing to interact with developers, suggesting code snippets (e.g., method implementations) that can be incorporated into projects. Recent studies empirically investigated the effectiveness of code assistants using simple exemplary problems (e.g., the re-implementation of well-known algorithms), which fail to capture the spectrum and nature of the tasks actually faced by developers. In this paper, we expand the knowledge in the area by comparatively assessing four popular AI-based code assistants, namely GitHub Copilot, Tabnine, ChatGPT, and Google Bard, with a dataset of 100 methods that we constructed from real-life open-source Java projects, considering a variety of cases for complexity and dependency from contextual elements. Results show that Copilot is often more accurate than other techniques, yet none of the assistants is completely subsumed by the rest of the approaches. Interestingly, the effectiveness of these solutions dramatically decreases when dealing with dependencies outside the boundaries of single classes.
Automated Probe Life-Cycle Management for Monitoring-as-a-Service
Journal Paper
IEEE Transactions on Services Computing 16 (2), 2023.
Abstract
Automated Probe Life-Cycle Management for Monitoring-As-a-Service.
Predicting failures in multi-tier distributed systems.
Journal Paper
Journal of Systems and Software, Volume 161, March 2020.
Abstract
Many applications are implemented as multi-tier software systems, and are executed on distributed infrastructures, like cloud infrastructures, to benefit from the cost reduction that derives from dynamically allocating resources on-demand. In these systems, failures are becoming the norm rather than the exception, and predicting their occurrence, as well as locating the responsible faults, are essential enablers of preventive and corrective actions that can mitigate the impact of failures, and significantly improve the dependability of the systems. Current failure prediction approaches suffer either from false positives or limited accuracy, and do not produce enough information to effectively locate the responsible faults. In this paper, we present PreMiSE, a lightweight and precise approach to predict failures and locate the corresponding faults in multi-tier distributed systems. PreMiSE blends anomaly-based and signature-based techniques to identify multi-tier failures that impact on performance indicators, with high precision and low false positive rate. The experimental results that we obtained on a Cloud-based IP Multimedia Subsystem indicate that PreMiSE can indeed predict and locate possible failure occurrences with high precision and low overhead.
Data loss detector: automatically revealing data loss bugs in Android apps
Conference Paper
In Proc. of the International Symposium on Software
Testing and Analysis, 2020, Pages 141-152
Abstract
Android apps must work correctly even if their execution is interrupted by external events. For instance, an app must work properly even if a phone call is received, or after its layout is redrawn because the smartphone has been rotated. Since these events may require destroying, when the execution is interrupted, and recreating, when the execution is resumed, the foreground activity of the app, the only way to prevent the loss of state information is to save and restore it. This behavior must be explicitly implemented by app developers, who often miss to implement it properly, releasing apps affected by data loss problems, that is, apps that may lose state information when their execution is interrupted. Although several techniques can be used to automatically generate test cases for Android apps, the obtained test cases seldom include the interactions and the checks necessary to exercise and reveal data loss faults. To address this problem, this paper presents Data Loss Detector (DLD), a test case generation technique that integrates an exploration strategy, data-loss-revealing actions, and two customized oracle strategies for the detection of data loss failures. DLD revealed 75% of the faults in a benchmark of 54 Android app releases affected by 110 known data loss faults, and also revealed unknown data loss problems, outperforming competing approaches
From source code to test cases: A comprehensive benchmark for resource leak detection in Android apps.
Journal Paper
Software: Practice and Experience, Volume 49, Issue 3, 2019, Pages 540-548
Abstract
Android apps share resources, such as sensors, cameras, and Global Positioning System, that are subject to specific usage policies whose correct implementation is left to programmers. Failing to satisfy these policies may cause resource leaks, that is, apps may acquire but never release resources. This might have different kinds of consequences, such as apps that are unable to use resources or resources that are unnecessarily active wasting battery. Researchers have proposed several techniques to detect and fix resource leaks. However, the unavailability of public benchmarks of faulty apps makes comparison between techniques difficult, if not impossible, and forces researchers to build their own data set to verify the effectiveness of their techniques (thus, making their work burdensome). The aim of our work is to define a public benchmark of Android apps affected by resource leaks. The resulting benchmark, called AppLeak, is publicly available on GitLab and includes faulty apps, versions with bug fixes (when available), test cases to automatically reproduce the leaks, and additional information that may help researchers in their tasks. Overall, the benchmark includes a body of 40 faults that can be exploited to evaluate and compare both static and dynamic analysis techniques for resource leak detection.
Controlling Interactions with Libraries in Android Apps Through Runtime Enforcement.
Journal Paper
ACM Transactions on Autonomous and Adaptive Systems, Volume 14, Issue 2, 2019, Pages 8:1-8:29
Abstract
Android applications are executed on smartphones equipped with a variety of resources that must be properly accessed and controlled, otherwise the correctness of the executions and the stability of the entire environment might be negatively affected. For example, apps must properly acquire, use, and release microphones, cameras, and other multimedia devices, otherwise the behavior of the apps that use the same resources might be compromised. Unfortunately, several apps do not use resources correctly, for instance, due to faults and inaccurate design decisions. By interacting with these apps, users may experience unexpected behaviors, which in turn may cause instability and sporadic failures, especially when resources are accessed. In this article, we present an approach that lets users protect their environment from the apps that use resources improperly by enforcing the correct usage protocol. This is achieved by using software enforcers that can observe executions and change them when necessary. For instance, enforcers can detect that a resource has been acquired but not released and automatically perform the release operation, thus giving the possibility to use that same resource to the other apps. The main idea is that software libraries, in particular, the ones controlling access to resources, can be augmented with enforcers that can be activated and deactivated on demand by users to protect their environment from unwanted app behaviors. We call the software libraries augmented with one or more enforcers proactive libraries, because the activation of the enforcer decorates the library with proactive behaviors that can guarantee the correctness of the execution despite the invocation of the operations implemented by the library. For example, enforcers can detect that a resource has not been released on time and proactively release it. Our experimental results with 27 possible misuses of resources in real Android apps reveal that proactive libraries are able to effectively correct library misuses with negligible runtime overheads.
A Benchmark of Data Loss Bugs for Android Apps.
Conference Paper
In Proc. of the International Conference on Mining Software Repositories, 2019, Pages 582-586
Abstract
Android apps must be able to deal with both stop events, which require immediately stopping the execution of the app without losing state information, and start events, which require resuming the execution of the app at the same point it was stopped. Support to these kinds of events must be explicitly implemented by developers who unfortunately often fail to implement the proper logic for saving and restoring the state of an app. As a consequence apps can lose data when moved to background and then back to foreground (e.g., to answer a call) or when the screen is simply rotated. These faults can be the cause of annoying usability issues and unexpected crashes. This paper presents a public benchmark of 110 data loss faults in Android apps that we systematically collected to facilitate research and experimentation with these problems. The benchmark is available on GitLab and includes the faulty apps, the fixed apps (when available), the test cases to automatically reproduce the problems, and additional information that may help researchers in their tasks.
FILO: FIx-LOcus Recommendation for Problems Caused by Android Framework Upgrade
Conference Paper
In Proc. of the International Symposium on Software Reliability Engineering (ISSRE), 2019, Pages 358-368
Abstract
Dealing with the evolution of operating systems is challenging for developers of mobile apps, who have to deal with frequent upgrades that often include backward incompatible changes of the underlying API framework. As a consequence of framework upgrades, apps may show misbehaviours and unexpected crashes once executed within an evolved environment. Identifying the portion of the app that must be modified to correctly execute on a newly released operating system can be challenging. Although incompatibilities are visibile at the level of the interactions between the app and its execution environment, the actual methods to be changed are often located in classes that do not directly interact with any external element. To facilitate debugging activities for problems introduced by backward incompatible upgrades of the operating system, this paper presents FILO, a technique that can recommend the method that must be changed to implement the fix from the analysis of a single failing execution. FILO can also select key symptomatic anomalous events that can help the developer understanding the reason of the failure and facilitate the implementation of the fix. Our evaluation with multiple known compatibility problems introduced by Android upgrades shows that FILO can effectively and efficiently identify the faulty methods in the apps.
The Next Generation Platform as A Service: Composition and Deployment of Platforms and Services.
Journal Paper
Future Internet, Volume 11, Issue 5, 2019, Pages 119-139
Abstract
The emergence of widespread cloudification and virtualisation promises increased flexibility, scalability, and programmability for the deployment of services by Vertical Service Providers (VSPs). This cloudification also improves service and network management, reducing the Capital and Operational Expenses (CAPEX, OPEX). A truly cloud-native approach is essential, since 5G will provide a diverse range of services - many requiring stringent performance guarantees while maximising flexibility and agility despite the technological diversity. This paper proposes a workflow based on the principles of build-to-order, Build-Ship-Run, and automation; following the Next Generation Platform as a Service (NGPaaS) vision. Through the concept of Reusable Functional Blocks (RFBs), an enhancement to Virtual Network Functions, this methodology allows a VSP to deploy and manage platforms and services, agnostic to the underlying technologies, protocols, and APIs. To validate the proposed workflow, a use case is also presented herein, which illustrates both the deployment of the underlying platform by the Telco operator and of the services that run on top of it. In this use case, the NGPaaS operator facilitates a VSP to provide Virtual Network Function as a Service (VNFaaS) capabilities for its end customers.
Localizing Faults in Cloud Systems.
Conference Paper
In Proc. of the International Conference on Software Testing, Verification and Validation (ICST), 2018, Pages 262-273
Abstract
By leveraging large clusters of commodity hardware, the Cloud offers great opportunities to optimize the operative costs of software systems, but impacts significantly on the reliability of software applications. The lack of control of applications over Cloud execution environments largely limits the applicability of state-of-the-art approaches that address reliability issues by relying on heavyweight training with injected faults. In this paper, we propose LOUD, a lightweight fault localization approach that relies on positive training only, and can thus operate within the constraints of Cloud systems. LOUD relies on machine learning and graph theory. It trains machine learning models with correct executions only, and compensates the inaccuracy that derives from training with positive samples, by elaborating the outcome of machine learning techniques with graph theory algorithms. The experimental results reported in this paper confirm that LOUD can localize faults with high precision, by relying only on a lightweight positive training.
Link: Exploiting the Web of Data to Generate Test Inputs.
Conference Paper
In Proc. of the International Symposium on Software
Testing and Analysis, 2014, Pages 373-384
Abstract
Applications that process complex data, such as maps, personal data, book information, travel data, etc., are becoming extremely common. Testing such applications is hard, because they require realistic and coherent test inputs that are expensive to generate manually and difficult to synthesize automatically. So far the research on test case generation techniques has focused mostly on generating test sequences and synthetic test inputs, and has payed little attention to the generation of complex test inputs. This paper presents Link, a technique to automatically generate test cases for applications that process complex data. The novel idea of Link is to exploit the Web of Data to generate test data that match the semantics of the related fields, and satisfy the semantic constraints that arise among interrelated fields. Link automatically analyzes the GUI of the application under test, generates a model of the required inputs, queries DBPedia to extract the data that can be used in the tests, and uses the extracted data to generate complex system test inputs. The experimental results show that Link can generate realistic and coherent test inputs that can exercise behaviors difficult to exercise with currently available techniques.
Automatic Testing of GUI-Based Applications.
Journal Paper
International Journal of Software Testing, Verification
and Reliability, Volume 24, Issue 5, 2014, Pages 341-366
Abstract
Testing GUI-based applications is hard and time consuming because it requires exploring a potentially huge execution space by interacting with the graphical interface of the applications. Manual testing can cover only a small subset of the functionality provided by applications with complex interfaces, and thus, automatic techniques are necessary to extensively validate GUI-based systems. This paper presents AutoBlackTest, a technique to automatically generate test cases at the system level. AutoBlackTest uses reinforcement learning, in particular Q-learning, to learn how to interact with the application under test and stimulate its functionalities. When used to complement the activity of test designers, AutoBlackTest reuses the information in the available test suites to increase its effectiveness. The empirical results show that AutoBlackTest can sample better than state of the art techniques the behaviour of the application under test and can reveal previously unknown problems by working at the system level and interacting only through the graphical user interface.
Extracting Widget Descriptions from GUIs.
Conference Paper
In Proc. of the International Conference on Fundamental Approaches to Software Engineering (FASE), 2012, Pages 347-361
Abstract
Graphical User Interfaces (GUIs) are typically designed to simplify data entering, data processing and visualization of results. However, GUIs can also be exploited for other purposes. For instance, automatic tools can analyze GUIs to retrieve information about the data that can be processed by an application. This information can serve many purposes such as ease application integration, augment test case generation, and support reverse engineering techniques. In the last years, the scientific community provided an increasing attention to the automatic extraction of information from interfaces. For instance, in the domain of Web applications, learning techniques have been used to extract information from Web forms. The knowledge about the data that can be processed by an application is not only relevant for the Web, but it is also extremely useful to support the same techniques when applied to desktop applications. In this paper we present a technique for the automatic extraction of descriptive information about the data that can be handled by widgets in GUI-based desktop applications. The technique is grounded on mature standards and best practices about the design of GUIs, and exploits the presence of textual descriptions in the GUIs to automatically obtain descriptive data for data widgets. The early empirical results with three desktop applications show that the presented algorithm can extract data with high precision and recall, and can be used to improve generation of GUI test cases.
AutoBlackTest: Automatic Black-Box Testing of Interactive Applications.
Conference Paper
In Proc. of the International Conference on Software Testing, Verification and Validation (ICST), 2012, Pages 81-90
Abstract
Automatic test case generation is a key ingredient of an efficient and cost-effective software verification process. In this paper we focus on testing applications that interact with the users through a GUI, and present AutoBlackTest, a technique to automatically generate test cases at the system level. AutoBlackTest uses reinforcement learning, in particular Q-Learning, to learn how to interact with the application under test and stimulate its functionalities. The empirical results show that AutoBlackTest can execute a relevant portion of the code of the application under test, and can reveal previously unknown problems by working at the system level and interacting only through the GUI.
Teaching
Throughout my career, I have had the privilege of instructing a diverse range of undergraduate and graduate courses, each designed to inspire critical thinking, creativity, and academic growth. Below, you'll find a selection of both current and past courses that I have had the pleasure of teaching:
Current Teaching
-
Present 2012
Software Specification and Design
The course helps the student to create object-oriented projects through the application of a series of heuristics and principles. In particular, the student will be able to analyze a problem, produce a specification of the requirements, carry out the analysis and design of the solution, produce an implementation of a system that is consistent with a project. Course Website.
Bachelor's degree in Computer Science, University of Milano-Bicocca, Italy.
-
Present 2021
Software Engineering
The course helps the student to advance their expertise in software development by delving into more complex concepts and practices. Students will learn to apply architectural patterns effectively, enabling them to design software solutions that are scalable, maintainable, and resilient. They will also gain proficiency in identifying and rectifying code violations through the use of tools like SonarQube and SonarCloud, enhancing their ability to produce high-quality code. Additionally, the course provides an introduction to DevOps principles and Continuous Integration techniques, empowering students to streamline the development process and collaborate efficiently in modern software development environments. Course Website.
Bachelor's degree in Computer Science, University of Milano-Bicocca, Italy.
-
Present 2021
Design Laboratory
The course facilitates students in acquiring essential skills for software system development through hands-on, experiential activities centered around agile methodologies. Course Website.
Master's degree in Computer Science, University of Milano-Bicocca, Italy.
-
Present 2021
Information Systems
The course helps students to understand the relationships between the organizational, social, economic, business, and technological aspects involved in the design and evaluation of an Information System (SI), and will be able to use standard techniques and models for business process design and information system life cycle assessment. Course Website.
Master's degree in Computer Science, University of Milano-Bicocca, Italy.
Teaching History
-
2016 2015
Programming 1
The course introduces concepts which are the basis of high level programming languages, with a deeper focus on imperative paradigm.
Bachelor's degree in Computer Science, University of Milano-Bicocca, Italy.
-
2014 2013
Software Quality
This course introduces the main testing and analysis techniques that can be used to identify failures and verify the quality of software systems. The course shows how to apply them to solve relevant quality problems, illustrates complementarities and differences among the different techniques, and presents the organization of a coherent quality process.
Master's degree in Computer Science, University of Milano-Bicocca, Italy.
-
2012 2011
Software Engineering
The principal aim of this course is to introduce the software development process, concentrating in particular on the object-oriented analysis and design phases using the unified process and UML modeling language.
Bachelor's degree in Computer Science, University of Milano-Bicocca, Italy.
-
2012 2010
Concurrent and Distributed Paradigms
The principal aim of this course is to gain knowledge of the internal structure of operating systems, concurrency models and distributed architectures, and wireless networking technologies.
Bachelor's degree in Computer Science, University of Milano-Bicocca, Italy.
-
2012 2010
Algorithms and Programming
The course aims to teach object-oriented programming and elements of software design. At the end of the course the student is expected to model a problem following the object-oriented paradigm and, then, to translate the model into a corresponding program written in an object-oriented language.
Bachelor's degree in Mathematics, University of Milano-Bicocca, Italy.
-
2010 2009
Complex System Design
This course attempts to bring to students the core mathematical concepts of Process Calculi without losing sight of the practical needs of the software programmers and analysts. It will cover basic techniques to describe the form and meaning of program terms and to reason about them.
Master's degree in Computer Science, University of Camerino, Italy.
-
2010 2006
Software Engineering
The course is designed to present software engineering concepts and principles in parallel with the software development life cycle concentrating in particular on the object-oriented analysis and design phases using the unified process and UML modeling language.
Bachelor's degree in Computer Science, University of Camerino, Italy.
-
2006 2005
Elements of Computer Science
The course is designed to provide a background knowledge on computer science in order to understand how a computer works and its structure (hardware and software), the fundamental concepts of networking (Internet in particular), and essential notions of programming.
Bachelor's degree in Mathematics, University of Camerino, Italy.
Projects
These highlighted projects represent my unwavering commitment to advancing technology and addressing complex challenges through innovative research initiatives. While the list is not exhaustive, my primary focus on software engineering underscores my dedication to pushing the boundaries of research and driving positive change in the field.
Current Projects
-
Funding: PNRR CN1 spoke 9
Time frame: 2023 -
HPC and Big Data, along with innovative models and algorithms, present opportunities to tackle complex challenges in smart cities and digital societies. The Spoke initiative aims to overcome these challenges by leveraging digital twin concepts to create accurate representations of social, organizational, and physical structures within cities and communities. By utilizing big data analytics, AI techniques, and advanced simulations supported by HPC infrastructure, this spoke seeks to understand, predict, and influence city dynamics. Its objectives include foundational research, identifying application domains, and collaborating with partners to experiment and evaluate solutions. The initiative focuses on five application domains: Health and Lifestyle, Mobility, Socio-economic analysis, Infrastructure and services, and Environment. Spoke pursues three research lines: Modelling (AI, computational social science), Computing (IoT, cloud, edge systems), and Software systems (system software platforms, AI algorithm prototyping).
This initiative is funded by the Centro Nazionale HPC, Big Data e Quantum Computing (PNRR CN1).
read more... -
Funding: "Dipartimento di Eccellenza 2023-2027" grant
Time frame: 2023 -
AI has immense potential to improve human lives, provided it adheres to ethical, reliable, safe and sustainable standards. Pioneering research conducted at the University of Milan-Bicocca is dedicated to advancing the development of AI systems by prioritizing open science principles. This holistic project includes rigorous foundational and applied research, as well as extensive dissemination work and specialized training programs. By placing a deep emphasis on research, we aim to respond effectively to the needs of society and promote the rising of new AI experts who can shape a brighter future.
This project is founded by Ministry of University and Research (IUR) under the grant "Dipartimenti di Eccellenza 2023-2027"
Past Projects
-
Funding: H2020-EU.1.1.
Time frame: 01/01/2019 - 30/06/2020
Verifying the correctness of software systems requires extensive and expensive testing sessions. While there are tools and methodologies to efficiently address unit and integration testing, system testing is still largely the result of manual effort.
Testing software applications at the system level requires executing the applications through their interfaces to verify the correctness of their functionalities and stimulate all their layers and components. Automating just part of this process can dramatically improve the effectiveness of verification activities and significantly reduce development costs, relevantly alleviating developers from their verification effort.
This project addresses the development of a pre-commercial tool that has the unique capability of efficiently and automatically generating semantically-relevant system test cases equipped with functional oracles.
read more... -
Funding: 2015 MiUR-PRIN grant (n.2015KWREMX)
Time frame: 01/01/2017 - 30/06/2020
The GAUSS project will deliver the methodological enablers required to identify, integrate, and manage “emergent” Systems of Systems (eSoS). These require dynamic and opportunistic engineering due to their intrinsically variable nature tied to their scale and heterogeneity. GAUSS will release a set of integrated technologies to address these engineering problems of eSoS at runtime, when specific execution contexts may invalidate design-time solutions. GAUSS will govern eSoS by enriching initial lightweight designs with concrete and contextualised aspects obtained from the runtime context.
This project is founded by Ministry of Education, University and Research (MIUR) under the call Research Projects of National Interest (PRIN).
read more... -
Funding: H2020-EU.1.1.
Time frame: 01/10/2015 - 30/09/2019
Modern software systems must be extremely flexible and easily adaptable to different user needs and environments. Such flexibility requirements are so important that it is indeed common practice to develop applications that can be updated, modified and adapted in the field, directly by the end- users. However, this flexibility also introduces relevant quality issues. Almost all computer users have had the unpleasant experience to watch their favorite applications fail and crash frequently after an update. These problems are so common that is sufficient browsing the Web to find millions of reports about failures observed after updates and incompatibilities caused by the interaction of a newly installed component with the existing components. Even worse each of these problems affected a population of thousands of users.
The impact of problems introduced by end-users (e.g., the installation of a new plug-in) can be dramatic because end-users can easily modify applications, like developers do, but end-users have neither the knowledge nor the skill of developers, and they cannot debug and fix the problems that they unintentionally introduce. It is thus necessary to timely develop novel solutions that can increase the reliability of the moderns systems, which can be extended and adapted by end-users, with the capability to automatically address problems that are unknown at development-time.
The Learn project aims to produce innovative solutions for the development of systems that can work around the problems introduced by end-users when modifying their applications. The three key elements introduced by Learn to automatically produce a (temporary) fix for the software are: (1) the definition of the InternetLearn infrastructure, which is a network infrastructure that enables communication between every individual instance of a same program running at different end-users' sites, thus augmenting each application with the capability to access a huge amount of information collected in-the-field from other sites; (2) the definition of analysis techniques that can learn the characteristics of successful and failed runs by monitoring executions in the field from a number of instances running at many end-user sites; and (3) the definition of techniques for the automatic generation and actuation of temporary fixes on an Internet (World) scale.
read more... -
Funding: EU H2020-ICT-2016-2017
Time frame: 01/06/2017 - 31/08/2019
Cloud innovations have had a major impact on the IT industry but not yet on networks. The danger is that 5G will be a niche industry providing basic connectivity for the cloud applications and services boom. The NGPaaS project envisages 5G as: a build-to-order platform, with components, features and performance tailored to a particular use case; developed through a “Dev-for-Operations” model that extends the IT industry’s DevOps approach to support a multi-sided platform between operators, vendors and verticals; and with revised Operational and Business Support Systems (OSS/BSS) to reflect the new parameters and highly dynamic environment. NGPaaS can enable 5G to become central to a cooperative future with cloud developers, by removing the technological silos between the telco and IT industries. NGPaaS builds on 5G-PPP phase 1 projects and lays the foundation for large-scale phase 3 deployments and industrial usage, through a stepped validation of several Telco, IoT/vertical and combined scenarios culminating in a live test in Paris-Saclay campus that can incorporate innovative SMEs selected for showcasing NGPaaS’s operational, service and business benefits.
This project has received funding from the European Union’s H2020-ICT-2016-2017 Programme under grant agreement n° 761557
read more... -
Funding: 2012 MiUR-PRIN grant (n.2012E47TM2)
Time frame: 01/05/2015-31/10/2015
This project aims at studying adaptive and self configurable systems by developing an integrated approach to the design and the evolution of such systems, in a software engineering perspective. Software-intensive systems are increasingly called to cope with highly dynamic environments in which resources (such as energy, computing and storage infrastructures, network bandwidth) change continuously and in unpredictable ways, and might even be unknown at design time entailing a growing need for adaptation and self-evolution capabilities. Since adaptation is becoming a core aspect of an increasing number of systems, it should emerge in all phases of the life-cycle.
Software should be designed for adaptability, tested for adaptability, configured and maintained for adaptability. The classic boundary between design approaches and runtime infrastructure fades: models traditionally used at design time shall be made available at runtime to enable late verification, which in turns supports adaptation. Similarly, data collected at runtime may be reflected in changes to the design time models to avoid undesirable behaviors. The presence of independent adaptation mechanisms at various abstraction levels calls for new coordination mechanisms that shall avoid unstable behaviors and violations to key properties.
In the last few years researchers have focused on adaptability-related topics and all the units presenting this proposal have ongoing works in the field. However, we still lack a unified framework leading to a novel life cycle spanning development and runtime for self-adaptive systems. The project proposes a new framework encompassing applications and platforms guaranteeing sound adaptability at different abstraction levels that cope both with changes in the environment and runtime evolution of the execution platforms. The former is the case of virtualized environments like cloud computing and service based systems, while the latter is the case of cyber physical systems. The new framework will be organized in two layers: (i) a methodological and linguistic layer, related to how to develop, represent, verify, and validate adaptable software and (ii) a runtime and evolution layer, related to the environment that supports execution of self-adaptive software, possibly integrating legacy code. The added value of this project proposal is to bring the separate, but largely complementary, knowledge of the involved partners together to define an integrated process that deals with adaptation within the software life-cycle using different techniques and granting mechanisms to trace adaptability-related requirements all through the development, deployment, runtime execution and evolution of a system. The proposers are in the position to fully achieve the goal, since they are already studying specific perspectives of this comprehensive problem and the proposed project will allow to factorize the competences acquired so far to fully exploit their synergies.
This project is founded by Ministry of Education, University and Research (MIUR) under the call Research Projects of National Interest (PRIN)
-
Funding:Huawei Technologies Co., Ltd.
Time frame: 01/05/2014 - 30/04/2015
In telecom industry, the deployment of new communications services often requires a long and expensive development process and often relies on new proprietary software running on new purpose built hardware making it difficult for Communications Service Providers (CSPs) to keep up with the competitive pressure of the rapidly changing market of the communications services.
Network functions virtualization (NFV) is an initiative driven by several large CSPs that aims to leverage commercial off-the-shelf (COTS) systems, cloud technologies and dynamic service chaining to allow dynamic provisioning, deployment and configuration of communications services, while also enabling service personalization. This in turn would enable the reduction of cost in development and provide faster time to market for new and differentiated services.
The challenge is to adapt cloud technologies to the telecom industry requirements of high reliability, low latency, and the ability to scale to support millions of users. Cloud systems must be adjusted to meet the specific reliability requirements in the telecom environment, where services cannot be down for more than 5 minutes over the span of an entire year (i.e. 99.999 percent availability). End users naturally expect services offered via cloud technologies to deliver at least the same reliability and availability as traditional communications service implementation models.
The project focuses on the development of new approaches to failure prediction and self-healing for virtualized Telecom systems in order to meet the high availability and reliability requirements of telecom services, such as VoIP services.
This research project was entirely funded by Huawei Technologies Co., Ltd. and conducted by the University of Lugano
-
Funding: EU FP7-ICT (Grant agreement ID: 257647)
Time frame: 01/07/2010 - 31/10/2013
Software for networked systems is usually not written all at once, but is built incrementally, due to several reasons, such as maintenance (fixing errors and flaws, hardware changes, etc.) and enhancements (new functionality, improved efficiency, extension, new regulations, etc.). Changes are done frequently during the lifetime of most systems and can introduce software errors that were not present in the old version, or expose errors that were present before but did not get exercised. In addition, upgrades are done gradually, so the old and new versions have to co-exist in the same system. PINCETTE focuses on networked systems that have high reliability requirements. In these systems, the correctness of the system has to be re-validated after any upgrade or change. Currently, error detection relies on the execution of extensive test suites, which is very time consuming, and thus, expensive; fault localization is mainly manual and driven by experts' knowledge of the system; fault fixing often introduces new faults that are hard to detect and remove. Moreover, upgrading one node in a networked system is extremely risky, as it can potentially cause a crash in the whole system. In addition, the cost of this validation dominates the maintenance costs of the software.
The vision of PINCETTE is to solve the problem of high cost of changes by introducing an automated framework and methodology, and a mix of technologies to identify the impact of changes that derive from intra-component changes (due to error fixing and functionality enhancement) and from component replacement within a single product and a product family. This methodology improves the reliability of networked software by implementing an innovative solution for the automatic detection, localization, and repair of program bugs.
This project was founded under the European Commission's FP7 Work Programme.
read more...
Contact Me
Contact & Meet Me
I would be happy to talk to you if you need my assistance in your research or whether you need professional support for your company.
- office: 0039-02-6448-7821
- lab: 0039-02-6448-7853
- oliviero.riganelli@unimib.it
- oliviero.riganelli@gmail.com
- oliviero.riganelli
- it.linkedin.com/in/origanelli
At My Office
You can find me at my office located at the Computer Science Department of the University of Milano Bicocca. The office is at the second floor, room 2015.
I am at my office every day from 9:00 until 18:00 pm, but you may consider a call to fix an appointment.
At My Lab
If I am not in my office, chances are I am in the Laboratory of Test and Analysis (LTA) located at the Computer Science Department of the University of Milano Bicocca. The laboratory is at the ground floor, room T033-T034.