Marco Papacchini

Welcome

Today industry requires the rapid development of high quality, very large, mission-critical software systems in a turbulent business and technology environment, which is subject to frequent changes. E/m-commerce represents a typical example of this context. Still too many systems are rigid and defect change.

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:

Software Sructure

«To my taste the main characteristic of intelligent thinking is that one is willing and able to study in depth an aspect of one’s subject matter in isolation, for the sake of its own consistency, all the time knowing that one is occupying with only one of the aspects. The other aspects have to wait their turn (...). I usually refer to it as Separation of Concerns because one tries to deal with the difficulties, the obligations, the desires and the constrains one by one»
(E.W. Dijkstra)

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

«Traditional software development is great...except that it doesn’t work!»
(Martin Fowler)

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

«By keenly confronting the enigmas that surround us and by considering and analysing the observations that I have made, I ended up in the domain of Mathematics»
(M.C. Escher)

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.

© Copyright Marco Papacchini