Previous automated approaches to discovering design patterns in source code have suffered from a need to enumerate static descriptions of structural and behavioural relationships, resulting in a finite library of variations on pattern implementation. Our approach, System for Pattern Query and Recognition, or SPQR, differs in that we do not seek statically to encode each pattern and each variant that we wish to find. Our system finds patterns that were not explicitly defined, but instead are inferred dynamically during code analysis by a theorem prover, providing practical tool support for software construction, comprehension, maintenance, and refactoring. We use a logical inference system to reveal large numbers of patterns and their variations from a small number of definitions by encoding in a formal denotational semantics a small number of fundamental OO concepts (elemental design patterns), encode the rules by which these concepts are combined to form patterns (reliance operators) , and encode the structural/behavioral relationships among components of objects and classes (rho-calculus). A chain of fully automated tools provides a path from source code to revealed patterns. We describe our approach in this paper with a concrete example to drive the discussion, accompanied by formal treatment of the foundational topics.

This dissertation proposes micro-workflow, a new workflow architecture that bridges the gap between the type of functionality provided by current workflow systems and the type of workflow functionality required in object-oriented applications. Micro-workflow provides a better solution when the focus is on customizing the workflow features and integrating with other systems. In this thesis I discuss how micro-workflow leverages object technology to provide workflow functionality. As an example, I present the design of an object-oriented framework which provides a reusable micro-workflow architecture and enables developers to customize it through framework-specific reuse techniques. I show how through composition, developers extend micro-workflow to support history, persistence, monitoring, manual intervention, worklists, and federated workflow. I evaluate this approach with three case studies that implement processes with different requirements

Since the publication of the Design Patterns book, a large number of object-oriented design patterns have been identified and codified. As part of the pattern form, objectoriented design patterns must indicate their relationships with other patterns, but these relationships are typically described very briefly, and different collections of patterns describe different relationships in different ways. In this paper we describe and classify the common relationships between object oriented design patterns. Practitioners can use these relationships to help them identity those patterns which may be applicable to a particular problem, and pattern writers can use these relationships to help them integrate new patterns into the body of the patterns literature. 1.

Design patterns are an important concept in the field of software engineering, providing a language and application independent method for expressing and conveying lessons learned by experienced designers. There is a large gap, however, between the aesthetic and elegance of the patterns as intended and the reality of working with an ultimately mathematically expressible system such as code. In this paper we describe a step towards meaningful formal analysis of code within the language of patterns, and discuss potential uses. The major contributions include: a compendium of Elemental Design Patterns (EDPs), a layer of seemingly simplistic relationships between objects that, on closer inspection, provide a critical link between the world of formal analysis and the realm of pattern design and implementation without reducing the patterns to merely syntactic constructs; an extension to the ς-calculus, termed ρ-calculus, a formal notation for expressing relationships between the elements of object oriented languages, and its use in expressing the EDPs directly. We discuss their use in composition and decomposition of existing patterns, identification of pattern use in existing code to aid comprehension, and future research directions, such as support for refactoring of designs, interaction with traditional code analysis systems, and the education of students of software architecture. 1. Problem Description Programming has historically been an exercise in the creation of hierarchical abstractions to manage complexity. As programming techniques have progressed in the field, language designers have continued to push the envelope of producing explicit constructs for those conceptual lessons learned in the previous generation of languages, and software architects have continued to build ever more complex and powerful abstractions. At the same time that these ab-

The use of dynamic information to aid in software understanding is a common practice nowadays. One of the many approaches concerns the comprehension of execution traces. A major issue in this context is scalability: due to the vast amounts of information, it is a very difficult task to successfully find your way through such traces without getting lost. In this paper, we propose the use of a novel trace visualization method based on a massive sequence and circular bundle view, constructed with scalability in mind. By means of three usage scenarios that were conducted on three different software systems, we show how our approach, implemented in a tool called EXTRAVIS, is applicable to the areas of trace exploration, feature location, and feature comprehension.

The conceptual structure of existing software systems is often implicit or non-existing in the source code. We propose the lightweight abstraction of intentional source-code views as a means of making these conceptual structures more explicit. Based on the experience gained with two case studies, we illustrate how intentional source-code views can simplify and improve software understanding, maintenance and evolution in various ways. We present the results as a catalog of usage scenarios in a pattern-like format.

A Wiki is a collaborative software to do content management. Although there are a lot of different Wiki implementations available today, they all lack the possibility to be extended and to adapt to the needs of their users. SmallWiki is a new and fully object-oriented Wiki framework in Smalltalk, that has got a lot of unit-tests included. This documentation gives an overview how to run it, about its design and implementation, and provides a few examples on writing extensions. Acknowledgments I am grateful to Stephane Ducasse and Roel Wuyts for all those useful discussions about the design and the implementation of SmallWiki. I would like to thank Alexandre Bergel for writing examples and an initial documentation. Thanks to all the people who have submitted suggestions, patches and bug reports.

Refactorings are behavior-preserving program transformations that improve the design of a program. Refactoring engines are tools that automate the application of refactorings: first the user chooses a refactoring to apply, then the engine checks if the transformation is safe, and if so, transforms the program. Refactoring engines are a key component of modern IDEs, and programmers rely on them to perform refactorings. A bug in the refactoring engine can have severe consequences as it can erroneously change large bodies of source code. We present a technique for automated testing of refactoring engines. Test inputs for refactoring engines are programs. The core of our technique is a framework for iterative generation of structurally syntax trees that represent Java programs. We also create several kinds of oracles to automatically check that the refactoring engine transformed the generated program correctly. We have applied our technique to testing Eclipse and NetBeans, two popular open-source IDEs for Java, and we have exposed 21 new bugs in Eclipse and 24 new bugs in NetBeans.

The field of software design patterns has seen an explosion in interest in the last three years. Work to date has been on the recognition, cataloging, and finding of patterns with little attention to the use of patterns especially by students and practitioners not well-versed in object-oriented technologies. This project addresses novice use directly yielding benefits for both the established pattern community and to students and educators new to the field. Although we do not claim that design patterns are Brooks' silver bullet [8], their use can help cope with the accidental complexity of software development and, we argue, their use is essential for a successful adoption of object-oriented techniques in academic computer science programs. This project addresses practical and pedagogical concerns of the computer science and software engineering communities by addressing the teaching and learning of patterns. In this paper we argue that design patterns are an essential programming and ...

This technical report presents 25 design patterns using the role diagram notation. The role diagram notation describes a pattern using the concept of "role" as the central modeling construct. The purpose of this report is to describe a set of common reusable patterns in a form that makes them an easy target for composition. The ultimate goal is to explain frameworks as sets of instantiated patterns which integrate with each other to serve a common goal, that is to achieve the framework's purpose. Dirk Riehle (Dirk.Riehle@ubs.com) October 1996, Zürich, Switzerland Table of Contents 1 Introduction ......................................................................................................7 2 Roles and Role Diagrams .................................................................................9 3 Object Creation...............................................................................................11 3.1 Factory Method ................................................