Abstract

Separation of concerns is at the core of object-oriented software development. Done well, it can provide a host of crucial benefits: additive, rather than invasive, change; improved comprehension and reduction of complexity; adaptability, customizability, and reuse, particularly of off-the-shelf components; simplified component integration; and the ultimate goal of "faster, safer, cheaper, better" software.

To benefit from separation of concerns, one must have the right modularization at the right time: the concerns that are separated must match the concerns one needs to deal with. Unfortunately, different development activities often involve concerns of dramatically different kinds. For example, changing a data representation in an object-oriented system might involve a single class, or a few closely-related classes, and might be done non-invasively using subclassing or suitable design patterns. Here the hallmark of object orientation—modularization by class (or object)—is a major asset. On the other hand, adding a new feature to a system typically involves invasive changes to many classes: the feature code is scattered across multiple classes, and tangled with other code within those classes. Sometimes one needs modularization by class, sometimes by feature, sometimes by other criteria (e.g., "aspect" [5], "role" [6], "variant," etc.).

Multi-dimensional separation of concerns is a new approach that supports clean separation of multiple, potentially overlapping concerns simultaneously, with on-demand remodularization. A developer can choose the best modularization, based on any or all of the concerns, for the development task at hand. In addition to reducing impact of change substantially, this opens the door to system refactoring and reengineering. The support for on-demand modularization is a major advance over earlier mechanisms, such as subject-oriented programming [3,4] and aspect-oriented programming [5]. These support more flexible modularization than the object-oriented paradigm they extend, but in only one way at a time.

This demonstration will present HyperJ, a tool that supports multi-dimensional separation of concerns for Java^TM. HyperJ is a visual compositor tool, which provides the ability to identify concerns, specify modules in terms of those concerns, and synthesize systems and components by integrating these modules. The tool works with standard Java class files, as both inputs and outputs, and the Java software with which it works need not have been developed using HyperJ or multiple concerns. We will demonstrate the use of this tool in several software development and evolution activities and indicate how multi-dimensional separation of concerns promotes flexible separation and modularization of concerns, system composition and integration, evolution, and non-invasive, on-demand remodularization.

Technical Description

Background

Multi-dimensional separation of concerns [1,2] is a new approach to constructing and evolving object-oriented (and other) software. It supports flexible separation of concerns by permitting the identification, encapsulation, composition, and evolution of multiple, potentially overlapping concerns within a software system. Multi-dimensional software engineering allows different modularizations to co-exist and be maintained in parallel, and new modularizations to be introduced as needed. This allows the best modularization to be used for any particular development task. It opens up the possibility of flexible adaptation, reconfiguration of software.

Multi-dimensional software engineering is a language-independent technology that can be applied to any programming paradigm, including object-oriented. It augments existing paradigms, which traditionally support a single, dominant means of decomposing systems (by class or object in the OO paradigm; by function in functional languages; etc.). While every decomposition criterion is useful for some purposes (e.g., the object-oriented paradigm greatly facilitates evolutionary changes that affect members of individual classes), they are not adequate for all purposes (e.g., object-oriented software incurs invasive, high-impact cost of adding or modifying system features or functions). The support for multiple, simultaneous modularizations is a significant advance over earlier mechanisms, such as subject-oriented programming [3,4] and aspect-oriented programming [5], which supported more flexible modularization than the object-oriented paradigm they extend, but in only one way at a time.

Multi-dimensional separation of concerns addresses a number of common problems in the development and evolution of large-scale, complex software systems. Its use can help achieve many of the goals of object-oriented software development, including:

• Reduced software complexity and improved comprehensibility: The goal of separation of concerns is to enable developers to focus on a small part of a system (reduction of complexity) and to provide abstractions that hide "unnecessary" details (improved comprehension). The set of details that can be hidden varies considerably, depending on the intended usage. For example, when modifying a particular feature, it is possible to hide details of other features; when specializing a particular class, it is possible to hide other classes. The ability to separate and encapsulate many different kinds of concerns reduces complexity and improves comprehension by enabling developers to focus on different parts of systems, and to hide different kinds of details, as needed for different purposes.
• Software synthesis, integration, and reuse: Software systems and components address one or more concerns; thus, once identified, separated, and encapsulated, it must be possible to integrate, or compose, concerns into systems or components from modules based on concerns. It must also be possible to extract new concern modules from existing ones (e.g., refactoring, or the ability to pull out useful subpieces of existing systems or components). Composition can facilitate a variety of important system properties, including plug-and-play (i.e., the ability to replace one concern with another non-invasively) and mix-and-match (choosing a subset of concerns that will be addressed in a system from the set of all possible concerns, as when deciding that different versions of a system will include different features). Composition and refactoring together can facilitate adaptation and customization.
• Non-invasive, low-impact evolution: A primary cause of invasive, high-impact changes to object-oriented software is the mismatch between evolutionary concerns and developmental concerns. Different kinds of modularization exhibit properties that allow them to facilitate very different types of changes. For example, objects, as units of data abstraction, localize changes to data (low impact), but they result in the scattering of functions and features across multiple classes (high impact), while feature-based separations facilitate changes to features but result in scattering of data. Thus, different kinds of evolution require the use of different types of concerns and modularization, to ensure that the modularization that best localizes the effects of a given change is used.

HyperJ

HyperJ supports multi-dimensional separation of concerns for Java^TM. It currently includes a visual compositor tool, which provides the ability to identify concerns, specify modules in terms of those concerns, and synthesize systems and components by integrating these modules. We provide visual, WYSIWYG support for building and editing composition rules, which describe the interrelationships and interactions among concerns and how to build new concerns out of existing ones.

HyperJ allows trial-and-error synthesis and integration of concerns into systems or components. The user starts by choosing a set of concerns and an overall default composition rule, which is applied to the concerns to produce a composed system or component. Users can interact with the composed system or component, tailoring the composition using a variety of commands provided through menus and buttons. All changes are recorded as composition rules. The rules can be viewed and turned on or off individually. Traditional undo/redo is also supported. If the input concerns change, the rules can be reapplied, to yield a result that, in many cases, will be either correct or close to what is desired. Any rules that are no longer valid will turn themselves off. The user can interact further, improving the result in the light of the new inputs.

The Demonstration

We will demonstrate the use of this tool in several software development and evolution activities and indicate how HyperJ promotes these activities:

• Flexible separation and modularization of concerns: Java software can be written with or without multi-dimensional separation of concerns, and with or without HyperJ. HyperJ permits the identification, encapsulation, and manipulation of concerns in standard Java^TM software, either during initial system development or in retrospect, as the need arises during the course of evolution. The tool set works with any Java^TM class files. We will begin initially with a software system that has been modularized according to two types of concern: by object/class and by feature.
• Composition: Given a set of modules encapsulating different kinds of concerns, we will demonstrate the ability to synthesize and integrate some or all of these concerns into systems and system components with the compositor tool. This part of the demonstration will also highlight the ability to perform mix-and-match and plug-and-play non-invasively.
• Evolution: We will introduce an evolutionary change to the system and demonstrate why one existing modularization (by feature) better limits the impact of the change than the other (by object). We will show how the change can be made additively, using the feature modularization, while still producing a standard Java^TM program with the compositor tool.
• Non-invasive, on-demand remodularization: We will introduce another evolutionary change, which requires the introduction of a new type of modularization. We will demonstrate tool support for on-demand remodularization, and we will show how the compositor tool permits the identification, encapsulation, and modularization of concerns from existing ones.

Harold Ossher co-invented subject-oriented programming in 1993 and multi-dimensional software engineering in 1998-1999. He manages a group that builds support for these development paradigms and conducts related research.

Peri Tarr co-invented multi-dimensional software engineering. She leads the tool development effort for HyperJ and has been exploring issues in subject-oriented and multi-dimensional software engineering throughout the software engineering lifecycle.

For Additional Information

Bibliography references [1] and [2] are the best sources of additional information, and the authors will gladly provide them on request. A web site for multi-dimensional separation of concerns will be available April 15, 1999.

1. P. Tarr, H. Ossher, W. Harrison and S.M. Sutton, Jr. "N Degrees of Separation: Multi-Dimensional Separation of Concerns." Proceedings International Conference on Software Engineering (ICSE ’99), May, 1999. (To appear.)
2. H. Ossher and P. Tarr. "Concern Spaces: Structuring Systems with Hypermodules." Technical Report, IBM T.J. Watson Research Center, March 1999.
3. W. Harrison and H. Ossher. Subject-oriented programming (a critique of pure objects). In Proceedings of the Conference on Object-Oriented Programming: Systems, Languages, and Applications, pages 411–428, Washington, D.C., September 1993. ACM.
4. H. Ossher, M. Kaplan, A. Katz, W. Harrison, and V. Kruskal. Specifying subject-oriented composition. Theory and Practice of Object Systems (TAPOS) 2(3):179-202, 1996. Special Issue on Subjectivity in Object-Oriented Systems.
5. G. Kiczales. "Aspect-Oriented Programming." Proceedings of the European Conference on Object-Oriented Programming, 1997. Invited presentation.
6. E.P. Andersen and T. Reenskaug. "System Design by Composing Structures of Interacting Objects." Proceedings of the European Conference on Object-Oriented Programming, 1992.