No abstract available

Separation of concerns has been central to software engineering for decades, yet its many advantages are still not fully realized. A key reason is that traditional modularization mechanisms do not allow simultaneous decomposition according to multiple kinds of (overlapping and interacting) concerns. This workshop was intended to bring together researchers working on more advanced modularization mechanisms, and practitioners who have experienced the need for them, as a step towards a common understanding of the issues, problems and research challenges.

Done well, separation of concerns can provide many software engineering benefits, including reduced complexity, improved reusability, and simpler evolution.The choice of boundaries for separate concerns depends on both requirements on the system and on the kind(s) of decompositionand composition a given formalism supports.The predominant methodologies and formalisms available, however, support only orthogonal separations of concerns, along sdngle dimensions of composition and decomposition.These characteristics lead to a number of well-known and difficult problems.This paper describes a new paradigm for modeling and implementing software artifacts, one that permits separation of overlapping concerns along multiple dimensions of composition and decomposition.This approach addresses numerous problems throughout the software lifecycle in achieving wellengineered, evolvable, flexible software artifacts and traceability across artifacts.

article Free Access Share on Subject-oriented design: towards improved alignment of requirements, design, and code Authors: Siobhán Clarke School of Computer Applications, Dublin City University, Dublin 9, Republic of Ireland School of Computer Applications, Dublin City University, Dublin 9, Republic of IrelandView Profile , William Harrison IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NY IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NYView Profile , Harold Ossher IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NY IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NYView Profile , Peri Tarr IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NY IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NYView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 34Issue 10Oct. 1999 pp 325–339https://doi.org/10.1145/320385.320420Online:01 October 1999Publication History 94citation1,710DownloadsMetricsTotal Citations94Total Downloads1,710Last 12 Months24Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Subject-oriented programming supports composition of object-oriented programs or program fragments called subjects. This paper presents an approach to the composition rules used to specify composition details. Rules can be generic, allowing different subrules to be "plugged into" higher-level rules, and they include a means of specifying exceptions to general rules. We give definitions of a number of useful, generic rules, including merge and override, as a first step towards a generally-useful composition rule library. We also outline an object-oriented framework for implementing rules, which we are currently building as part of our support for subject-oriented programming in C++.

Object-Oriented technology is often described in terms of an interwoven troika of themes: encapsulation, polymorphism, and inheritance.But these themes are firmly tied with the concept of identity.If object-oriented technology is to be successfully scaled from the development of independent applications to development of integrated suites of applica-tions, it must relax its emphasis on the objecf.The technology must recognize more directly that a multiplicity of subjective views delocalizes the concept of object, and must emphasize more the binding concept of identity to tie them together.This paper explores this shift to a style of objectoriented technology that emphasizes the subjective views: Subject-Oriented Programming.

Making extensionsto existing systems is a critically important activity in object-oriented pro-existing application.We are in full agreement with Lieberman [7] that one wants a small extension to behavior to require just a small extension to code, and that adding new code is good, whereas modifying existing code is bad.We call this approach "extension-by-addition" [16].gramming.This paper proposes an approach in which extensions of all kinds are clearly separated from the base hierarchy upon which they are built, for ease of distribution and combination.Extensions, including extensions to existing classes, are written in separate, sparse extension hierarchies.The entire system is obtained by combining the extension hierarchies with the base hierarchy.Sequences of successive extensions can be combined using an extension operator, and parallel extensions can be combined using a merge operator, which might identify conflicts that must be reconciled.System building takes place at two levels: combining existing extensions from a library using these operators, and building new extensions when existing ones are not adequate.New extensions built in this way are added to the library, and so should be written to be as general and reusable as possible.

Development of any large system or artifact requires the coordination of many developers. Development activities can occur concurrently. The goal of coordination is to enhance, not restrict, developer productivity, while ensuring that concurrent development activities do not clash with one another.

This paper presents our experience building an extendible software development environment using the object-oriented paradigm. We have found that object instances provide a natural way to model program constructs, and to capture complex relationships between different aspects of a software system. The object-oriented paradigm can be efficiently implemented on standard hardware and software, and provides some degree of extendibility without requiring major modifications to the existing implementation.

No abstract available.

This paper presents a systematic approach to the problem of generating good code with a compiler that is easy to construct. A compiler structure is proposed which relies on interprocedural data flow analysis, global optimization, and an intermediate language schema to simplify the task of writing the code generating portions of a compiler without sacrificing code quality. This structure is contrasted with a more conventional structure to explore the reasons why the new structure solves several problems inherent in the conventional structure. Further advantages which accrue from the new structure are also presented.

This paper presents a systematic approach to the problem of generating good code with a compiler that is easy to construct. A compiler structure is proposed which relies on interprocedural data flow analysis, global optimization, and an intermediate language schema to simplify the task of writing the code generating portions of a compiler without sacrificing code quality. This structure is contrasted with a more conventional structure to explore the reasons why the new structure solves several problems inherent in the conventional structure. Further advantages which accrue from the new structure are also presented.

Programs can be analyzed to determine bounds on the ranges of values assumed by variables at various points in the program. This range information can then be used to eliminate redundant tests, verify correct operation, choose data representations, select code to be generated, and provide diagnostic information. Sophisticated analyses involving the proofs of complex assertions are sometimes required to derive accurate range information for the purpose of proving programs correct. The performance of such algorithms may be unacceptable for the routine analysis required during the compilation process. This paper presents a discussion of mechanical range analysis employing techniques practical for use in a compiler. This analysis can also serve as a useful adjunct to the more sophisticated techniques required for program proving.