Abstract. Software architectures and designs "notations " are typically based on bubble-and-arc diagrams. Embellishing these diagrams may increase their information content but does not make a language. A formal language has syntax, semantics, and inference rules, so that reasoning and automatic manipulation are made possible. We describe LePUS, a formal language for describing and reasoning about object oriented software architectures, designs, and patterns. A LePUS formula imposes constraints on the software at an appropriate level of abstraction but does not unnecessarily restrict the implementation. LePUS is not an ad hoc collection of loosely related concepts but instead originates from an insight on a small number of necessary and sufficient basic "building blocks " that are ubiquitous in object oriented design. A LePUS specification can be expressed as either a formula or a semantically equivalent diagram. We provide examples of LePUS descriptions ranging from simple design patterns, such as FACTORY METHOD, to popular current architectures, such as Enterprise JavaBeans™.

In re-engineering object-oriented legacy code, it is frequently useful to introduce a design pattern in order to improve specific non-functional requirements (e.g., maintainability enhancement). This paper presents a methodology for the development of a quality-driven re-engineering framework for object-oriented systems. First, a catalogue of design motifs (primitive design pattern transformations) is presented. Then, the transformations for the design patterns in the GoF book are defined as a composition of these primitive transformations. Non-functional requirements for the migrant system can be encoded using soft-goal interdependency graphs and can be associated with design pattern transformations that are applied for the migration of an object-oriented legacy system. 1

The ultimate goal of all computer science is the program. The performance of programs was once the noblest function of computer science, and computer science was indispensable to great programs. Today, programming and computer science exist in complacent isolation, and can only be rescued by the conscious co-operation and collaboration of all programmers. The universities were unable to produce this unity; and how indeed, should they have done so, since creativity cannot be taught? Designers, programmers and engineers must once again come to know and comprehend the composite character of a program, both as an entity and in terms of its various parts. Then their work will be filled with that true software spirit which, as “theory of computing”, it has lost. Universities must return to programming. The worlds of the formal methods and algorithm analysis, consisting only of logic and mathematics, must become once again a world in which things are built. If the young person who rejoices in creative activity now begins his career as in the older days by learning to program, then the unproductive “scientist ” will no longer be condemned to inadequate science, for their skills will be preserved for the programming in which they can achieve great things. Designers, programmers, engineers, we must all return to programming! There is no essential difference between the computer scientist and the programmer. The computer scientist is an exalted programmer. By the grace of Heaven and in rare moments of inspiration which transcend the will, computer science may unconsciously blossom from the labour of the hand, but a base in programming is essential to every computer scientist. It is there that the original source of creativity lies. Let us therefore create a new guild of programmers without the class-distinctions that raise an arrogant barrier between programmers and computer scientists! Let us desire, conceive, and create the new program of the future together. It will combine design, user-interfaces, and programming in a single form, and will one day rise towards the heavens from the hands of a million workers as the crystalline symbol of a new and coming faith. 1 1

As software projects continue to grow in scale and scope, it becomes important to reuse software. An important kind of reuse is extensibility, i.e., the extension of software without accessing existing code to edit or copy it. In this paper, we propose a rigorous, semantics-based definition of software extensibility. Then we illustrate the utility of our definitions by applying them to several programs. The examination shows how programming style affects extensibility and also drives the creation of a variant of an existing design pattern. We consider programs in both object-oriented and functional languages to prove the robustness of our definitions. 1 Introduction As software projects have continued to grow in scale and scope, it has become increasingly important to reuse program components. Reuse lowers software development costs by reducing development time, decreasing the number of errors, and increasing the consistency of software systems. In short, there are compelling reasons...

A detailed case study in the representation of the STATE design pattern [1] serves us in providing an intuitive introduction to LePUS -- a symbolic logic language for the specification of recurring motifs in object oriented architectures. LePUS' constructs express accurately and concisely fundamental elements of O-O architecture, such as inheritanceclass -hierarchies, and correlations, such as isomorphisms between methods, classes, and hierarchies. Employing both the graphic and textual versions of our specification language, we explain in detail the formal representation of the STATE pattern and of a sample implementation thereof. We supply three examples for the utility of LePUS: Tool support, validation of pattern satisfaction, and refinement relation between patterns. Index terms: Object oriented design, design patterns, formal methods, software architecture 1. Introduction LePUS [2] is a higher order monadic logic [3] language for the specification of recurring motifs iv in ob...

A design pattern describes a structure of communicating components that solves a commonly occurring design problem. Designing with patterns offers the possibility of raising the abstraction level at which design is performed, with improvements in clarity, understanding, and facility of maintenance of applications. However, in their most common presentation, design patterns are informal pieces of design process, which application is not reflected in the operational system, and the potential advantages of a more principled design are not realized. This work proposes to organize design in such a way that pattern applications remain explicit in the operational systems. A reflective architecture is proposed, where patterns are reified as metalevel constructs. Keyword: design patterns - metalevel architecture - metaobjects-computational reflection C.Marcos et al., Reifying Design Patterns ..., EJS, 2(1) 17-29(1999) 18 1. Introduction The continuous evolution in information te...

: Most of the study of patterns has been restricted to the composition of "new" patterns. These authors, however, believe that the investigation of design patterns is ripe for an endeavor at an underlying formal conceptual framework. In this article we address future directions in the investigation of design patterns and stress the significance of precise specifications. We also propose our own approach at precise specification of design patterns. Keywords: Tool support for design patterns, formal methods, metaprogramming 1. Introduction Patterns and design patterns have been attracting great interest within the OOP community and the general software industry. Their research is, however, yet at its cradle, and effort is mostly constrained to the definition (or discovery) of new software patterns (see pattern mining [GoV 96]). It is the humble opinion of these authors that much benefit can be gained from the study of other questions that would typically be classified as second-order ...

The paper presents the reection facilities of the speci cation language Slam-sl. Slam-sl is an object oriented speci cation language where class methods are speci ed by pre and postconditions. The reection capabilities permit managing these pre and postconditions in speci cations what means that semantic reection is possible. The range of interesting applications is very wide: formal speci cation of interfaces and abstract classes, speci cation of component based software, formalization of design pattern, using Slamsl as a pattern language, etc. The paper discusses the last two advantages in some detail.

Software development raise the need for traceability, i.e. the ability to control the consistency between software artifacts produced at different stages of the software life-cycle. This traceability cannot be obtained without a systematic transformational approach to software development. In this paper, we present a new approach to the correct stepwise refinement of UML static and dynamic design models based on refinement schemas. A refinement schema is composed of two compartments. The first compartment describes the abstract model of the design and the second compartment shows its corresponding detailed model after application of one design pattern. We propose also a number of correct smaller transformations called micro-refinements. These micro-refinements can be composed to produce correct refinement schemas. Our approach supports documentation and traceability, enhances evolvability, and helps automating detailed design.

this article, the interested reader may refer to work [17]