What differentiates professional software system development from dilettantish programming is the attention to quality, e.g. robustness and flexibility. Building a software system is in fact a very different task from simply assembling parts realized with various software technologies (like Applets, Servlets, Java Beans, JSPs, and so on). A software system must be carefully engineered, in order to show a high-quality structure. Principles characterise quality structures, and strategies and techniques are required in order to satisfy principles. The great success obtained by software Design Patterns in the software developer community witnesses the importance of this approach to software systems design. A Design Pattern describes how design strategies resolve the involved forces, in order to produce a high-quality solution to a common problem in a given context.
My research interests are in Software Engineering and my aim is to investigate:
- new ways to improve software structure modularity by means of Advanced Separation of Concerns;
- adaptation of Agile Software Development Methodologies to a distributed team;
- formal foundation of Design Patterns.
Separation of Concerns is one of the keys to successful software modularisation, but it is necessary to separate exactly the concerns one needs to deal with, in order to produce the right modularisation. The design style supported by OO is one of decomposing a system by means of parts with well-defined responsibilities. But there are many aspects that don’t align with this kind of modularisation (e.g. persistence, real-time constrains,...). These aspects are then scattered across multiple classes and code results in a tangled mess of instructions. This increases the impact of change and reduces comprehensibility. Advanced Separation of Concerns (AOP, AP, SOP, GP, MDSoC) enhances the OO approach by providing separation along various concerns.
My interest is in studying how is possible to obtain flexible structures by means of this new approach: decomposition/composition techniques, principles, strategies and patterns.
Agile Methodologies for Distributed Teams
Software development is often characterised by the volatility of requirements. This is particularly true in the context of business applications. Heavyweight Methodologies are based on a control and prevent defects approach: they are predictive and have a lot of rules, practises, documents and up-front plans. On the contrary, Agile Methodologies are adaptive: they embrace change, trying to adapt software in a responsive way to frequent changes. They have only few, but effective, rules and practises and don’t produce a lot of up-front plans. They adopt an iterative and incremental process strategy, trying to create feedback as early as possible, in order to improve subsequent iterations.
I'm interested in studying how Agile Methodologies can be adapted to internationally distributed teams (offshore development), with particular attention to XP (Distributed Extreme Programming -- DXP).
Formal Foundation of Design Patterns
A Pattern is much more than a proven solution to a problem in a context! I'm interested in a formal foundation of Design Patterns (and more generally of Design) based on the analysis of the geometrical structure of software.
The idea of flexibility is strictly related to that of symmetry. Many programming languages constructs express symmetry, but when they fail to solve particular design problems, Patterns can help to solve them. It can be shown that patterns operate redistributing symmetry locally (Coplien-Zhao theory). That is how Pattern Languages build structures (wholes with the Quality Without a Name -- in Christopher Alexander's words) through a process of piecemeal growth and local adaptation.