A Meta-Model for Composition Techniques in Object-Oriented Software Development
|
|
- Victoria Stokes
- 6 years ago
- Views:
Transcription
1 A Meta-Model for Composition Techniques in Object-Oriented Software Development Bedir Tekinerdogan Department of Computer Science University of Twente P.O. Box 217, 7500 AE Enschede, The Netherlands 1. Introduction It is clear that compositional behavior has different aspects and meanings in the object-oriented software development area. In general, composition is needed to assemble or compose existing components together to get more complex or more adjusted functionality. The main issue here is that components should be freely and modularly combined [22], that is, we should not need to modify the existing components if we combine it with another component. Composition can be done either by black-box reuse or white-box reuse [15]. In the black-box reuse approach no internal details of objects are visible and objects appear as black boxes. In the white-box reuse approach the internal details of the object are visible. However, even in the case of white-box reuse the existing components should stay intact. Finally composition can be applied either at compile-time or run-time. Compositions in the conventional OO model are restricted to inheritance, encapsulation and communication protocols [1]. However, these composition techniques still suffer from providing real composability and other modeling problems [3]. Inheritance is a composition technique which is defined at compile time and is actually based on white-box reuse, because we need some internal details of the superclass if we would like to extend the existing class. As such we say that inheritance breaks the encapsulation [24]. The lack of powerful composability techniques for inheritance can further provide the so-called inheritance anomalies as described in [6][20]. Hereby we are forced to rewrite the original class in order to extend the base class. An alternative to inheritance is delegation [19] which is a composition technique that is adopted at run-time and which is more based on blackbox reuse. Although encapsulation is considered to be important for providing modular software it may provide obstacles for reusability and extensibility as well, because also information which is needed for reuse is hidden. Several approaches to solve this problem have been proposed as well. Finally, communication protocols can have additional constraints which the conventional object model and composition techniques cannot adequately cope with, like for example distributed, realtime and synchronization constraints [4] [5] [7]. In order to solve the compositional modeling problems we can identify two research approaches. The first approach takes the object models and tries according to some specific problem to find solutions. Subsequently, the object model is then adjusted for these specific situations. We adopt the second approach as it is illustrated in figure 1 and in which a meta-model of the compositional behavior of the object model is build. The problems of the object model and the solutions will be derived from this meta-model and accordingly new and better object models will be exploited. It is thus our concern to make explicit the composability issues of the conventional object model and identify the weak and strong aspects of the different object models. That is, in order to identify the basic problems like in traditional engineering techniques we will model our domain, which is in fact the OO model itself. Modeling the object model or part of it have been done by many authors and for several reasons [16] [21] [23]. All these meta-models have mainly in common that they try to solve some specific problems of the OO model which cannot be adequately encountered with the conventional OO techniques. We will distantiate us from specific problems of the object model and just try to make explicit the compositional behavior of the object model such that we can reason about it and accordingly control it in a later phase. Our meta-model will thus be an abstraction of the composition decisions which are 1
2 normally not accessible for the software engineer, like for example the strategy for the method-lookup and inheritance. Figure 1. The two composability research approaches According to the separation of concerns principle [13], we will separate two concerns in our metamodel: First, the components in the software and second the composer objects, called composers, which compose the components. Composers will make explicit the control behavior and the dependencies among the different components in the object model. Using this approach we will see that we can identify different composers which are normally hidden in the functionality of the compiler. Our meta-model will be the basis for our research to adaptable and composable models and methods. Using this generic meta-model we will express the OO models adopted by different OO languages like Smalltalk [12], C++ [9][25], SELF [8] and SINA [2][17] and exploit the common powerful properties which support the composability and as such the adaptability of the software. We have to note that this is a preliminary work and as such the paper is really written as a position paper. The main goal of this position paper is to foster discussions and to obtain input for our further research in this area. The paper is further organized as follows. Section 2 will deal with the software components. Section 3 will describe the basic composers in the OO model. Section 4 will give the dependencies between components and composers. Finally, we will conclude with the conclusions and evaluations. 2. Software Components Software consists of components which are either primitives or composites. A composite component on its own may recursively include other primitive or composite components. Components will be composed by Composer which describes a specific composition protocol. We will use the Composite Design Pattern [11] for the structure of our compositions. Figure 2 illustrates the object model for the composers and the component. Figure 2. The composite structure of software components Note that in contrary to the Composite Design pattern the composition semantic here has been left open and depends only on the kind of composite component. So the composition relation between a composite and other component can describe other relations than part-of as well. For the Composer it is not important whether the component is a primitive or a composition of components. It will treat all components in the composite structure uniformly. A Composer will use the Component s class interface to interact with the components in the CompositionComponent. If the recipient is a SoftwarePrimitive, then the request will be handled directly. If the recipient is a CompositionComponent, then it will usually forward requests to its child primitives. 3. Composers The components are build by the composer. The primitive components together with the composers form the primitive entities in our meta-model. All compositional behavior in the object model will be made explicit in the composers. Since each language adopts slightly different object models we will 2
3 have different composers. Figure 3 gives a framework for the different abstract composers. These composers can be further tailored to the needs and requirements of the specific object models. Figure 3. Composer hierarchy The UniversalComposer provides the abstract interface for the specific Composers. The underlying composers represent the basic composition functionalities for the composition of specific kind of components. Note that we did not make a distinction between compile-time and run-time composers. Whether the composer will be invoked at compile-time or run-time will be implicit in the semantics of the composer. The composers further differ in three ways. First, each composer will compose only specific components. For example ObjectComposer will only compose objects whereas MessageComposer composes Messages. Second, each composer will only accept specific kind of components. Third, each composer will have its own strategy on how to compose the accepted components. Composers will be classified using these three criteria. The next sections handle the different composers in more detail. ObjectComposer An ObjectComposer as illustrated in figure 4 composes an object from a set of slots [8]. A slot is a name-vale pair; slots may contain references to other components. Furthermore an ObjectComposer will assign an object id to the generated object. An id of a component in general, will be needed to uniquely identify the components. Figure 4. The ObjectComposer MessageComposer A MessageComposer creates and manipulates Message components. The input of the MessageComposer consists of a set of entities which represent the selector name, the receiver name and the argument names. These entities will then be mapped to a Message component. This Message component has no context yet. Figure 5 illustrates the model for the MessageComposer. Figure 5. MessageComposer 3
4 MethodComposer Figure 6 illustrates the composition of a Method component. The Method Composer will accept a set of messages composed by the MessageComposer, and will compose this in a Method component. Besides of the messages the MethodComposer will accept the control entities which include control statements and for example the return message. The messages will thus be put in the context of a Method component. In general Method components belong to classes. However, if we separate these from classes we can model the propagation patterns model [18]. Each method generated by a propagation pattern model may generate method components which is associated with many classes. ClassComposer Figure 6. MethodComposer The ClassComposer will accept a set of instance variables and methods and compose this in a class component which will have also a class id. If we are concerning object-based languages which do not include the class concept then we may not need this kind of composer. Figure 7. ClassComposer InheritanceComposer The InheritanceComposer as illustrated in figure 8 composes an InheritanceComposite by accepting Class components. Again the InheritanceComposer will put an inheritance id in the InheritanceComposite component. Furthermore the kind of composition strategy will determine what kind of inheritance the object model will use, single-inheritance, multiple inheritance, static inheritance, dynamic inheritance etc. From this example it is clear that we may then have many dedicated subclasses of the abstract ClassComposer of figure 3. Figure 8. InheritanceComposer InstantiationComposer The InstanceComposer of figure 9 composes instances of a specific class in an InstanceOfComposite. This means that the InstantiationComposer will assign a class id to the InstanceOfComposite. This 4
5 composer will be typically adopted at run-time. In class-less language object models we will not need this Composer as well. Figure 9. InstanceComposer MessageCallComposer The MessageCallComposer as illustrated in figure 10, is another run-time composer which composes an object with a message. The method lookup strategy will be made explicit in this composer. Figure 10. MessageCall Composer 4. Composer and Component dependency We have seen before that each composer can only create specific components. However, for different OO models we will need different composers. This means that composers differ in the kind of model adopted. If we adopt a Smalltalk OO model we will have a different ClassComposer than the model adopted by for example C++. However, we will still have the same component of a class. As such composer can be considered as a strategy for the components. Each component may then be associated with several composers. For this purpose we will use the Strategy Design Pattern [11] as illustrated in figure 11. Figure 11. The composer as a strategy The collaborations in this design pattern are as follows: The component here forms the context of the Strategy which is the Composer. The component will pass all data required by the algorithm to the composer when the composition algorithm is called. Alternatively, the component can pass itself as an argument to the Composer operations. A components forwards requests from its clients to its Composer. Clients usually create and pass a ConcreteComposer object to the component. After that clients will interact with the component exclusively. For our model we will provide a family of ConcreteComposer classes for a client to choose from. As an example figure 12 illustrates the event trace diagram [14] for the composition of a Class Component. First the MethodComposer will accept all the necessary components for the method and then update the Method. Subsequently this Method component can be used to compose a class component. 5
6 Conclusion & Evaluations Figure 12. An event trace diagram for the composition of a class In order to reason about composability we have made an attempt to provide a meta-model for the composability aspects of the different OO models. Although some things have to be worked out yet we think that exposing the composability behavior of the OO model using the initial meta-model presented can provide us useful input for our further research activities in composability. Our position statements for the workshop can be summarized in the following statement. Using a meta-model for the compositional behavior will provide us more insight in the deficiencies and the strengths of the object-model. References [1]. M. Aksit. Separation and Composition of Concerns. Position paper for the ECOOP 96 adaptabilty in OO software development workshop, [2]. M. Aksit. On the Design of the Object-Oriented Language Sina, Ph.D Thesis, University of Twente, [3]. M. Aksit and L. Bergmans. Obstacles in Object-Oriented Software Development, Proc. of the OOPSLA'92 Conference, ACM SIGPLAN Notices, Vol. 27, No. 10, October 1992, pp [4]. Aksit, J. Bosch, W. v.d. Sterren and L. Bergmans. Real-Time Specification Inheritance Anomalies and Real-Time Filters, Proc of the ECOOP '94 Conference, LNCS 821, Springer Verlag, July 1994, pp [5]. C. Atkinson, S. Goldsack, A. Di Maio and R. Bayan. Object Oriented Concurrency and Distribution in DRAGOON, Journal of Object-Oriented Programming, March/April 1991, pp [6]. L. Bergmans. Composing Concurrent Objects, Ph.D. thesis, University of Twente, The Netherlands, [7]. J-P. Briot and A. Yonezawa. Inheritance and Synchronization in Concurrent OOP, Proc of the ECOOP'87 Conference, Springer-Verlag, 1987, pp [8]. Craig Chambers. The Design and Implementation of the SELF Compiler, an Optimizing Compiler for Object-Oriented Programming Languages. Ph.D. dissertation, Computer Science Departments, Stanford University, March [9]. J. O. Coplien. Advanced C++ Programming Styles and Idioms. Addison-Wesley, Reading, MA,
7 [10]. D. Decouchant, P. Le Dot, M. Riveill, C. Roisin and X. Rousset de Pina. A Synchronization Mechanism for an Object-Oriented Distributed System, Proc. of the 11th IEEE Conference on Distributed Computing, May 1991 [11]. E. Gamma, R. Helm, R. Johnson, J. Vlissides. Design Patterns: Elements of Reusable Object- Oriented Software. Addison-Wesley, [12]. A. J. Goldberg & D. Robson. Smalltalk-80: The Language and its Implementation. Addison- Wesley, Reading, MA, [13]. W. Hursch and C. Lopes. Separation of Concerns, Northeastern University, February, [14]. I. Jacobson et. al. Object-Oriented Software Engineering- A Use Case Driven Approach. [15]. R. E. Johnson and B. Foote. Designing reusable classes. Journal of Object-Oriented Programming, 1(2):22-35, June/July [16]. G. Kiczales, J. des Rivières & D.G. Bobrow. The Art of Metaobject Protocol. MIT Press, [17]. P. Koopmans. Sina/st User s Guide and Reference Manual. Dept. of Computer Science, University of Twente. [18]. K. Lieberherr. Adaptive Object-Oriented Software: The Demeter method with Propagation Patterns, PWS Publishing Company, [19]. H. Lieberman. Using prototypical objects to implement shared behavior in object-oriented systems. In Proceedings of OOPSLA 86, pp , Portland, OR, [20]. S. Matsuoka & A. Yonezawa, Inheritance Anomaly in Object-Oriented Concurrent Programming Languages, in Research Directions in Concurrent Object-Oriented Programming, (eds.) G. Agha, P. Wegner & A. Yonezawa, MIT Press, April 1993, pp [21]. J. McAffer. Meta-level Programming in Coda, Proc. of the ECOOP 95 Conference, LNCS 952, Springer-Verlag, 1995, pp [22]. B. Meyer. Object-Oriented Software Construction, Prentice Hall, [23]. M. Mezini. Dynamic Metaclass Construction for an Explicit Specialization Interface, Dept. of Elect.Engineering and Comp. Science, University of Siegen, [24]. P. Mullet, J. Malenfant and P. Cointe, Towards a Methodlogy for Explicit Composition of MetaObjects, OOPSLA 95 Conference Proceedings, ACM Sigplan Notices, Vol. 30, No. 10, October 1995, pp [25]. A. Snyder. Encapsulation and inheritance in object-oriented languages. In Proceedings of OOPSLA 86, pp , Portland, OR, November ACM Press. [26]. B. Stroustrup. The C++ Programming Language. Addison-Wesley, Reading, MA,
Composition and Separation of Concerns in the Object-Oriented Model
ACM Computing Surveys 28A(4), December 1996, http://www.acm.org/surveys/1996/. Copyright 1996 by the Association for Computing Machinery, Inc. See the permissions statement below. Composition and Separation
More informationReal-Time Specification Inheritance Anomalies and Real-Time Filters
Real-Time Specification Inheritance Anomalies and Real-Time Filters Mehmet Aksit Jan Bosch William van der Sterren * Lodewijk Bergmans TRESE project Department of Computer Science University of Twente
More informationImplementing Software Connectors through First-Class Methods
Implementing Software Connectors through First-Class Methods Cheoljoo Jeong and Sangduck Lee Computer & Software Technology Laboratory Electronics and Telecommunications Research Institute Taejon, 305-350,
More informationComposing Multiple-Client-Multiple-Server Synchronizations
Composing Multiple-Client-Multiple-Server Synchronizations Mehmet Aksit and Lodewijk Bergmans TRESE project, CTIT and Department of Computer Science, University of Twente, P.O. Box 217,7500 AE Enschede,
More informationReflective Java and A Reflective Component-Based Transaction Architecture
Reflective Java and A Reflective Component-Based Transaction Architecture Zhixue Wu APM Ltd., Poseidon House, Castle Park, Cambridge CB3 0RD UK +44 1223 568930 zhixue.wu@citrix.com ABSTRACT In this paper,
More informationDeriving design aspects from canonical models
Deriving design aspects from canonical models Bedir Tekinerdogan & Mehmet Aksit University of Twente Department of Computer Science P.O. Box 217 7500 AE Enschede, The Netherlands e-mail: {bedir aksit}@cs.utwente.nl
More informationObject-Oriented Design
Object-Oriented Design Lecturer: Raman Ramsin Lecture 20: GoF Design Patterns Creational 1 Software Patterns Software Patterns support reuse of software architecture and design. Patterns capture the static
More informationPattern-Oriented Development with Rational Rose
Pattern-Oriented Development with Rational Rose Professor Peter Forbrig, Department of Computer Science, University of Rostock, Germany; Dr. Ralf Laemmel, Department of Information Management and Software
More informationAspect-Orientation from Design to Code
Aspect-Orientation from Design to Code Iris Groher Siemens AG, CT SE 2 Otto-Hahn-Ring 6 81739 Munich, Germany groher@informatik.tu-darmstadt.de Thomas Baumgarth Siemens AG, CT SE 2 Otto-Hahn-Ring 6 81739
More informationUsing Aspects to Make Adaptive Object-Models Adaptable
Using Aspects to Make Adaptive Object-Models Adaptable Ayla Dantas 1, Joseph Yoder 2, Paulo Borba 1, Ralph Johnson 2 1 Software Productivity Group Informatics Center Federal University of Pernambuco Recife,
More informationUsing Aspects to Make Adaptive Object-Models Adaptable
Using Aspects to Make Adaptive Object-Models Adaptable Ayla Dantas 1, Joseph Yoder 2, Paulo Borba, and Ralph Johnson 1 Software Productivity Group Informatics Center Federal University of Pernambuco Recife,
More informationImplementing Reusable Collaborations with Delegation Layers
Implementing Reusable Collaborations with Delegation Layers Klaus Ostermann Siemens AG, Corporate Technology SE 2 D-81730 Munich, Germany Klaus.Ostermann@mchp.siemens.de ABSTRACT It has been recognized
More informationIdioms for Building Software Frameworks in AspectJ
Idioms for Building Software Frameworks in AspectJ Stefan Hanenberg 1 and Arno Schmidmeier 2 1 Institute for Computer Science University of Essen, 45117 Essen, Germany shanenbe@cs.uni-essen.de 2 AspectSoft,
More informationASL: Hierarchy, Composition, Heterogeneity, and Multi-Granularity in Concurrent Object-Oriented Programming. Abstract
ASL: Hierarchy, Composition, Heterogeneity, and Multi-Granularity in Concurrent Object-Oriented Programming Alfredo Weitzenfeld Computer Science Department University of Southern California Los Angeles,
More informationUsing AOP to build complex data centric component frameworks
Using AOP to build complex data centric component frameworks Tom Mahieu, Bart Vanhaute, Karel De Vlaminck, Gerda Janssens, Wouter Joosen Katholieke Universiteit Leuven Computer Science Dept. - Distrinet
More informationA Proposal For Classifying Tangled Code
A Proposal For Classifying Tangled Code Stefan Hanenberg and Rainer Unland Institute for Computer Science University of Essen, 45117 Essen, Germany {shanenbe, unlandr@csuni-essende Abstract A lot of different
More informationRun-time adaptability of synchronization policies in concurrent objectoriented
Run-time adaptability of synchronization policies in concurrent objectoriented languages Fernando Sánchez, Juan Hernández, Juan Manuel Murillo, Enrique Pedraza Computer Science Department University of
More informationTopics in Object-Oriented Design Patterns
Software design Topics in Object-Oriented Design Patterns Material mainly from the book Design Patterns by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides; slides originally by Spiros Mancoridis;
More informationAn Object-Oriented Approach to Software Development for Parallel Processing Systems
An Object-Oriented Approach to Software Development for Parallel Processing Systems Stephen S. Yau, Xiaoping Jia, Doo-Hwan Bae, Madhan Chidambaram, and Gilho Oh Computer and Information Sciences Department
More information41. Composition Filters - A Filter-Based Grey-Box Component Model
41. Composition Filters - A Filter-Based Grey-Box Component Model Prof. Dr. Uwe Aßmann Technische Universität Dresden Institut für Software- und Multimediatechnik http://st.inf.tu-dresden.de Version 16-0.2,
More informationsecurity model. The framework allowed for quickly creating applications that examine nancial data stored in a database. The applications that are gene
Patterns For Developing Successful Object-Oriented Frameworks Joseph W. Yoder August 27, 1997 1 Overview The work described here extends last years OOPSLA framework workshop paper [Yoder 1996] describing
More informationA computational model for an object-oriented operating system
A computational model for an object-oriented operating system Lourdes Tajes Martínez, Fernando Álvarez García, Marian Díaz Fondón, Darío Álvarez Gutiérrez y Juan Manuel Cueva L? ovelle Abstract--The design
More informationA FRAMEWORK FOR ACTIVE OBJECTS IN.NET
STUDIA UNIV. BABEŞ BOLYAI, INFORMATICA, Volume LV, Number 3, 2010 A FRAMEWORK FOR ACTIVE OBJECTS IN.NET DAN MIRCEA SUCIU AND ALINA CUT Abstract. Nowadays, the concern of computer science is to find new
More informationComposing Multiple Concerns Using Composition Filters
Composing Multiple Concerns Using Composition Filters Lodewijk Bergmans & Mehmet Aksit TRESE group, Department of Computer Science, University of Twente, P.O. Box 217, 7500 AE Enschede, The Netherlands.
More informationReflective Design Patterns to Implement Fault Tolerance
Reflective Design Patterns to Implement Fault Tolerance Luciane Lamour Ferreira Cecília Mary Fischer Rubira Institute of Computing - IC State University of Campinas UNICAMP P.O. Box 676, Campinas, SP 3083-970
More informationUML Aspect Specification Using Role Models
UML Aspect Specification Using Role Models Geri Georg Agilent Laboratories, Agilent Technologies, Fort Collins, USA geri_georg@agilent.com Robert France Department of Computer Science, Colorado State University
More informationIntroduction to Object-Oriented Programming
1/9 Introduction to Object-Oriented Programming Conception et programmation orientées object, B. Meyer, Eyrolles Object-Oriented Software Engineering, T. C. Lethbridge, R. Laganière, McGraw Hill Design
More informationTowards a Methodology for Explicit Composition of MetaObjects
See discussions, stats, and author profiles for this publication at: https://www.researchgate.net/publication/2610218 Towards a Methodology for Explicit Composition of MetaObjects Article December 1999
More informationModeling Heuristic Rules of Methods
Modeling Heuristic Rules of Methods Bedir 7HNLQHUGR DQÃÉÃ0HKPHWÃAkúLW TRESE project, Department of Computer Science, University of Twente, P.O. Box 217, 7500 AE Enschede, The Netherlands. email: {bedir
More informationJOURNAL OF OBJECT TECHNOLOGY Online at Published by ETH Zurich, Chair of Software Engineering. JOT, 2002
JOURNAL OF OBJECT TECHNOLOGY Online at www.jot.fm. Published by ETH Zurich, Chair of Software Engineering. JOT, 2002 Vol. 1, No. 2, July-August 2002 Representing Design Patterns and Frameworks in UML Towards
More informationExecutable Connectors: Towards Reusable Design Elements
Executable Connectors: Towards Reusable Design Elements Appeared in ESEC 97 Stéphane Ducasse and Tamar Richner Software Composition Group, Institut für Informatik (IAM), Universität Bern (ducasse,richner)@iam.unibe.ch
More informationEvaluating Architecture Implementation Alternatives based on Adaptability Concerns
Evaluating Architecture Implementation Alternatives based on Adaptability Concerns Mehmet Aksit and Bedir Tekinerdogan TRESE project, CTIT and Department of Computer Science, University of Twente, P.O.
More informationSafe Metaclass Composition Using Mixin-Based Inheritance
Safe Metaclass Composition Using Mixin-Based Inheritance Noury Bouraqadi bouraqadi@ensm-douai.fr http://csl.ensm-douai.fr/noury Dépt. G.I.P. - Ecole des Mines de Douai 941, rue Charles Bourseul - B.P.
More informationEfficient Support for Mixin-Based Inheritance Using Metaclasses
ubmission to the Workshop on Reflectively Extensible Programming Languages and ytems (REPL) at the International Conference on Generative Programming and Component Engineering (GPCE 03) eptember 22 nd,
More informationDomain-Driven Development with Ontologies and Aspects
Domain-Driven Development with Ontologies and Aspects Submitted for Domain-Specific Modeling workshop at OOPSLA 2005 Latest version of this paper can be downloaded from http://phruby.com Pavel Hruby Microsoft
More informationAbstracting Object Interactions Using Composition Filters
Abstracting Object Interactions Using Composition Filters Mehmet Aksit 1, Ken Wakita 2, Jan Bosch 1, Lodewijk Bergmans 1 and Akinori Yonezawa 3 1TRESE project, Department of Computer Science, University
More informationAn Object-Oriented Model for Extensible Concurrent Systems: The Composition-Filters Approach
An Object-Oriented Model for Extensible Concurrent Systems: The Composition-Filters Approach Lodewijk Bergmans Mehmet Aksit Ken Wakita * Faculty of Computer Science University of Twente Enschede, The Netherlands
More informationRAMSES: a Reflective Middleware for Software Evolution
RAMSES: a Reflective Middleware for Software Evolution Walter Cazzola 1, Ahmed Ghoneim 2, and Gunter Saake 2 1 Department of Informatics and Communication, Università degli Studi di Milano, Italy cazzola@dico.unimi.it
More informationConcurrency Control with Java and Relational Databases
Concurrency Control with Java and Relational Databases Sérgio Soares and Paulo Borba Informatics Center Federal University of Pernambuco Recife, PE, Brazil scbs,phmb @cin.ufpe.br Abstract As web based
More informationEvolution of Collective Object Behavior in Presence of Simultaneous Client-Specific Views
Evolution of Collective Object Behavior in Presence of Simultaneous Client-Specific Views Bo Nørregaard Jørgensen, Eddy Truyen The Maersk Mc-Kinney Moller Institute for Production Technology, University
More informationBase Architectures for NLP
Base Architectures for NLP Tom Mahieu, Stefan Raeymaekers et al. Department of Computer Science K.U.Leuven Abstract Our goal is to develop an object-oriented framework for natural language processing (NLP).
More informationSoftware Engineering
Software Engineering CSC 331/631 - Spring 2018 Object-Oriented Design Principles Paul Pauca April 10 Design Principles DP1. Identify aspects of the application that vary and separate them from what stays
More informationBehavioral Design Patterns Used in Data Structures Implementation
Behavioral Design Patterns Used in Data Structures Implementation Niculescu Virginia Department of Computer Science Babeş-Bolyai University, Cluj-Napoca email address: vniculescu@cs.ubbcluj.ro November,
More informationCoordination Patterns
Coordination Patterns 1. Coordination Patterns Design Patterns and their relevance for Coordination Oscar Nierstrasz Software Composition Group Institut für Informatik (IAM) Universität Bern oscar@iam.unibe.ch
More informationIdioms and Design Patterns. Martin Skogevall IDE, Mälardalen University
Idioms and Design Patterns Martin Skogevall IDE, Mälardalen University 2005-04-07 Acronyms Object Oriented Analysis and Design (OOAD) Object Oriented Programming (OOD Software Design Patterns (SDP) Gang
More informationextrinsic members RoleB RoleA
ASPECT- ORIENTED PROGRAMMING FOR ROLE MODELS Elizabeth A. Kendall Department of Computer Science, Royal Melbourne Institute of Technology GPO Box 2476V, Melbourne, VIC 3001, AUSTRALIA email: kendall@rmit.edu.au
More informationEfficient Separate Compilation of Object-Oriented Languages
Efficient Separate Compilation of Object-Oriented Languages Jean Privat, Floréal Morandat, and Roland Ducournau LIRMM Université Montpellier II CNRS 161 rue Ada 34392 Montpellier cedex 5, France {privat,morandat,ducour}@lirmm.fr
More informationDeriving Object-Oriented Frameworks From Domain Knowledge
Deriving Object-Oriented Frameworks From Domain Knowledge Mehmet Aksit 1, Bedir Tekinerdogan 1, Francesco Marcelloni 2 and Lodewijk Bergmans 1, 3 1 TRESE Project, Department of Computer Science, University
More informationShortcomings of Existing Approaches
Object Database Evolution using Separation of Concerns Awais Rashid, Peter Sawyer {marash sawyer}@comp.lancs.ac.uk Computing Department, Lancaster University, Lancaster LA1 4YR, UK Abstract This paper
More informationAn Expert System for Design Patterns Recognition
IJCSNS International Journal of Computer Science and Network Security, VOL.17 No.1, January 2017 93 An Expert System for Design Patterns Recognition Omar AlSheikSalem 1 and Hazem Qattous 2 1 Department
More informationDynamic Instantiation-Checking Components
Dynamic Instantiation-Checking Components Nigamanth Sridhar Electrical and Computer Engineering Cleveland State University 318 Stilwell Hall, 2121 Euclid Ave Cleveland OH 44113 n.sridhar1@csuohio.edu ABSTRACT
More informationOrganizing Programs Without Classes *
To be published in: LISP AND SYMBOLIC COMPUTATION: An International Journal, 4, 3, 1991 1991 Kluwer Academic Publishers - Manufactured in The Netherlands Organizing Programs Without Classes * DAVID UNGAR
More informationSoftware Language Engineering of Architectural Viewpoints
Software Language Engineering of Architectural Viewpoints Elif Demirli and Bedir Tekinerdogan Department of Computer Engineering, Bilkent University, Ankara 06800, Turkey {demirli,bedir}@cs.bilkent.edu.tr
More informationTeaching Encapsulation and Modularity in Object-Oriented Languages with Access Graphs
Teaching Encapsulation and Modularity in Object-Oriented Languages with Access Graphs Gilles Ardourel, Marianne Huchard To cite this version: Gilles Ardourel, Marianne Huchard. Teaching Encapsulation and
More informationOn the Role of Language Constructs for Framework Design COT/ Centre for Object Technology
On the Role of Language Constructs for Framework Design COT/4-10-1.0 C * O T Centre for Object Technology Centre for Object Technology Revision history: 07-07-97 v1.0 Submitted version Author(s): Status:
More informationCOFFEESTRAINER - Statically Checking Structural Constraints on Java Programs
COFFEESTRAINER - Statically Checking Structural Constraints on Java Programs Boris Bokowski bokowski@inf.fu-berlin.de Technical Report B-98-14 December 1998 Abstract It is generally desirable to detect
More informationA Type Graph Model for Java Programs
A Type Graph Model for Java Programs Arend Rensink and Eduardo Zambon Formal Methods and Tools Group, EWI-INF, University of Twente PO Box 217, 7500 AE, Enschede, The Netherlands {rensink,zambon}@cs.utwente.nl
More informationOn the Concurrent Object Model of UML *
On the Concurrent Object Model of UML * Iulian Ober, Ileana Stan INPT-ENSEEIHT, 2, rue Camichel, 31000 Toulouse, France Phone (+33) 5.61.19.29.39, Fax (+33) 5.61.40.84.52 {iulian.ober, ileana.stan}@enseeiht.fr
More informationCompile Time and Runtime Reflection for Dynamic Evaluation of Messages : Application to Interactions between Remote Objects
Compile Time and Runtime Reflection for Dynamic Evaluation of Messages : Application to Interactions between Remote Objects Laurent Berger I3S - CNRS UPRESA 6070 - Bât ESSI 930 Rte des Colles - BP 145
More informationEfficient Separate Compilation of Object-Oriented Languages
Efficient Separate Compilation of Object-Oriented Languages Jean Privat, Floréal Morandat, and Roland Ducournau LIRMM Université Montpellier II CNRS 161 rue Ada 34392 Montpellier cedex 5, France {privat,morandat,ducour}@lirmm.fr
More informationInterner Bericht. Institut für Mathematische Maschinen und Datenverarbeitung der Friedrich-Alexander-Universität Erlangen-Nürnberg
Cooperative Concurency Control Rainer Pruy November 1992 TR-I4-18-92 Interner Bericht Institut für Mathematische Maschinen und Datenverarbeitung der Friedrich-Alexander-Universität Erlangen-Nürnberg Lehrstuhl
More information204 Supporting Software Reuse in Concurrent OOPLs
204 Supporting Software Reuse in Concurrent OOPLs [32] C. Tomlinson and V. Singh, Inheritance and Synchronization with Enabled Sets, ACM SIGPLAN Notices, Proceedings OOPSLA 89, vol. 24, no. 10, pp. 103-112,
More informationCall by Declaration. Erik Ernst 1. Dept. of Computer Science, University of Aarhus, Denmark
Call by Declaration Erik Ernst 1 Dept. of Computer Science, University of Aarhus, Denmark eernst@daimi.au.dk Abstract. With traditional inheritance mechanisms, a subclass is able to use inherited features
More informationPublications related to Chez Scheme
Publications related to Chez Scheme [1] Andrew W. Keep and R. Kent Dybvig. Automatic cross-library optimization. In Scheme 2013: Workshop on Scheme and Functional Programming, 2013. Describes how Chez
More informationComposition Approaches Summary
Composition Approaches Summary Related Work Several successful experiences have reported on the advantages of using patterns in designing applications. For instance, Srinivasan et. al. [26] discuss their
More informationChapter 5 Object-Oriented Programming
Chapter 5 Object-Oriented Programming Develop code that implements tight encapsulation, loose coupling, and high cohesion Develop code that demonstrates the use of polymorphism Develop code that declares
More informationInheritance (Chapter 7)
Inheritance (Chapter 7) Prof. Dr. Wolfgang Pree Department of Computer Science University of Salzburg cs.uni-salzburg.at Inheritance the soup of the day?! Inheritance combines three aspects: inheritance
More informationSynthesizing Communication Middleware from Explicit Connectors in Component Based Distributed Architectures
Synthesizing Communication Middleware from Explicit Connectors in Component Based Distributed Architectures Dietmar Schreiner 1,2 and Karl M. Göschka 1 1 Vienna University of Technology Institute of Information
More informationPATTERNS AND SOFTWARE DESIGN
This article first appeared in Dr. Dobb s Sourcebook, March/April, 1995. Copyright 1995, Dr. Dobb's Journal. PATTERNS AND SOFTWARE DESIGN Patterns for Reusable Object-Oriented Software Richard Helm and
More informationCYES-C++: A Concurrent Extension of C++ through Compositional Mechanisms
CYES-C++: A Concurrent Extension of C++ through Compositional Mechanisms Raju Pandey J. C. Browne Department of Computer Sciences The University of Texas at Austin Austin, TX 78712 fraju, browneg@cs.utexas.edu
More informationDEMOB - An Object Oriented Application Generator for Image Processing
DEMOB - An Object Oriented Application Generator for Image Processing N. Bryson, D.H.Cooper, J.G.Graham, D.P.Pycock, C.J.Taylor, P.W.Woods Wolf son Image Analysis Unit, Department of Medical Biophysics
More informationPrototyping Languages Related Constructs and Tools with Squeak
Prototyping Languages Related Constructs and Tools with Squeak Alexandre Bergel Distributed Systems Group Dept. of Computer Science Trinity College Dublin 2, Ireland www.cs.tcd.ie/alexandre.bergel Marcus
More informationRun-Time Evolution through Explicit Meta-Objects
Run-Time Evolution through Explicit Meta-Objects Jorge Ressia, Lukas Renggli, Tudor Gîrba and Oscar Nierstrasz Software Composition Group University of Bern Switzerland http://scg.unibe.ch Abstract. Software
More informationApplying Experiences with Declarative Codifications of Software Architectures on COD
Applying Experiences with Declarative Codifications of Software Architectures on COD Position Paper Roel Wuyts Stéphane Ducasse Gabriela Arévalo roel.wuyts@iam.unibe.ch ducasse@iam.unibe.ch arevalo@iam.unibe.ch
More informationOpenCorba: a Reflective Open Broker
OpenCorba: a Reflective Open Broker Thomas Ledoux École des Mines de Nantes 4 rue Alfred Kastler F-44307 Nantes cedex 3, France Thomas.Ledoux@emn.fr Abstract. Today, CORBA architecture brings the major
More informationSummary of the course lectures
Summary of the course lectures 1 Components and Interfaces Components: Compile-time: Packages, Classes, Methods, Run-time: Objects, Invocations, Interfaces: What the client needs to know: Syntactic and
More informationObject-Oriented Design
Object-Oriented Design Lecture 14: Design Workflow Department of Computer Engineering Sharif University of Technology 1 UP iterations and workflow Workflows Requirements Analysis Phases Inception Elaboration
More informationDesign Patterns for Description-Driven Systems
Design Patterns for Description-Driven Systems N. Baker 3, A. Bazan 1, G. Chevenier 2, Z. Kovacs 3, T Le Flour 1, J-M Le Goff 4, R. McClatchey 3 & S Murray 1 1 LAPP, IN2P3, Annecy-le-Vieux, France 2 HEP
More informationCHAPTER 5 GENERAL OOP CONCEPTS
CHAPTER 5 GENERAL OOP CONCEPTS EVOLUTION OF SOFTWARE A PROGRAMMING LANGUAGE SHOULD SERVE 2 RELATED PURPOSES : 1. It should provide a vehicle for programmer to specify actions to be executed. 2. It should
More informationCHAPTER 9 DESIGN ENGINEERING. Overview
CHAPTER 9 DESIGN ENGINEERING Overview A software design is a meaningful engineering representation of some software product that is to be built. Designers must strive to acquire a repertoire of alternative
More informationAn Analysis of Aspect Composition Problems
An Analysis of Aspect Composition Problems Wilke Havinga havingaw@cs.utwente.nl Istvan Nagy nagyist@cs.utwente.nl TRESE/Software Engineering group University of Twente, The Netherlands Lodewijk Bergmans
More informationJarcler: Aspect-Oriented Middleware for Distributed Software in Java
Jarcler: Aspect-Oriented Middleware for Distributed Software in Java Muga Nishizawa Shigeru Chiba Dept. of Mathematical and Computing Sciences Tokyo Institute of Technology Email: {muga,chiba@csg.is.titech.ac.jp
More informationClasses and Inheritance in Actor- Oriented Models
Classes and Inheritance in Actor- Oriented Models Stephen Neuendorffer Edward Lee UC Berkeley Chess Review May 8, 2003 Berkeley, CA Introduction Component-based design Object-oriented components Actor-oriented
More informationUML Specification and Correction of Object-Oriented Anti-patterns
UML Specification and Correction of Object-Oriented Anti-patterns Maria Teresa Llano and Rob Pooley School of Mathematical and Computer Sciences Heriot-Watt University Edinburgh, United Kingdom {mtl4,rjpooley}@hwacuk
More informationDESIGN PATTERN - INTERVIEW QUESTIONS
DESIGN PATTERN - INTERVIEW QUESTIONS http://www.tutorialspoint.com/design_pattern/design_pattern_interview_questions.htm Copyright tutorialspoint.com Dear readers, these Design Pattern Interview Questions
More informationLecture Notes on Programming Languages
Lecture Notes on Programming Languages 85 Lecture 09: Support for Object-Oriented Programming This lecture discusses how programming languages support object-oriented programming. Topics to be covered
More informationThe TTC 2011 Reengineering Challenge Using MOLA and Higher-Order Transformations
The TTC 2011 Reengineering Challenge Using MOLA and Higher-Order Transformations Agris Sostaks, Elina Kalnina, Audris Kalnins, Edgars Celms, and Janis Iraids Institute of Computer Science and Mathematics,
More informationSoftware Design Patterns. Background 1. Background 2. Jonathan I. Maletic, Ph.D.
Software Design Patterns Jonathan I. Maletic, Ph.D. Department of Computer Science Kent State University J. Maletic 1 Background 1 Search for recurring successful designs emergent designs from practice
More informationLate-bound Pragmatical Class Methods
Late-bound Pragmatical Class Methods AXEL SCHMOLITZKY, MARK EVERED, J. LESLIE KEEDY, GISELA MENGER Department of Computer Structures University of Ulm 89069 Ulm, Germany {axel, markev, keedy, gisela@informatik.uni-ulm.de
More informationDesign Patterns. Observations. Electrical Engineering Patterns. Mechanical Engineering Patterns
Introduction o to Patterns and Design Patterns Dept. of Computer Science Baylor University Some slides adapted from slides by R. France and B. Tekinerdogan Observations Engineering=Problem Solving Many
More informationA SYSTEMATIC APPROACH FOR COMPONENT-BASED SOFTWARE DEVELOPMENT
A SYSTEMATIC APPROACH FOR COMPONENT-BASED SOFTWARE DEVELOPMENT Cléver Ricardo Guareis de Farias, Marten van Sinderen and Luís Ferreira Pires Centre for Telematics and Information Technology (CTIT) PO Box
More information1 From Distributed Objects to Distributed Components
From Distributed Objects to Distributed : the Olan Approach Luc Bellissard, Michel Riveill BP 53, F 38041 Grenoble Cedex 9, FRANCE Phone: (33) 76 61 52 78 Fax: (33) 76 61 52 52 Email: Luc.Bellissard@imag.fr
More informationMartin P. Robillard and Gail C. Murphy. University of British Columbia. November, 1999
Migrating a Static Analysis Tool to AspectJ TM Martin P. Robillard and Gail C. Murphy Department of Computer Science University of British Columbia 201-2366 Main Mall Vancouver BC Canada V6T 1Z4 fmrobilla,murphyg@cs.ubc.ca
More informationDesign Patterns and Frameworks 1) Introduction
Design Patterns and Frameworks 1) Introduction Dr. Sebastian Götz Software Technology Group Department of Computer Science Technische Universität Dresden WS 16/17, Oct 11, 2016 Slides from Prof. Dr. U.
More informationPiecemeal Migration of a Document Archive System with an Architectural Pattern Language
Piecemeal Migration of a Document Archive System with an Architectural Pattern Language Michael Goedicke, Uwe Zdun Specification of Software Systems University of Essen, Germany goedicke uzdun @cs.uni-essen.de
More informationObject-Based Features
History of this Material Object-Based Features Luca Cardelli joint work with Mart n Abadi Digital Equipment Corporation Systems Research Center Designing a class-based language (Modula-3). Designing an
More informationObject-Oriented Design
Object-Oriented Design Lecturer: Raman Ramsin Lecture 10: Analysis Packages 1 Analysis Workflow: Packages The analysis workflow consists of the following activities: Architectural analysis Analyze a use
More informationComposition Graphs: a Foundation for Reasoning about Aspect-Oriented Composition
s: a Foundation for Reasoning about Aspect-Oriented - Position Paper - István Nagy Mehmet Aksit Lodewijk Bergmans TRESE Software Engineering group, Faculty of Computer Science, University of Twente P.O.
More informationIntroduction to Aspect-Oriented Programming
Introduction to Aspect-Oriented Programming LÁSZLÓ LENGYEL, TIHAMÉR LEVENDOVSZKY {lengyel, tihamer}@aut.bme.hu Reviewed Key words: aspect-oriented programming (AOP), crosscutting concerns Aspect-oriented
More informationConcurrent Object-Oriented Development with Behavioral Design Patterns
Concurrent Object-Oriented Development with Behavioral Design Patterns Benjamin Morandi 1, Scott West 1, Sebastian Nanz 1, and Hassan Gomaa 2 1 ETH Zurich, Switzerland 2 George Mason University, USA firstname.lastname@inf.ethz.ch
More information