No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Subject-Oriented Programming: A Critique of Pure Objects
Abstract
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 applications, 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.
... It is customary in the AOSD community to make a broad distinction between two families of aspects: one derived from subjects [10] and one derived from AspectJ [13]. Although both families can possibly implement any kind of requirement, AspectJ-like aspects are often used to implement design level requirements such as persistence, distribution, security, logging, whereas subject-like aspects are often used to implement pluggable features that depend on core functionality [10]. ...
... It is customary in the AOSD community to make a broad distinction between two families of aspects: one derived from subjects [10] and one derived from AspectJ [13]. Although both families can possibly implement any kind of requirement, AspectJ-like aspects are often used to implement design level requirements such as persistence, distribution, security, logging, whereas subject-like aspects are often used to implement pluggable features that depend on core functionality [10]. A textbook example of subjet-like aspects concerns a telephone switching system: the basic functionality of such a system consists of routing calls and managing connexions, but we can have additional features (subjects) such as call-waiting, three-way calling, call forwarding, etc. ...
... We are interested in functional aspects that look like subjects [10] or their descendents, hyperslices [19], for two main reasons. First, historically, subjectoriented programming [10] and its descendant [19] have been motivated by the need to separate functional aspects or roles that are played by the same entities, whereas aspect-oriented programming has been motivated by the need to untangle architectural or design-level aspects. ...
Aspect-oriented software development builds upon object-oriented development by offering additional abstraction boundaries that help us separate different types of requirements into so-called aspects. Given a legacy OO application, it pays to identify existing aspects to help understand the structure of the application and potentially to extract those aspects into separate software modules that can be maintained and reused individually. We present an approach to extract functional aspects using program slicing. We first characterize what we mean by functional aspect, and explore the extent to which program slicing techniques could improve over existing aspect mining and feature location methods for such aspects. We then describe the results of applying our approach to two medium-sized open source programs. Our preliminary results show that program slicing can yield well-defined functional aspects when the appropriate slicing criteria are used. Finally, we explore the effect of design quality on the candidate functional aspects.
... Due to the benefits of collaboration-based languages, a dozens of them were emerged in the past twenty years (Smaragdakis and Batory, 2002;Herrmann, 2003;Helm et al., 1990;Mezini and Lieberherr, 1998;Nystrom et al., 2004;Nystrom et al., 2006;Ostermann, 2002;Madsen and Moller-Pedersen, 1989;Harrison and Ossher, 1993;Ernst, 2001;Baldoni et al., 2006;Leuth et al., 2015). They differ in the definition of collaboration abstraction, composition model and role attributes. ...
... The next feature is the way that a collaboration is defined. A few languages (Harrison and Ossher, 1993) use a traditional OOP language for this purpose. Therefore, it is not possible that a collaboration uses another collaboration. ...
In the past twenty years, dozens of collaboration-based languages have emerged. Often they have an abstraction to denote a collaboration. Most of them use a form of single inheritance to build collaboration from another one. In this model, when a collaboration uses another one, every role class in the sub collaboration inherits from a role class in the super collaboration which has the same name. This affects the reusability of roles and collaborations and makes them semi interactive.
To overcome this problem, this paper uses a new collaboration-based language named Set Oriented Programming (SOP). In SOP, collaborations, instead of being inherited, are composed with each other. To improve the reusability of SOP roles and to make them interactive, events are used. Events cause interaction of roles by crosscutting them. Moreover, a new context problem is discussed and dynamic context solution is proposed by delegations. Finally, we show that events improve the reusability and delegations concur context problem.
... Un sujet peut être complet ou juste une partie d'une application. Ces différents sujets pourraient agir sur des objets partagés de manière indépendante [50]. ...
... Un sujet modélise son domaine à partir de son propre point de vue particulier et il est mis en oeuvre en utilisant des classes, variables d'instance et des opérations d'une manière orientée objet standard. La programmation orientée objet est bien adaptée à la construction des applications indépendantes mais moins bien adaptée pour la construc- tion des suites ou familles d'applications intégrées [50]. Par exemple, une abstraction de voiture comme le montre la figure 1.16, peut être considérée selon le point de vue du conducteur, vendeur ou mécanicien. ...
The object oriented simulation is currently widespread and is based on the object
oriented (OO) paradigm.Discrete event simulation (DES) systems implement several cross-cutting concerns such as event handling, steady state detection and keeping track of a simulation’s state. These concerns tend to produce two major problems that exceed the capacity of the OO paradigm used in simulation: tangling and scattering simulation code. This increases the complexity and reduces the maintainability which requires specific separation of concerns (SoC). The aspect oriented programming (AOP) paradigm puts a greater focus on crosscutting concerns than other language paradigms by offering a strong language mechanisms such as AspectJ.
The application of the AOP in the simulation domain is a recent and innovative re-
search field. In this thesis, we have proposed a discrete event simulation environment
based on AOP paradigm. Our contribution is divided into three parts. The first one re-
presents a comparative study between the aspect-oriented approaches such as subject-
oriented programming and Xerox Parc AOP. The second part concerns the identification of the non-functional concerns of a discrete events simulation systems. Moreover, an architecture for discrete event simulation based on the AOP paradigm using Japrosim library is proposed. Finally, the last part concerns the proposition of a UML profile for the implementation of the AOP at the design level. This profile is specific to the AspectJ language and uses Xpand tool for automatic code generation.
... It is interesting that the author picks as a central example of a signifier 1 Barring strange mishaps such as that of Moliere's hero of Le Bourgeois Gentilhomme who had been speaking prose for more than forty years without knowing it. 2 This example is taken from [5] "Tree" since this apparently harmless term can lead us into the deepest thickets. Consider for example, ...
... Whilst it is not explicitly referenced, the author's work falls in the tradition of work descended from [2] which is the root of a wide literature on techniques for "subjective" or otherwise "contextoriented" programming. An element in common between members of this tradition is that object boundaries are sacrosanct, and whilst different observers may disagree on the nature and behaviour of objects in question, they may not disagree on their multiplicity and relative arrangement. ...
We supply a critique of the paper Semprola: A Semiotic Programming Language, suggesting directions in which its work of bringing semiotics to programming can be refined, and supplying opinions on areas where it may be refounded.
... With identity control the meta-object (mirror-based or otherwise) assumes the identity of the receiver of the reflective method, bypassing the object's control altogether. From this perspective the problem is also closely related to the ideas of both subject and context-oriented programming [34,33,35]. Indeed these two paradigms deal with variations of object behavior that conceptually do not depend on one specific object, but rather on the execution context and its state. ...
... Subject and Context-Oriented Programming. Finally, as we discussed in Section 2.5, the problem of identity control is closely related to the ideas of both subject and context-oriented programming [34,33,35]. These two paradigms deal with variations of object behavior that conceptually do not depend on one specific object. ...
Reflective facilities in OO languages are used both for implementing language extensions (such as AOP frameworks) and for supporting new programming tools and methodologies (such as object-centric debugging and message-based profiling). Yet controlling the runtime behavior of these reflective facilities introduces several challenges, such as computational overhead, the possibility of meta-recursion and an unclean separation of concerns between base and meta-level. In this paper we present five dimensions of meta-level control from related literature that try to remedy these problems. These dimensions are namely: temporal and spatial control, placement control, level control and identity control. We then discuss how these dimensions interact with language semantics in class-based OO languages in terms of: scoping, inheritance and first-class entities. We argue that the reification of the descriptive notion of reflectogram can unify the control of meta-level execution in all these five dimensions while expressing properly the underlying language semantics. We present an extended model for the reification of the reflectogram based on our additional analysis and validate our approach through a new prototype implementation that relies on byte-code instrumentation. Finally, we illustrate our approach through a case study on runtime tracing.
... The viewpoint paradigm is an active subject of research in many areas such as software engineering, knowledge representation, database systems, web applications, sometimes in other terms such as subject in the work of Harrison andal. in 1993 (Harrison, 1993) role at Kristensen in 1996(Kristensen, 1996 and aspect Kiczales andal. in 1997 (Kiczales, 1997). ...
... The viewpoint paradigm is an active subject of research in many areas such as software engineering, knowledge representation, database systems, web applications, sometimes in other terms such as subject in the work of Harrison andal. in 1993 (Harrison, 1993) role at Kristensen in 1996(Kristensen, 1996 and aspect Kiczales andal. in 1997 (Kiczales, 1997). ...
The interest behind the use of component based software engineering is to divide an information
system in subsystems with less complexity, the reduction of time, faster development, and enhancing
the productivity. The software systems are developed by assembling components which are software
units that offer a set of services exposed as interfaces. The indispensable role of component-based
development is the component model that defines how components can be built and how they can
be assembled. A component is intended to provide specific services as the management of the
combination and the communication between the system units. The Manager Component is an
important and complementary paradigm for the development of software systems. The functionalities
that it encapsulates must be related and consistent. The model presented in this paper proposes a
component called Manager Software component based on the viewpoint (vision of each system user
and actor) by the assembly of Base Component and system components.
... Nonetheless we did not consider these solutions to implement context-oriented applications because some implementation techniques are less maintainable such as the IFs-statements, and those based on design patterns create too much boilerplate code due to the additional structure introduced by these design patterns [CM22]. Other solutions based on programming languages also exist to implement such systems, such as subject-oriented programming [HO93], role-oriented programming [Her07;Küh+14] or context-oriented programming [HCN08]. For subject-oriented programming and role-oriented programming, the notion of context is replaced by a notion of subject or the role played by an object. ...
Context-oriented programming enables dynamic software evolution by supporting the creation of software systems that dynamically adapt their behaviour depending on the context of their surrounding environment. Upon sensing a new particular situation in the surrounding environment, which is reified as a context, the system activates this context and then continues by selecting and activating fine-grained features corresponding to that context. These features, representing functionalities specific to that context, are then installed in the system to refine its behaviour at runtime. Conceiving such systems is complex due to their high dynamicity and the combinatorial explosion of possible contexts and corresponding features that could be active.
To address this complexity, we propose a feature-based context-oriented software development approach to design and implement context-oriented applications. This approach unifies context-oriented programming, feature modelling and dynamic software product lines into a single paradigm. In this novel paradigm we separate clearly and explicitly contexts and features that we model in terms of a context model, a feature model and the mapping between them. We also design an architecture, implement a programming framework, and develop a supporting development methodology and two visualisation tools to help designers and programmers in their modelling, development and debugging tasks. Furthermore we also develop a user interface library in our approach to create applications with user interfaces that are adaptive.
To validate our feature-based context-oriented software development approach, we designed five case studies and implemented three of them. Then we discussed the design qualities to evaluate our implementation of the programming framework. We also assessed the usability of the programming framework from our own perspective based on the cognitive dimensions of notations framework. Finally we also conducted four user studies with real users in which we asked them to play the role of designers and programmers to validate the understandability, usefulness and usability of our approach. The results we gathered from our participants are promising and provide us with several paths to enhance our approach.
... For that, the viewpoint concept has received significant attention and has been used for different purposes such as a filter, subject, role, state, perspective, and view [8][20] [2]. We recover these different concepts in object-oriented databases, knowledge representation systems and object-oriented analysis and design methods. ...
... Introduit par W. Harrison et H. Ossher [OKH + 95,HO93], la programmation orientée sujet est une extension de la programmation orientée objet. Le principe fondamental de la programmation orientée sujet consiste à avoir une vision subjective d'un même objet c'est-à-dire qu'un objet peut avoir différentes propriétés ou peut être défini de différentes manières en fonction d'un contexte donné. ...
Dans les systèmes embarqués, la spécialisation ou la configuration des systèmes d’exploitation temps réel en fonction des besoins de l’application consiste en la suppression des services inutiles du système d’exploitation. Cela a non seulement pour but d’optimiser l’empreinte mémoire occupée par le système d’exploitation temps réel, afin de satisfaire les contraintes de mémoire auxquelles les systèmes embarqués font face, mais aussi de réduire la quantité de code mort au sein du système d’exploitation temps réel afin d’améliorer la sureté de fonctionnement. Dans nos travaux de thèse, nous nous intéressons à l’utilisation des méthodes formelles dans le processus de spécialisation des systèmes d’exploitation temps réel. Une difficulté majeure dans l’utilisation de modèles formels est la distance entre le modèle et le système modélisé. Nous proposons donc de modéliser le système d’exploitation de telle sorte que le modèle embarque son code source et les structures de données manipulées. Nous utilisons à cet effet un modèle à états finis (éventuellement temporisé) augmenté par des variables discrètes et des séquences d’instructions, considérées comme atomiques, manipulant ces variables. À partir du modèle du système d’exploitation et d’un modèle de l’application visée, l’ensemble des états accessibles du modèle du système d’exploitation traduisant le code effectivement utilisé lors de l’exécution de l’application est calculé. Le code source du système d’exploitation spécialisé est extrait de ce modèle élagué. L’ensemble de la démarche exposée est mise en oeuvre avec Trampoline, un système d’exploitation temps réel basée sur les standards OSEK/VDX et AUTOSAR. Cette technique de spécialisation garantit l’absence de code mort, minimise l’empreinte mémoire et fournit un modèle formel du système d’exploitation utilisable dans une étape ultérieure de modelchecking. Dans ce cadre, nous proposons une technique automatique de vérification formelle de la conformité aux standards OSEK/VDX et AUTOSAR à l’aide d’observateurs génériques.
... Introduit par W. Harrison et H. Ossher [OKH + 95,HO93], la programmation orientée sujet est une extension de la programmation orientée objet. Le principe fondamental de la programmation orientée sujet consiste à avoir une vision subjective d'un même objet c'est-à-dire qu'un objet peut avoir différentes propriétés ou peut être défini de différentes manières en fonction d'un contexte donné. ...
Dans les systèmes embarqués, la spécialisation ou la configuration des systèmes d'exploitation temps réel en fonction des besoins de l'application consiste en la suppression des services inutiles du système d'exploitation. Cela a non seulement pour but d'optimiser l'empreinte mémoire occupée par le système d'exploitation temps réel, afin de satisfaire les contraintes de mémoire auxquelles les systèmes embarqués font face, mais aussi de réduire la quantité de code mort au sein du système d'exploitation temps réel afin d'améliorer la sureté de fonctionnement.Dans nos travaux de thèse, nous nous intéressons à l'utilisation des méthodes formelles dans le processus de spécialisation des systèmes d'exploitation temps réel.Une difficulté majeure dans l'utilisation de modèles formels est la distance entre le modèle et le système modélisé. Nous proposons donc de modéliser le système d'exploitation de telle sorte que le modèle embarque son code source et les structures de données manipulées. Nous utilisons à cet effet un modèle à états finis (éventuellement temporisé) augmenté par des variables discrètes et des séquences d'instructions, considérées comme atomiques, manipulant ces variables.À partir du modèle du système d'exploitation et d'un modèle de l'application visée, l'ensemble des états accessibles du modèle du système d'exploitation traduisant le code effectivement utilisé lors de l'exécution de l'application est calculé. Le code source du système d'exploitation spécialisé est extrait de ce modèle élagué.L'ensemble de la démarche exposée est mise en œuvre avec Trampoline, un système d'exploitation temps réel basée sur les standards OSEK/VDX et AUTOSAR.Cette technique de spécialisation garantit l'absence de code mort, minimise l'empreinte mémoire et fournit un modèle formel du système d'exploitation utilisable dans une étape ultérieure de model-checking. Dans ce cadre, nous proposons une technique automatique de vérification formelle de la conformité aux standards OSEK/VDX et AUTOSAR à l'aide d'observateurs génériques.
... Aspects are expressed through code fragments that spread over the system classes [35]. Some concerns that are frequently aspects: concurrent objects synchronization [36], distribution [37], exception handling [38], coordination of multiple objects [39], persistence, serialization, replication, security, visualization, logging, tracing, load balance and fault tolerance amongst others. ...
... Paradigms like procedural or object oriented programming provide good solutions for the design and implementation of core concerns, but they cannot deal properly with crosscutting concerns. Many different approaches have been proposed for the design and implementation of crosscutting concerns: subject oriented programming [1], composition filters [2], adaptive programming [3], generative programming [4], and aspect oriented programming (AOP) [5]. From these approaches, the aspect oriented programming approach has known the greatest success both in industry and academia. ...
Automatic identification of crosscutting concerns implementation is still a challenging task in software engineering. The approaches
proposed so far for crosscutting concerns identification are all bottom-up approaches: starting from the source code of a software
system they try to discover all the crosscutting concerns that exist in the system. In this paper we present a top-down approach that
we developed based on the observations gathered after analyzing how monitoring crosscutting concerns are implemented in different
open source object oriented software systems. The approach aims to identify only one type of crosscutting concern, namely monitoring.
It tries to automatically identify the type of the logger used for monitoring crosscutting concerns implementation by analyzing the
attributes defined in Java-based software systems. We also present and discuss the results obtained by applying this approach to
different open source Java software systems.
... En los últimos años, en el campo de la investigación se han desarrollado mecanismos avanzados de modularización que ayudan a superar una serie de problemas asociados con la inadecuada SoC. Por ejemplo, se pueden mencionar, la programación adaptativa (Lieberherr, 1996), componentes plug-and-play adaptativos (Mezini y Lieberherr, 1998), programación orientada a aspectos (Kiczales et al., 1997), filtros de composición (Aksit et al., 1992), módulos conceptuales (Baniassad y Murphy, 1998), ingeniería de requerimientos basada en features (Griss, 2000), programación generativa (Batory et al., 2000a,b;Czarnecki y Eisenecker, 2000), separación multidimensional de concerns e hiperespacios (Tarr et al., 1999), modelado por roles (Andersen y Reenskaug, 1992), programación orientada a sujetos (Harrison y Ossher, 1993), programación orientada a variación (Lieberherr, 1996), viewpoints (Nuseibeh et al., 1994), desarrollo de software orientado a features (Apel y Kaestner, 2009), entre otros. Cada enfoque explora un punto diferente en el espacio de soluciones y trata diferentes subgrupos de problemas. ...
El desarrollo de aplicaciones para Grid computing, puede beneficiarse si se aplican enfoques emergentes de Ingeniería de Software basados en la Separación Avanzada de Concerns. En el presente trabajo analizamos los más representativos, de qué manera se aplicaron en el área de Grid computing. Los enfoques abordados incluyen Desarrollo de Software Dirigido por Mo-delos, Desarrollo de Software Basado en Componentes, Desarrollo de Software Orientado a Aspectos, Ingeniería de Línea de Productos y Desarrollo de Software Orientado a Features. Se analizan y comparan estos enfoques de Separación Avanzada de Concerns para determinar de qué manera y en qué grado cada uno de ellos satisfacen las necesidades que se requieren para desarrollo de aplicaciones para Grid computing.
... Paradigms like procedural or object oriented programming provide good solutions for the design and implementation of core concerns, but they cannot deal properly with crosscutting concerns. Many different approaches have been proposed for the design and implementation of crosscutting concerns: subject oriented programming [1], composition filters [2], adaptive programming [3], generative programming [4], and aspect oriented programming (AOP) [5]. From these approaches, the aspect oriented programming approach has known the greatest success both in industry and academia. ...
... One such approach is subject-oriented programming, which views OO applications as the composition of several partial views (subjects) of the same class hierarchies. Subject-oriented programming enables developers to develop applications incrementally by integrating new functions as they become available, without modifying the existing code [22,23,24]. Aspect-oriented programming enables us to separate non-functional aspects that cut-across several classes (e.g., logging, error handling, synchronization) from those functional aspects that are embodied in the OO core of applications [25]; an aspect weaver compiles aspects (some sort of high-level macros) into regular Java classes to produce aspect-enabled programs. ...
Enterprise frameworks are a special class of application frameworks. They are distinguished from other application frameworks in terms of scale and focus. In terms of focus, application frameworks typically cover one particular aspect of an application, either a domain-dependent aspect (e.g., billing in a web-based customer-to-business ordering system), or a computational infrastructure aspect such as distribution, man-machine interface, or persistence, etc. Generally, an application framework alone delivers no useful end-user function. With infrastructure frameworks, we still have to plug in domain functionalities, while with domain frameworks, we need to setup the infrastructure. In contrast, enterprise frameworks embody a reference architecture for an entire application, covering both the infrastructure aspects of the application, and much of the domain-specific functionality. Instantiating an enterprise framework is nothing short of application engineering, where the architecture and many of the components are reusable. While creativity and continual improvement may be the major ingredients for building a good application framework, anything related to enterprise frameworks, be it building, documenting, or instantiating them, is complex and requires careful design and planning. In this paper, we identify the issues involved in building, using, and maintaining enterprise frameworks, both from research and practical perspective.
... For the design level, Composition Patterns [9] is the most referenced AOM approach. Interestingly, it has its roots on Subject-Oriented Design, a design counterpart for Subject-Oriented Programming [26]. Clarke's Composition Patterns are based on the Subject-Oriented Design Model [9]. ...
Aspect-oriented software development promotes improved separation of concerns by introducing a new modular unit, called aspect, for the modularization of crosscutting concerns. As a new kind of modular unit, aspects should have explicit interfaces that describe the way they interact with the rest of the system and how they affect other modules. This interaction can be homogeneous or heterogeneous. In this paper, we present crosscutting interfaces as a conceptual tool for dealing with the complexity of heterogeneous aspects at the design level. Crosscutting interfaces have been incorporated by the aSideML modeling language in order to enhance aspect description at the design level. Moreover, we present a modeling notation for the description of architecture-level aspects that also supports the explicit representation of crosscutting interfaces. Finally, we present two large-scale case studies we have performed using this modeling language that support our arguments in favor of crosscutting interfaces.
... The main addition to the UML is the concept of multi-views class that combines the concept of flexibility via the notion of viewpoint. Later, the notion of multi-view class was used by Zeddari and Ettalbi (2014) in the concept of a multi-view system in order to help the end-users to be more effective and learn the new system faster, and to allow engineers and clients to implement new kinds of design methods and techniques that adapt to the specific needs of the workers Also, the concept of viewpoint has emerged in the 1990s in several prototype and programming languages such as programming by view (Mili et al., 2000), subject (Harrison and Ossher, 1993) and aspect (Kiczales and Lampng, 1997). The concept of viewpoint was included in this domain by using inheritance, delegation and composition of the object paradigm. ...
Metadata integration and interoperability is still one of the leading problems facing the datawarehouse and the business analysis community. The Common Warehouse Metamodel (CWM) enables interoperability and easy interchange of warehouse and business information metadata between heterogeneous systems. However, a decisional process involves a variety of expert and novice users who manipulate several types of knowledge and know-how, each user exploits the process based on his preferences, needs and objectives. Currently, the CWM metamodel does not allow to model and to keep trace of users' experiences during the exploitation of the whole decisional process. In this paper, we extend the CWM in order to support its different users with a new entity that is viewpoints, which models and keeps trace of user preferences, objectives, and decisions made during the datawarehouse process. Our main objective is the capitalisation of users' experiences to enhance reusability of metadata and coordination between users.
... В статье [9] показано, что сквозная функциональность вызвана тем, что в классы зачастую входит большое количество полей и методов, не являющихся неотъемлемыми для данного класса. Многие поля и методы обусловлены субъективным взглядом на этот класс -требованиями, которые этот класс должен соблюдать помимо выполнения своей основной задачи. ...
The approach to simplify working with crosscutting concerns by adding a tool to an integrated development environment which enables marking up aspects in the source code is proposed. We consider aspects as sets of related fragments of code, spread across the project. Each fragment is a syntactical entity in some language. The set of such fragments is organized into a tree-like structure and is displayed in a special aspect markup window. After the structure of the aspects is formed, the aspect markup window enables quick navigation across distributed fragment of code which significantly quickens the development.
The approach is meant to work with any language which may be expressed with a LR-grammar. Support of different languages is achieved by implementing a lightweight parser using a DSL-language LightParse.
The aspect markup tool is implemented as a plug-in to several development environments. Lightweight parsers for a number of commonly used languages are presented.
... More work in these areas is required. Although aspect-oriented programming (AOP) [26] and subject-oriented programming (SOP) [15] claim to provide similar approaches to software engineering and programming, we believe that the reason AOP and SOP are not widely accepted after two decades is the lack of formal specifications for roles/role-players and the design of a role engine to support high-level role-based design and agent development. ...
Adaptability is a common and typical property for natural systems in the real world. It is also an important and desirable property for computer supported artificial systems. An adaptive collaboration system (ACS) can be viewed as a set of interacting intelligent agents, real or abstract, forming an integrated system that can respond to internal and environmental changes. Feedback is a key feature of such systems because it enables appropriate responses to change. Artificial systems can be made adaptive by using feedback to sense new conditions in the environment and then adjusting accordingly. ACSs can find applications in almost all industrial sectors, particularly in aerospace, automotive, manufacturing, and management. Adaptive collaboration (AC) can be realized through the promising architecture and process of role-based collaboration (RBC) [21]. RBC is a computational methodology that uses roles [21] as primary underlying mechanisms to facilitate collaboration. RBC has been developed into a methodology of discovery in the research of collaboration systems, because it takes advantage of formalizations and abstractions of system components through mathematical expressions. Problem instances of such abstractions are easily found in real-world scenarios.
... It is a n extension of the objectoriented programming paradigm that considers systems as a set of subjects with different subjective views. Although subjects are standalone running components of the software, working independently of each other, they are not comp letely isolated [6]. In the subject-oriented programming paradigm various forms of interactions may occur between subjects [7]: ü a request for function or state change to be supplied by another subject. ...
The object-oriented software suffers from code tangling and code scattering problems leading to weak code reusability and difficult application evolution. New approaches supporting an advanced separation of concerns (ASoC) are proposed to overcome this dilemma. These latter provide a more powerful constructs for software decomposition than the object-oriented paradigm and their comparison is increasingly considered as an important issue. This paper is dedicated to the comparison and the assessment of two samples of ASoC approaches: aspect-oriented programming (AOP) and subject-oriented programming (SOP).
... This approach is somewhat more abstract than ours – for example, the algorithm for merging hyperslices is taken as a parameter. Earlier work in the same group promoted a technology called subject-oriented programming (Harrison & Ossher, 1993). One of its principal goals was to allow parallel development of classes and provide a composition mechanism to obtain a final system. ...
TinkerType is a pragmatic framework for compact and modular description of formal systems (type systems, operational semantics, logics, etc.). A family of related systems is broken down into a set of clauses –- individual inference rules -– and a set of features controlling the inclusion of clauses in particular systems. Simple static checks are used to help maintain consistency of the generated systems. We present TinkerType and its implementation and describe its application to two substantial repositories of typed λ-calculi. The first repository covers a broad range of typing features, including subtyping, polymorphism, type operators and kinding, computational effects, and dependent types. It describes both declarative and algorithmic aspects of the systems, and can be used with our tool, the TinkerType Assembler, to generate calculi either in the form of typeset collections of inference rules or as executable ML typecheckers. The second repository addresses a smaller collection of systems, and provides modularized proofs of basic safety properties.
... Numerous methods and techniques such as Aspect-Oriented Programming (AOP), Subject-oriented programming [HO93,LRN11] and special programming techniques for one-dimensional systems in the form of architectural and design patterns have been conceived to handle concerns in adaptive systems. The problems with these techniques are that they either require the use of special tools and languages, such as aspect description languages and compilers, or reprogramming of the mechanisms mdp already provides for every problem instance. ...
In 2014, Ungar et al. proposed Korz, a new computational model for structuring adaptive (object-oriented) systems. Korz combines implicit parameters and multiple dispatch to structure the behavior of objects in a multidimensional space. Korz is a simple yet expressive model which does not require special programming techniques such as the Visitor or Strategy pattern to accommodate a system for emerging contextual requirements. We show how the ideas of Korz can be integrated in a Prolog system by extending its syntax and semantics with simple meta-programming techniques. We developed a library, called mdp (multidimensional predicates) which can be used to experiment with multidimensional Prolog systems. We highlight its benefits with numerous scenarios such as printing debugging information, memoization, object-oriented programming and adaptive GUIs. In particular, we point out that we can structure and extend Prolog programs with additional concerns in a clear and concise manner. We also demonstrate how Prolog's unique meta-programming capabilities allow for quick experimentation with syntactical and semantical enhancement of the new, multidimensional model. While there are many open concerns, such as efficiency and comprehensibility in the case of larger systems, we will see that we can use the leverage of mdp and Prolog to explore new horizons in the design of adaptive systems.
... More efforts are required. Although Aspect-Oriented Programming (AOP) [26] and Subject-Oriented Programming (SOP) [15] claim to provide similar approaches to software engineering and programing, the author believes that the reason why AOP and SOP are not widely accepted after two decades is the lack of formal specifications for roles/role players and the design of a role engine to support high-level role-based design and agent development. ...
??????Role-based collaboration (RBC) is an emerging computational methodology that uses roles as the primary underlying mechanism to facilitate collaboration activities. It consists of a set of concepts, principles, models, and algorithms. RBC offers benefits and challenges that may not be revealed with the traditional methodologies and systems. Related research continues the process of improvement to the development, evaluation, management, and performance of computer-based systems. This article provides a concise introduction to RBC and its model, the Environments-Classes, Agents, Roles, Groups, and Objects (E-CARGO) model; reviews the related research achievements in RBC over the past decade; discusses the challenges requiring future research; presents fundamental methods for conducting related research; and analyzes the connections between RBC and other fields.
... Our work on subject-oriented programming [1,2] has focused on two central issues that we believe to be at the core of research in the domain of "aspect-oriented'" software development: ...
The identification and integration of join points-locations where different components describe overlapping concerns-is at the core of research in AOP. The selection of potential join points-the types of locations in code, such as statements or declarations, that may be joined-affects, either positively or negatively, many properties of both aspect weavers and "woven" systems. This paper explores same issues in selecting potential join points.
Behavioural Modelling –
Foundations and Applications
BM-FA2011
http://www.ou.nl/bm-fa
In collaboration with the Seventh European
Conference on Modelling Foundations and
Applications ECMFA 2011
A methodology is a system of methods, principles, and rules used in a particular area of study or activity. Role-Based Collaboration (RBC) is a generalized computational methodology utilizing roles as its kernel components. It was initially proposed to support Computer-Supported Cooperative Work (CSCW), but gradually developed into a general methodology to manage, organize, and support collaboration. RBC, as a methodology, provides a set of concepts, models, processes, and algorithms aiming at supporting collaboration and activities in collaboration. RBC can also be viewed as a general methodology to model, analyze, design, and implement artificial systems, including socio-technical systems.
This chapter establishes the requirements of RBC, illustrates the RBC process, discusses the RBC principles, clarifies the RBC properties, presents the benefits of RBC, and provides a complete description of the methodology of RBC.
With the continuous effort in research, Role-Based Collaboration (RBC) has been developed into a general methodology for developing, analyzing, designing, evaluating, and simulating complex systems and the Environments – Classes, Agents, Roles, Groups, and Objects (E-CARGO) model has been developed into a general model for complex systems.
Presently, there are still numerous challenges in the investigations of RBC and the E-CARGO model. This chapter discusses the problems and challenges that have not been solved or addressed satisfactorily. Such problems and challenges may still be under investigations, or might be very specific and require domain-related knowledge.
The related problems include role negotiation, role specification, agent evaluation, collective role assignment, role engine, social simulation, adaptive collaboration, and other related RBC and E-CARGO problems in practice. This chapter mainly presents related problems. The author encourages more investigations of the solutions in the future.
A new approach to web application development is presented, in which an application is constructed by configuring and composing concepts drawn from a catalog developed by experts.
A concept is a self-contained, reusable increment of functionality. Each concept includes both front-end and back-end functionality, and exports a collection of components—full-stack GUI elements, backed by application logic and database storage.
To build an app, the developer imports concepts from the catalog, tunes them to fit the application’s particular needs via configuration variables, and links concept components together to create pages. Components of different concepts may be executed independently, or bound together declaratively with dataflows and synchronization. The instantiation, configuration, linking and binding of components is all expressed in a simple template language that extends HTML.
The approach has been implemented in a platform called Déjà Vu, which we outline and compare to conventional web application architectures. We describe a case study in which a collection of applications previously built as team projects for a web programming course were replicated in Déjà Vu. Preliminary results validate our hypothesis, suggesting that a variety of non-trivial applications can be built from a repository of generic concepts.
A software product line comprises a set of products that share a common code base, but vary in specific characteristics called features. Ideally, features of a product line are developed in isolation and composed subsequently. Product lines are increasingly used for safety–critical software, for which quality assurance becomes indispensable. While the verification of product lines gained considerable interest in research over the last decade, the subject of how to specify product lines is only covered rudimentarily. A challenge to overcome is composition; similar to inheritance in object-oriented programming, features of a product line may refine other features along with their specifications. To investigate how refinement and composition of specifications can be established, we derive a notion of feature-oriented contracts comprising preconditions, postconditions, and framing conditions of a method. We discuss six mechanisms to perform contract composition between original and refining contracts. Moreover, we identify and discuss desired properties for contract composition and evaluate which properties are established by which mechanism. Our three main insights are that (a) contract refinement is seldom but crucial, (b) the Liskov principle does not apply to features, and (c) it is sufficient to accommodate techniques from object-orientation in the contract-composition mechanisms for handling frame refinements.
Smart contracts formalize and automate interactions among and between individuals and systems in an executable and decentralized way. They are analogous to objects in object-oriented programming, but their behavior and state is replicated across multiple participants in a network and messages sent to the "object" are relayed to all network participants, allowing everyone to keep its replica up-to-date. Originally introduced in the mid-1990s, their recent surge in popularity is linked to a rising interest in blockchain-backed, general-purpose smart contract platforms.
Manging contract-specific state and behavior associated with the interacting parties and shared objects is a modularity challenge in smart contracts. Each contract has individual requirements for the (non-contract) objects it interacts with. We observed that smart contracts tend to manage object-specific state and behavior itself, often leading to a single monolithic mediator.
We aim at improving encapsulation and separation of concerns by allowing programmers to modularly express instance-specific state and behavior within the scope of a so called Activity Context. Activity Contexts are an extension to objects that collect these modular adaptations and jointly overlay them over instances that participate in the activity modeled by the smart contract.
We demonstrate the benefits of Activity Contexts by refactoring an exemplary smart contract and discuss their trade-offs compared to traditional object-oriented decomposition and their integration into an existing layer-based context-oriented ecosystem.
Data solutions in the teaching and learning space are in need of pro-active innovations in data management, to ensure that systems for learning analytics can scale up to match the size of datasets now available. Here, we illustrate the scale at which a Learning Management System (LMS) accumulates data, and discuss the barriers to using this data for in-depth analyses. We illustrate the exponential growth of our LMS data to represent a single example dataset, and highlight the broader need for taking a pro-active approach to dimensional modelling in learning analytics, anticipating that common learning analytics questions will be computationally expensive, and that the most useful data structures for learning analytics will not necessarily follow those of the source dataset.
Modeling protean objects, i.e. objects adapting their structure and behavior dynamically with respect to changeable environment, may be challenging in traditional object oriented languages. While some dynamic languages make the implementation of changeable behavior of objects possible by injecting code into the objects at run-time, their lack of an in-depth compile-time code analysis makes the resulting code fragile. The concept of object metamorphism (OM) targets the gap between the two language types by introducing a declarative modeling of protean objects. Such a model, which is validated at compile-time, defines all possible compositions of a given object from smaller parts represented by traits. The actual composition used to instantiate the object is chosen dynamically with respect to the current environment. The result of this research will provide the theoretical concept of OM along with a proof-of-concept adoption of OM to Scala.
In this paper we describe our approach to representing concerns in an interface of an IDE to make navigation across crosscutting concerns faster and easier. Concerns are represented as a tree of an arbitrary structure, each node of the tree can be bound to a fragment of code. It allows one to quickly locate fragments in the source code and makes switching between software development tasks easier. We describe a model which specifies data structures used to store the information about these code fragments and algorithms used to find the code fragment in original or modified source code. The model describes the information about code fragments as a set of contexts. Another important feature of the model is language independency. The model supports different programming, mark-up, DSL-languages and any structured text, such as a documentation. Main goal is to keep concern tree consistent with evolving source code. Search algorithm is designed to work with a modified source code, where the code fragment may change. The model is implemented as a tool, which supports different programming languages and integrates into different editors and integrated development environments. Source code analysis is performed by a set of lightweight parsers. In case of significant changes if the code fragment may be not found automatically the tool helps a programmer to find one by suggesting possible places in the source code based on the stored information.
In the design of complex and variable software systems, one of the key steps is to select the variability mechanism that defines how variable features are realized on the design and code level. Although different variability mechanisms were invented and applied in practice for decades, there are not many studies that compare these mechanisms based on practical experiences. This paper characterizes and compares seven variability mechanisms in terms of their techniques, binding time, granularity, and further aspects. It provides experiences of their usage, the practical benefits and challenges, as well as discusses existing solutions to the challenges based on related studies and our practice in industry.
Data-Context-Interactions architecture (DCI) is a software paradigm whose main goal is to bring the end user's mental models and computer program models closer together. It has been shown, however, that developing applications according to the DCI principles is rather difficult in the current languages. This paper presents a novel way of developing applications according to DCI in the framework of Morpheus, which is a proof-of-concept implementation of Object Morphology (OM) in Scala. OM is a new object-oriented paradigm developed to model highly mutable phenomena that may mutate not only with regard to state, but also with regard to type. Instead of classes, OM uses the concept of morph models describing possible forms of objects. Using a simple example it is demonstrated how natural and straightforward it could be to implement applications following the DCI architectural tenets.
The Event Coordination Notation (ECNO) allows modelling the desired behaviour of a software system on top of any object-oriented software. Together with existing technologies from Model-based Software Engineering (MBSE) for automatically generating the software for the structural parts, ECNO allows generating fully functional software from a combination of class diagrams and ECNO models. What is more, software generated from ECNO models, integrates with existing software and software generated by other technologies.
ECNO started out from some challenges in behaviour modelling and some requirements on behaviour modelling approaches, which we pointed out in a paper presented at the second BMFA workshop [1]; the integration with pre-existing software was but one of these requirements.
Different ideas and concepts of ECNO have been presented before – mostly with neat and small examples, which exhibit one special aspect of ECNO or another; and it would be fair to call them “Mickey Mouse examples”.
In this paper, we give a concise overview of the motivation, ideas, and concepts of ECNO. More importantly, we discuss a larger system, which was completely generated from the underlying models: a workflow management system. This way, we demonstrate that ECNO can be used for modelling software beyond the typical Mickey Mouse examples. This example demonstrates that the essence of workflow management – including its behaviour – can be captured in ECNO: in a sense, it is a domain model of workflow management, from which a fully functioning workflow engine can be generated.
The communication between cognitive DSS and data warehouse tends to be inefficient due to their contradictory knowledge/data oriented nature. Data-to-knowledge conversion requires specialized techniques, whereas knowledge-to-data conversion results in loss of knowledge. To address these issues, a subject-oriented semantic knowledge warehouse (SSKW) is proposed, to provide relevant and precise knowledge to CDSS. The SSKW consists of: a) object/process/event/relationship (OPER) model to store domain knowledge in a unified fashion; and, b) a subjective view database, containing opinions of stakeholders about various OPER knowledge elements. A case study to compare the performance of the SSKW-based CDSS against a DW-based CDSS is presented. The results show that SSKW improves communication efficiency, provides relevant and precise domain knowledge to CDSS in less decision cycles, minimizes the loss of knowledge, and helps decision maker to quickly grasp the decision situation through its human-centric nature.
The paper suggests an approach for conceptual modelling in which the phenomenon to be modelled is viewed as a behavioral unit and is recursively decomposed into smaller parts. The process is continued until all behavioral units are simple event types. Related entity types and association types with their attributes are also identified. The approach is illustrated using the example of the organization of a conference. The resultant hierarchical model can be used to structure the complexity of conceptual models, and provides an alternative to conceptual modelling based on user views. The top-down decomposition allows possible points of disagreement about the model to be identified early in the modelling process.
Background: Programming language design is not usually informed by empirical studies. In other fields similar problems have inspired an evidence-based paradigm of practice. Such a paradigm is practically inevitable in language design, as well. Aims: The content of evidence-based programming design (EB-PLD) is explored, as is the concept of evidence in general. Additionally, the extent of evidence potentially useful for EB-PLD is mapped, and the appropriateness of Cohen’s kappa for evaluating coder agreement in a secondary study is evaluated. Method: Philosophical analysis and explication are used to clarify the unclear. A systematic mapping study was conducted to map out the existing body of evidence. Results: Evidence is a report of observations that affects the strength of an argument. There is some but not much evidence. EB-PLD is a five-step process for resolving uncertainty about design problems. Cohen’s kappa is inappropriate for coder agreement evaluation in systematic secondary studies. Conclusions: Coder agreement evaluation should use Scott’s pi, Fleiss’ kappa, or Krippendorff’s alpha. EB-PLD is worthy of further research, although its usefulness was out of scope here.
Software-as-a-Service (SaaS) is a new delivery model, that involves providing applications to the customer on demand over the Internet. SaaS promotes multi-tenancy as a tool to exploit economies of scale. However, the flexibility of an application to be adapted to individual tenant's needs is a major requirement. Thus, we initiate in this paper to an approach proposing a more flexible and reusable SaaS system for multi-tenancy. This approach consist on integrating a functional variability using Rich-Variant Components with a deployment variability enabling the customers to choose with which others tenants they want or don't want to share instances. The approach presented enables exploiting the economies of scale while avoiding the problem of customers' hesitation about sharing with other tenants.
Korz is a new computational model that provides for context-oriented programming by combining implicit arguments and multiple dispatch in a slot-based model. This synthesis enables the writing of software that supports contextual variation along multiple dimensions, and graceful evolution of that software to support new, unexpected dimensions of variability, without the need for additional mechanism such as layers or aspects. With Korz, a system consists of a sea of method and data slots in a multidimensional space. There is no fixed organization of slots into objects - a slot pertains to a number of objects instead of being contained by a single object - and slots can come together according to the implicit context in any given situation, yielding subjective objects. There is no dominant decomposition, and no dimension holds sway over any other. IDE support is essential for managing complexity when working with the slot space and with subjectivity, allowing the task at hand to dictate what subspaces to isolate and what dominance of dimensions to use when presenting nested views to the user. We have implemented a prototype interpreter and IDE, and used it on several examples. This early experience has revealed much that needs to be done, but has also shown promise. It seems that Korz's particular combination of concepts, each well-known from the past, is indeed more powerful than the sum of its parts.
Scoping behavioral variations to dynamic extents is useful to support non-functional concerns that otherwise result in cross-cutting code. Unfortunately, such forms of scoping are difficult to obtain with traditional reflection or aspects. We propose delegation proxies, a dynamic proxy model that supports behavioral intercession through the interception of various interpretation operations. Delegation proxies permit different behavioral variations to be easily composed together. We show how delegation proxies enable behavioral variations that can propagate to dynamic extents. We demonstrate our approach with examples of behavioral variations scoped to dynamic extents that help simplify code related to safety, reliability, and monitoring.
Workflows are increasingly adopted to describe large-scale data- and compute-intensive scientific simulations which leverage the wealth of distributed data sources and computing infrastructures. Nonetheless, most scientific workflow formalisms remain difficult to exploit for scientists who are neither experts nor enthusiasts of distributed computing, because they mix the scientific processes they model with their implementations, blurring the lines between what is done and how it is done, as well as between what is and what is not infrastructure-dependent. Our objective is to improve scientific workflow accessibility and ease scientific workflow design and reuse, by elevating the abstraction level, emphasizing the scientific experiment over technicalities, ensuring proper separation between functional and non-functional concerns and leveraging domain knowledge and know-how. The main contributions of this work are: (i) a multi-level structurally flexible semantic scientific workflow model, called the Conceptual Workflow Model, which lets users design simulations at a computation-independent level and focus on domain goals and methods; and (ii) a computer-assisted Transformation Process relying on knowledge engineering technologies to help users transform their high-level simulation models into executable workflow artifacts which can be delegated to third-party frameworks for enactment.
At the core of any sophisticated software development and maintenance environment is a large mass of complex data. The data (the central data of the environment) is composed of smaller sets of data that can be related in complicated and often subtle ways. The user or developer of the environment will be more effective if they are able to deal with conceptual slices, or views, of the large, complex structure. This paper presents an architectural building block for object-based software environments based on the views concept. The building block allows the construction of global abstractions that describe unified behavior of large sets of objects. The basis of the architecture relies on extending the object-oriented paradigm in three steps: (1) defining multiple interfaces in object classes; (2) controlling visibility of instance variables; and (3) allowing multiple copies of an instance variable to occur within an object instance. This paper focuses on the technical aspects of the views approach.
The tool abstraction paradigm, which supports the evolution of large-scale software systems by easing design changes in the system functions, is discussed. Systems that support tool abstraction are structured as a pool of abstract data structures shared by a collection of cooperating 'toolies', where each toolie provides a piece of the overall system function. When one toolie updates the shared data, other toolies must be notified: otherwise, cooperating-but-independent toolies may not execute, and the overall system function may be compromised. The KWIC (key word in context) index production system is used to illustrate the idea of tool abstraction. The relationship of tool abstraction to other concepts is examined.< >
Behavioral compositions, groups of interdependent objects cooperating to accomplish tasks, are an important feature of object-oriented systems. This paper introduces Contracts, a new technique for specifying behavioral compositions and the obligations on participating objects. Refinement and composition of contracts allows for the creation of large grain abstractions based on behavior, orthogonal to those provided by existing class constructs. Using contracts thus provides a basis and vocabulary for Interaction-Oriented design which greatly facilitates the early identification, abstraction and reuse of patterns of behavior in programs. Contracts differ from previous work in that they capture explicitly and abstractly the behavioral dependencies amongst cooperating objects. By explicitly stating these dependencies, contract also provide an effective aid for program understanding and reuse.
The state of object-oriented is evolving rapidly. This survey describes what are currently thought to be the key ideas. Although it is necessarily incomplete, it contains both academic and industrial efforts and describes work in both the United States and Europe. It ignores well-known ideas, like that of Coad and Meyer [34], in favor of less widely known projects.
Research in object-oriented design can be divided many ways. Some research is focused on describing a design process. Some is focused on finding rules for good designs. A third approach is to build tools to support design. Most of the research described in this article does all three.
We first present work from Alan Snyder at Hewlett-Packard on developing a common framework for object-oriented terminology. The goal of this effort is to develop and communicate a corporate-wide common language for specifying and communicating about objects.
We next look into the research activity at Hewlett-Packard, led by Dennis de Champeaux. De Champeaux is developing a model for object-based analysis. His current research focuses on the use of a trigger-based model for inter-object communications and development of a top-down approach to analysis using ensembles.
We then survey two research activities that prescribe the design process. Rebecca Wirfs-Brock from Tektronix has been developing an object-oriented design method that focuses on object responsibilities and collaborations. The method includes graphical tools for improving encapsulation and understanding patterns of object communication. Trygve Reenskaug at the Center for Industriforskning in Oslo, Norway has been developing an object-oriented design method that focuses on roles, synthesis, and structuring. The method, called Object-Oriented Role Analysis, Syntheses and Structuring, is based on first modeling small sub-problems, and then combining small models into larger ones in a controlled manner using both inheritance (synthesis) and run-time binding (structuring).
We then present investigations by Ralph Johnson at the University of Illinois at Urbana-Champaign into object-oriented frameworks and the reuse of large-scale designs. A framework is a high-level design or application architecture and consists of a suite of classes that are specifically designed to be refined and used as a group. Past work has focused on describing frameworks and how they are developed. Current work includes the design of tools to make it easier to design frameworks.
Finally, we present some results from the research group in object-oriented software engineering at Northeastern University, led by Karl Lieberherr. They have been working on object-oriented Computer Assisted Software Engineering (CASE) technology, called the Demeterm system, which generates language-specific class definitions from language-independent class dictionaries. The Demeter system include tools for checking design rules and for implementing a design.
The problem of integrating separately written tools so that they
work cooperatively, a key issue in computer-aided software engineering
(CASE) frameworks, is addressed. An extended object-oriented approach to
tool integration that integrates coarse-grained and fine-grained
approaches is described. The advantages of both the approaches are
discussed, and the techniques by which integration is achieved are
described. The approach described addresses both the data and control
aspects of tool integration. The keys to the integration are the uniform
use of operations and events applied to objects, irrespective of
granularity, and the decentralized description of the behavior of
classes, permitting independently developed tools to provide separate
functionalities for the same objects
An overview is given of the Field environment, which was developed to show that highly integrated, interactive environments like those on PCs can be implemented on workstations and can be used for classical-language and large-scale programming. Field connects tools with selective broadcasting, which follows the Unix philosophy of letting independent tools cooperate through simple conventions, demonstrating that this simple approach is feasible and desirable. Field achieves its goals by providing a consistent graphical front end and a simple integration framework that lets existing and new Unix tools cooperate. The front end is based on a tool set called the Brown workstation environment. The framework combines selective broadcasting with an annotation editor that provides consistent access to the source code in multiple contexts and with a set of specialized interactive analysis tools. Field's integration framework and message facility are described.<
></ETX
Capsules and types in l:rcsco
- Alan Wills
Current Rescarch in Object-Oriented l)csign" Object Management Architecture Guide O M(J l)ocument 92.1 l.l ()bject Management Group
- P Ebecca Wirfs-Brock
- Ralph Lohnson
l larold Ossher and William I larrison "Support for Change in RI~I)F.~
- Larold Ossher
- William I Larrison
Achieving Agreement" (;ase Communiqu6 3404 Ilarmony P oadl
- P Ebecca Wirfs-Brock
- Ralph Lohnson
Englewood Cliffs) 1991. Peter Coad and Edward Yourdon "ObiectorientedI.')esi gn
- Peter Coad
- Edward Yourdon
Current Rescarch in Object-Oriented l)csign" OMG l)ocument 91.12.1 Object Management Group l)eccmber 1991. - (7ommon ()bject Request Broker Architecture and Specification OMG l)ocument 91.12.1 Object Management Group l
- P Ebecca Wirfs-Brock
- Ralph Lohnson
Cook A Denotational Semantics of Inheritance PhD. thesis Brown University 1989. William P . Cook A Denotational Semantics of Inheritance PhD
- P William