Research Activities



Empirical Software Engineering

We are interested in all the aspects of the empirical software engineering ranging from simple experiments with students to more complex industrial case studies and surveys. Empirical software engineering is a field of research that emphasizes the use of empirical studies to accumulate knowledge in the context of software systems. Analyzed objects can be software artifacts, processes, techniques, methods or tools. Collected data during experiments or interviewing practitioners can be analyzed using well-established techniques such as statistical analysis. Our goal is to assess and improve practitionersí tools, methods and performance.

Automated Software Testing

Test automation is a sub-area of software testing in which special software or frameworks are used to control the execution of test cases. The main advantage of test automation comes from fast, unattended execution of a set of test cases after some changes have been made to a software system. We apply test automation at user acceptance testing level in several contexts such as: Desktop, Web and Mobile applications. We are particularly interested in: reducing the test case fragility, developing robust locators and automatically repairing/generating test cases. Currently, we are investigating DOM-based testing tools (e.g., Selenium WebDriver) and Image recognition testing tools (e.g., Sikuli and JAutomate) for Web/Mobile applications.

Advanced Features for Software Reuse

We investigate language constructs which improve software extensibility and adaptability, going beyond inheritance as in the object-oriented paradigm. We focus on Java-like languages, and on proposals which do not even include inheritance in favour of modular composition as primary mechanism for structuring code. We investigate deep operators, that is, operators which allow manipulation (e.g., renaming or duplication) of a nested class at any level of depth. Moreover, we consider disciplined meta-programming features, that is, programmers can write meta-expressions that combine class definitions by the operators. This provides an effective language support for active libraries: namely, a (library) class can provide a method returning a customized version of a class, depending, e.g., on the execution platform. We adopt incremental typechecking techniques, which provide a good compromise between extreme expressiveness with no static type checking, and strong type system with only limited meta-programming capability. In particular, our technique ensures an important property, called meta-level soundness, stating that typing errors never originate from already compiled (meta-)code, that is, programmers can safely use (active) libraries.

This research is carried out in collaboration with Victoria University of Wellington, New Zealand.

Foundations of Dynamic Binding

We study foundational calculi which support both standard static binding as in the lambda-calculus, done on a positional basis, and dynamic (re)binding, which is done through names which do not obey alfa-equivalence. We investigate mechanisms for incremental rebinding, which makes possible code specialization, and for manipulation of rebindings as first-class values. We design sound type systems for such calculi. This work provides unifying foundations for, e.g,:

  • dynamic scoping in programming languages
  • rebinding of mobile code, for example when a marshaled value is received from the network, containing identifiers that must be rebound to local resources
  • meta-programming and component-based programming features.

This research is carried out in collaboration with University of Piemonte Orientale.