James O. Coplien

Commonality and variability in software engineering

The article describes how to perform domain engineering by identifying the commonalities and variabilities within a family of products. Through interesting examples dealing with reuse libraries, design patterns, and programming language design, the authors suggest a systematic scope, commonalities, and variabilities approach to formal analysis. Their SCV analysis has been an integral part of the FAST (Family-oriented Abstraction, Specification, and Translation) technology applied to over 25 domains at Lucent Technologies.

Idioms and patterns as architectural literature

If patterns are not about objects, and if they reach beyond software architecture, then what is a pattern? The author explores the relationships that might exist between objects, patterns and architecture, then examines their implications for software developers.

Feature Interaction in Composed Systems

The history of computer science has shown that decomposing software applications helps managing their complexity and facilitates reuse, but also bears challenging problems still unsolved, such as the assembly of the decomposed features when non-trivial feature interactions are involved. Examples of features include concerns or aspects, black box or white box components, and functional and non-functional requirements. Approaches such as object-oriented and component-based software development, as well as relatively new directions such as aspect-oriented programming, multi-dimensional separation of concerns and generative programming, all provide technical support for the definition and syntactical assembly of features, but fall short on the semantic level, for example in spotting meaningless or even faulty combinations. At previous ECOOPs, OOPSLAsand GCSEs dedicated events have been organised around the aforementioned technologies, where we experienced a growing awareness of this feature interaction problem. However, feature interaction is often merely dismissed as a secondary problem, percolating as an afterthought while other issues are being addressed. The intention of this workshop was to be the first co-ordinated effort to address the general problem of feature interaction in composed systems separately from other issues.

A role-based empirical process modeling environment

Much contemporary development process research is based on analyses of process steps, their duration, and the events they propagate. Because their initial research in large, mature telecommunications development processes concluded that such models do not capture abstractions that remain stable over time, the authors turned their attention to empirical role-based models. The basic abstraction in the model is a role, a longstanding, stable locus of associated responsibilities in a process. A process model evaluation prototyping environment is used to visualize the process data in several ways, including community-of-interest clustering, communication network clustering, and hierarchical rendering. Analyses of these models have led to insight both into individual projects and into the properties of software development processes in general.<<ETX>>

Reevaluating the architectural metaphor: Toward piecemeal growth

in New York and asked him whether he thought the term architect was suitable for software systems people. At the time, Weinberg had already been incorporating ideas from architecture in his courses on system development. Brooks was concerned about the fidelity of the analogy, but it seemed to hold in their ensuing discussions as they fleshed it out. From then on, the term became a fixture of the discourse on software design. This was an important chapter in software engineering—a latent field grasping for the kind of formal foundations found in more established technical fields. The engineering disciplines had math and physics to stand on, and math stood on a millennium of logic and formalism. The software field found several adopted parent dis-James Coplien introduces this focus on architecture design with a thought-provoking look at the history of soft ware architecture. He discusses the implications of ubiquitous computing, challenging soft ware developers to acknowledge their influence and make a difference.

Symmetry Breaking in Software Patterns

Patterns have a longstanding identity in the scientific community as results of a phenomenon called symmetry breaking. This article proposes a formalism for software patterns through connections from software patterns to symmetry and symmetry breaking. Specifically, we show (1) the ties from Alexanders work to symmetry and symmetry-breaking foundations; (2) many programming languages provide constructs that support symmetry; (3) software patterns are the results of symmetry breaking, compensating for design shortfalls in programming languages. The proposed pattern formalism may be useful as a foundation for pattern taxonomies, and to differentiate patterns as a design discipline from heuristics, rules, and arbitrary micro-architectures.

Social patterns in productive software development organizations

Software development is a predominantly social activity. It is important to view software development groups, departments, and corporations as social bodies. We study software organizations using a novel data-gathering approach that combines several techniques commonly used in social network analysis. Our techniques differ from those of ordinary social anthropology in that we help the organization introspect about itself; the technique is a “mirror” for the subject organization. We catalogued social network diagrams using a variety of visualization techniques. We have found visual patterns that correlate well to subjective measures of a good organization. We built analytical models to capture properties of the social networks, employing techniques similar to those used in established social network science. The emerging design technique based on architectural patterns provides a good vehicle for communicating organizational patterns. We have captured practices from outstanding organizations in a group of patterns that form a “pattern language” for productive software development.

Patterns of productive software organizations

Software development is a predominantly social activity. Individuals in a software project fill various roles and communicate with other roles, forming a social network of communication that embodies many important characteristics of the organization. These social networks lend themselves to both quantitative and visual analysis. In an attempt to isolate important factors that contribute to software productivity, we have used both visual and quantitative data to uncover patterns of organization and process that are characteristic of highly productive software projects. These patterns, in turn, have enabled us to establish guiding principles for roles and for communication among roles. Several projects have begun to apply these patterns in a generative manner to reshape their organizations.

A Version Model for Aspect Dependency Management

With Aspect-Oriented Programming (AOP) a new type of system units is introduced (aspects). One observed characteristic of AOP is that it results in a large number of additional (coarse-grained to fine-grained) system units (aspects) ready to be composed to the final application. With this growing number of system units the dependencies between them become vast and tangling. This results in the necessity of an improved management of the dependencies between these system units. Our paper investigates this problem, proposes a more general model (version model) to capture different facettes of AOP as well as a partial solution towards unit consistency based on versions.

The data, context and interaction paradigm

This is a design track overview tutorial that provides a foundation for exploring and applying the DCI (Data, Context and Interaction) paradigm. DCI is a means to supporting full object orientation that restores much of the original object vision that has been lost by class-based design and programming. DCI focuses on objects and their relationships to the roles of human mental models by which end users and programmers reason about them generally. DCI leads to an architecture that extends contemporary object-oriented programming from its data-centric structure to focus more on the business value of system-level operations.