Software patterns are proven solutions to recurring software construction problems in a given context. They describe the knowledge refined from experienced practitioners about a particular aspect of the domain of discourse. The concept of design pattern was formulated in  and has since been generalised in for example . The practical employment of patterns in software development has continuously grown .
Patterns are generally intended for human/manual use, as structured but informal documentations. Their primary aim is to guide software engineers, by presenting and explaining solutions regarding software construction applicable to a particular context. They are means of structuring solution descriptions. From this angle, therefore, they could be regarded as codes of good practice. This is the perspective that we take in this paper. In this context, patterns are presented in printed catalogues, employing mainly natural language, but also examples of code and diagrammatic representations.
Patterns can occur at different levels of abstraction with respect to the specification of a software solution. Thus, there may be architectural patterns, design patterns in a specific design paradigm (e.g. observer and composite  in the OO paradigm) and language-specific patterns (e.g. counted body  in C++, and marker interface in Java). The latter can also be called idioms. Furthermore, software patterns may have different degrees of generality. Some may be application or domain specific (e.g., contract and portfolio  in trading applications), whereas others may be general design patterns, applicable across application domains (e.g. observer and composite).
In recent years, software development using patterns has become common practice in the practitioners' community . Subsequently, the amount of refined patterns is growing, irrespective of their category--from general language-specific patterns to application specific patterns. However, it is towards the application-domain end that a high rate of growth is expected. The amount of printed documentation, thus, too, is increasing, to the extent that it becomes difficult for it to be effectively used. The problems that appear in this context are similar to the problems faced by engineering designers who have to comply with large codes of regulations and good design practice, which we have already discussed in .
We aim to develop tools for intelligent dissemination of patterns to software practitioners. We propose a general model that is applicable to patterns disregarding their level of abstraction (specification) and generality (application domain). On its basis we will implement specific solutions for different categories of patterns. We are here adapting some of the solutions we have proposed previously for the dissemination and enforcement of regulatory engineering-design knowledge (e.g., ) to the domain of software engineering and software patterns.
Research has been investigating the possibility of automatic code generation from formal representations of software patterns . The goal, according to this approach, is to reduce as much as possible the involvement of the human agent from the design and implementation process. This may be feasible for restricted areas. However, our standpoint is to develop tools that empower rather than replace the software practitioners; ``patterns should not, cannot and will not replace programmers'' . This is consistent with our previous work in intelligent design .