Agile Software Assistance

Asa-logo.pngAgile Software Assistance is a project funded by the Swiss National Science Foundation (SNF project 200020_181973.) The project is a continuation of Agile Software Analysis

Funding:368’517 SFr.
Period:Feb 1, 2019 - Apr. 30, 2022
Project partners:RMod group, INRIA, Lille, France
Dr. Mohammad Ghafari, U Bern, Switzerland
Dr. Tudor Girba, feenk GmbH, Bern, Switzerland
Collaborating teams:REVEAL research group, University of Lugano, Switzerland
PLEIAD lab, University of Chile, Santiago, Chile
LOOSE Research Group, Timisoara, Romania
Dr.Sebastiano Panichella, ZHAW, Winterthur, Switzerland
KeywordsSoftware evolution; Meta-modeling; Clone detection; Software architecture

Summary

As software systems evolve, developers struggle to track and understand the vast amount of software information related to the software source code itself, the application domain, its quality concerns, changes to the underlying infrastructure, and the software ecosystem at large. Mainstream integrated development environments (IDEs) offer only limited support to advise the developer during common development tasks, mainly in the form of so-called “quick fixes” related to purely technical aspects of the programming language. This continuation of our ongoing SNSF project1 will explore these issues in the following four thematically related PhD tracks:

  • Speculative software analysis. In this track we tackle the research question: “How can software information be speculatively analysed, and results be automatically presented that are relevant to the developer’s task at hand?” Developers are confronted with large amounts of software data: versions of the software itself, documentation, used libraries and frameworks, contents of the issue tracker, and all related information about the software ecosystem. Although some analysis tools exist, developers are often not aware of what tools or data might be useful to support which tasks, and relevant tools are typically not part of the standard IDE. We envision an automated developer support that proactively offers analysis results tailored to the current development context.
  • Executable domain models. Here we explore the question: “How can domain models be specified and deployed as executable software artifacts suitable for testing, expressing requirements, and driving design and implementation?” Domain knowledge is at the core of any software development process, and is essential for requirements analysis, object-oriented design, and management of software evolution. However domain models are often manifested only as static documentation that rapidly diverges from reality as the software system evolves. Although model-driven approaches have had some success, their application is largely limited to domains where changes are well-understood so models can be automatically transformed to code. Instead of transforming models to code, we imagine an approach in which executable domain models are developed throughout the software life cycle, and form an integral part of the system under development.
  • Domain-specific software quality. In this track we address the question: “How can domain-specific quality concerns and their corresponding corrective actions be effectively specified and monitored?” As a software system evolves, there may be important quality aspects of which the developer may only have passing knowledge, such as the security impact of certain implementation choices. We envision a system that actively monitors such domain-specific quality concerns and advises the developer of possible corrective actions. We plan to focus mainly on security issues in Android software, an area where we have achieved some very promising initial results.
  • API client migration. As software systems evolve, client software that depends on them must be adapted to the evolving Application Programming Interfaces (APIs). Here we plan to study the question: “What is a suitable model for specifying, reasoning about, and automating API client migration?” Although strides have been made in automating certain kinds of adaptations, generally API migration is poorly supported in practice. We imagine a system in which migrations can either be automated, or supported by tools that systematically guide developers in the migration. We will analyze various case studies of past API migrations to better understand the potential for automated migration, and carry out experiments to assess such migration schemes.

For more information, please consult the Research Plan of the project [pdf].

Last changed by oscar on 4 February 2019