The information technology market is characterized by rapid changes, both caused from technology evolution and the difficulties in transferring the new technologies in both products and processes. On the other hand the software industry is facing an ever increasing demand for new and more sophisticated applications, direct expression of new customer expectations concerning software applications.

The interest in the software process and in its development dynamics has grown in these last year as a response to the need to increase productivity and quality, while reducing time-to-market and taking into consideration maintenance aspects. But it has not (yet) reached the expected results, and every day software projects overrun the estimated budget and schedule, or at worse they are stopped.

Is this the ever-green software crisis? Is there a final solution to the problems of software industries?

Software firms seem to face a chronic disease that results in the inability to adequately respond to the market demand. It is the natural adaptation to the evolution and rapid changes that both the external environment and the internal conditions are undergoing .

Together with this movement towards a formalized and controlled software process, different methodologies and techniques have been proposed in order to solve specific problems and to improve the development activity. Software reuse, first proposed in ’68 in the seminal work of McIlroy, is one of the most interesting techniques. It promises to achieve a reduction in development costs and times, while increasing product quality and maintainability. But these expectations have not yet been fully exploited by software firms. Domain Analysis, the process by which information in the software life-cycle is identified and packaged aiming to make it reusable, is another technique for improving the software process, but like software reuse it has not encountered the expected diffusion in the industries. Many other examples exist, with more or less fortune. An object oriented technique is one of the most known and it has achieved a considerable diffusion and adoption.

Frameworks are macro-components developed as systems of objects, such as classes, that cooperate modeling a functionality or a relevant domain feature. Software architectures represent the underlying high-level model of the applications in a domain and are composed by the frameworks that model the functionalities exposed by the applications. Reusable components are assembled in frameworks in order to implement the functionality modeled by the framework itself and allow to tailor and customize the applications following customer needs.

Another buzzword that is rapidly spreading its diffusion in the software industry is pattern. A pattern is "the repeated or regular way in which something happens or is done" or "an arrangement of entities or shapes in which the same entity or shape is repeated in a regular way" or still "a model or diagram that you can use as a guide when you are making something or for dealing with a problem". A design pattern, following the approach of Alexander, is a general and proven solution to a specific problem in a defined context with given bounds and constraints.

These techniques are the expression of a shift of the interest in software reuse from code and small components to high level and abstract artifacts that embody a relevant piece of knowledge and design in the software life-cycle. This continuous research in the reuse practices for the best trade-off between development effort and return on the investment influences the underlying software process.

This software process is based on the production of frameworks, and in general delivers to the customer applications made up by assembling reusable assets following domain architectures. Its institutionalization fosters the shift of the organization toward the ‘software factory’ model well outlined by Basili. Framework, architectures and patterns are a privileged way to treasure the expertise gained in the software life-cycle, formalizing design issues and solutions. On the other hand, these techniques came up again with the problem of inter-personal and inter-team communication and coordination.

Considering software reuse, frameworks and pattern have many noticeable effects:

• developing software applications by composing frameworks following a reference architecture and assembling the reusable components into the frameworks increase the efficiency of the reuse practices, reducing at the same time development effort;
• frameworks and architectures enhance the modularity and the structuring of the applications, encapsulating the implementations details into interchangeable components and fostering the locality principle; moreover the ‘interface’ concept contributes to the division into modules of the applications;
• applying design patterns and using proven frameworks and architectures improve the robustness and the quality of the application; besides it is possible also for people with scarce experience in a specific field to produce a good application following publicly available design patterns and employing off-the-shelves frameworks and architectures;
• frameworks and architectures foster interoperability and communications among different products.

This list is not exhaustive but presents some of the benefits that frameworks, architectures and patterns can exploit when applied in the software process to support software reuse.

The papers presented in this special issues contribute to highlight the real potential of these technique, describing how frameworks and patterns can provide a relevant benefit when used in the software process and integrated in a broader and structured reuse program.

The first work " Domain Analysis and Framework-based Software Development" by Valerio, Succi and Fenaroli introduces the problem of framework and architecture extraction in the software life-cycle, in particular highlighting the importance of domain analysis methodologies in the analysis and formalization of knowledge and expertise build up in the software process. This paper also presents a case study carried out in a software firm on the applications of domain analysis for the extraction and development of reusable frameworks. Morandin and Zorer in their paper "An OO Framework in the Bulk Data Transfer Domain" give a different view on framework extraction basing on a custom methodology named SODA and describing the development of a framework fo rthe Bulk Data Transfer Domain. "The evaluation of framework reusability" by Cardino, Baruchelli and Valerio focus on the analysis of the effects that frameworks and patterns have on software reuse, proposing a set of criteria suitable for measuring the reusability of frameworks. The paper " From Process Modeling to Domain Modeling" by Benedicenti, Succi and Vernazza draws upon the authors’ experience in organizational process analysis and modeling, and concludes this issue presenting a broader view of frameworks, architectures and patterns at the process level.