Using AOP to build complex data centric component frameworks
|
|
- Gavin Gilbert
- 5 years ago
- Views:
Transcription
1 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 Celestijnenlaan 200A B-3001 Heverlee {tomma, bartvh, kdv, gerda, wouter}@cs.kuleuven.ac.be ABSTRACT This paper describes our experiences with building a component framework for a family of complex data processing applications. The framework architecture consists of a number of processing components operating on a central data structure. In building such a framework two important issues arise. The first issue concerns the complexity of the central data structure. The second problem arises when correct component compositions need to be made. The complex nature of the natural language processing application domain results in a core data structure, consisting of information common to the entire domain, plus a number of additional data types for each branch in the application framework. Due to the complexity and diversity of this information, these data types can easily cut across each other. We solved this problem by creating an aspect for each data type that may or may not cut across the core data structure. Secondly the component composition issue revealed the problem of hidden dependencies between components. These hidden dependencies complicate the creation of correct compositions with respect to component execution order. The dependencies boil down to the availability of componentspecific data. In our approach, we make the data availability requirement explicit by defining a number of dependency relations between processing components and aspects implementing the branch specific data types. These dependencies specify the types of data a component needs to be able to execute and the types of data that result from its execution. With this information we can create correctly ordered component compositions in a more validating way. In our component framework, aspects thus serve a dual role: On the one hand they solve the problem of cross cutting data structures, on the other hand they are used as a entities to validate component compositions. 1 Introduction Data processing applications usually revolve around a complex data structure that is processed and/or modified by a number of small subtasks. A possible way to model these applications is by the use of the pipes-and-filters architectural design pattern [1]. Each filter accepts a data structure, processes the data, stores its results in the data structure, and passes it on the next filter. In a framework environment, we would implement these filters to be small but welldefined tasks in order to obtain a set of highly reusable filters. Making an application would boil down to make a semantically meaningful composition of filters. In a data processing framework the data structure is an important issue. The data structure needs to contain all the necessary information relevant to the problem domain, and needs to be very flexible. Filters depend heavily on this data structure and every change made to the central data structure will affect all the filters.
2 In making filter compositions, one will soon notice there exist dependencies between different filters: filters need information stored in the data structure that is computed by other filters. However, a filter does not usually explicitly list these dependencies. The absence of this information renders it more difficult and more error prone to create valid compositions with respect to filter execution order. One could make an erroneous composition of filters and only become aware of it at runtime because the application would crash or produce erroneous results. Although there exist examples from pipeline architectures (See [3]) that check filter composability at compile-time through type checking, the data passed along these pipes is pretty simple. The type of data processing applications we target can have very complex data structures, which make simple type checking not feasible as composition validator. This paper describes our approach to solving this hidden component dependency problem. From now on we will talk about components because the complexity of our case study, a component framework for text processing systems, resulted in the processing subtasks being very configurable frameworks on their own. Section 2 elaborates on the text processing system we built. We will use this case study as an example in the paper. Section 3 clarifies the goals we wish to see accomplished. In section 4 we explain how we approached these goals using aspect-oriented programming. Finally section 5 discusses our approach. 2 Case study Our text processing system consists of a centralized tree based data structure. This core data structure reflects the structure of the text. The possible structure units are among others chapters, tables, bulleted lists, etc. The smallest structural unit is a paragraph consisting of a number of sentences with formatting information. The tree is designed to hold several variants of the same text. These variants can be several translations of the same text, or the same text annotated with application specific data. Next to the structured text content, the tree structure also contains data structures that are specific to several branches in the text-processing application domain. We will refer to these sub-data structures as component specific data types, because these data structures will only be used by certain processing components. The processing components in our framework are a number of visitors [2] that operate on the tree data structure. The visitor approach allows us to change our text-processing behavior with respect to the structure of the text. For example, in a translation system, we might want to use a different translation strategy for the items in a bulleted list than a normal paragraph. Every processing component is responsible for a small task in a branch of the large text-processing domain. Of course, a component will most likely use a subset of the component specific data types of the branch it belongs to. Component specific data types will usually be chosen in function of the processing components. In the case of a translation system, the components can be a dictionary lookup system, a chart parser, transfer and generation components, etc. The data types these components would use are the text structure, morphological information on words in the text, locale information, grammar parse trees and language transfer trees. 3 Goal To have more control over the semantic correctness of component compositions, we need to make the hidden dependencies between components explicit. These dependencies are mainly data-oriented: components use data computed by other components. The latter components will thus need to be executed before the first components. This introduces a partial order relation on the component execution. The order relation will allow us to check whether a list of selected components is in the correct order for execution. It will even allow us to create a possible but not necessarily unique or meaningful execution order out of a number of unordered components.
3 The data-oriented nature of the component dependencies is closely related to the component specific data types mentioned in section 2. Due to the wide range of applications possible in the domain of text processing applications, it is very likely that not all the data structures will perfectly align with the tree structure we use as a core data model. Component specific data types can thus cut across the core data structure. We want a mechanism to manage these cross cutting data types. 4 Approach 4.1 Cross cutting data types In a large application domain such as the text processing system domain, the core data structure can contain a large number of application specific data types. These component specific data types do not necessarily align well with a core data structure as the one described in Section 2. For example, component specific data structures used by a text categorization system may affect all structural nodes if the system wishes to use structural information. There exists no clean way to add all this structure related information to the central data structure without affecting the information and functionality in the classes that encapsulate text structure information. We defined a number of aspects ([4]) which each encapsulate a component specific data type. When a data type is needed, its corresponding aspect is woven through the core data structure. Since aspects define new data structures, they will consist mainly of introduction statements: new data members and data accessor methods (get/set) are introduced in the central data structure classes. How many classes of the central data structure are involved, and how many methods in these classes are affected depends on how much cross cutting there is with the core data structure. For example, in a translation system we will need a grammar tree, which is a grammatical representation of a sentence. The aspect implementing the grammar tree would cut across the classes that define the sentence data structure. A morphological information aspect would only affect the word related data structures. The data types we defined usually belong to a specific branch in the application domain. This results in aspects that affect only the central data structure, and have no interference relations with other aspects. In the translation system we developed, we did not encounter aspects that depend on other aspects. However, we do not want to conclude from this case study that dependencies between aspects will never occur. 4.2 Execution order Processing components have two different types of relations with the data types that exist in the data structure. Requires-dependencies denote the need for a specific type of data. Without that data, the processing component is not able to function. With a providesdependency, a component denotes that the results of its processing are of the given type, and that these results can be used by other components. These dependencies define a partial order relation between components. For example, if we would want to do a grammar check on a sentence in our data structure, we need morphological information on all the words in the text. This word lookup is implemented in a separate component due the potential complexity of the task: all possible declensions of every word need to be recognized, as well as numbers, roman numbers, dates, ISBN numbers, etc. For the grammar-checking component to work, the word lookup component needs to be executed first to retrieve morphological data and store this information in the central data structure. When given an ordered list of components, we can check the correctness of the order by checking data dependencies of all components in the list. The list would fail the correctness check when component with a requires-dependency for a given data type would occur, without being preceded by a component with a corresponding provides-dependency.
4 4.3 Aspects as composition tool To obtain a correct component execution order we check the availability of data types. Since aspects correspond to data types, we check for the availability of aspects. Consequently, to build an application out of an unordered list of components in practice, we check the aspect dependencies of the involved components to build or check the component execution order. We have made the component dependencies explicit by including an XML description for each component. Each XML description allows us to list a number of aspects for the two dependency types. When checking the order we need these XML descriptions of each component at composition time. 5 Discussion 5.1 The use of aspects We used aspects as a way to represent a number of data types that each address another concern within the same application domain. Obviously other technologies that takes separation of concerns to a higher level could be used. Data types could for instance be represented using a subject (Subject-oriented programming: [5]), or a hyperslice (Multi dimensional separation of concerns with the hyperspace approach: [6]). One could also decide to implement the component specific data structure handling on a meta level instead of using aspects. The meta level would offer us a generic execution model for the component specific data type handling. Meta level programming however can get very complex and are very difficult to reason about. It would have been possible to solve this problem using mixin inheritance. Every data structure would be implemented in a number of classes that would be unified into the classes of the central data structure when needed. However, for cross cutting component specific data types, this could result in a large number of classes and code duplication. We wanted to avoid this situation at all cost because of maintenance issues. With aspect-oriented programming approach, the component specific data structure is located in only one aspect. Using aspects as a technology to solve data representation issues is not conventional. One could claim that the design of the data structure is bad. Using aspects to add new data to a data structure may be considered as irresponsibly breaking of encapsulation. However when the data structures to be added do not align well with the core data structure, it is the most flexible and controlled way to add new data types. And this is exactly what a component builder wants in an application framework environment: flexibility in a controlled way. Aspects that address cross cutting behavior are conceptually not that much different from our data type aspects. They both address cross cutting issues. Without aspects or any similar technology, there is no way to add the cross cutting functionality or data without affecting the entire system. In the case of our data aspects this would mean changing or adding things to the core data structure, potentially breaking a large number of processing components. We also believe that the use of aspects will allow one to create components in a more isolated environment. Instead of having to cope with a large and monolithic data structure when creating a component, one will be able to create a component against the core data structure and the needed data types. If we would not use the aspect-oriented programming approach we would have to cope with a large monolithic data structure with a number of API s scattered all over the classes the data structure is made of. 5.2 Performance An additional benefit of using this aspect approach is the minimization of the memory usage of the central data structure. While checking or building a component execution order, we can deduce a list of the data types that will be needed in the central data structure from the component selection. These data types are the only data types next to the core data structure
5 that will be needed by the resulting application and are thus the only ones that will be woven through the core data structure. Next to space performance, the aspect approach also implies an execution performance improvement with respect to a meta programming solution. All component specific data type handling would imply code execution on the meta level. In a data processing application context where data may be consulted a lot, this can mean a serious performance penalty. 5.3 Composition restrictions Although the aspect dependencies help us in making correct compositions, it is still possible to make bad or meaningless compositions. For instance, suppose you have a component that implements an entire translation system (that would be a very bad software design, but it is justified for the sake of the example) and a component that prints out a number of variants of the text that reside in the data structure. If you want to make an application that translates a text from English to Dutch, and then prints out the translation of the text, the only data type that needs to be available for the printing component is text. Text is the core of the text-processing framework; that type of data will always be available. It will never be possible to calculate an unambiguous component execution order if they don t share any data type dependencies except for the default dependencies. In our example, we could calculate a correct execution order if we could make any suppositions on the contents of the data structure. However dependencies currently only allow us to make suppositions on the type of the data, not on the content of these data types; data types have no semantic meaning. There is no way to tell that the printing component can execute only when there is a Dutch variant of the text available. 6 References [1] F. Buschmann, R. Meunier, H. Rohnert, P. Sommerlad, M. Stal, A System of Patterns, John Wiley and Sons, ISBN [2] Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. Design Patterns : Elements of reusable Object-Oriented Software. Addison-Wesley, Reading, Massachusetts, first edition, 1995 [3] Edward J. Posnak, R. Greg Lavender, and Harrick M. Vin. An adaptive framework for developing multimedia software components. Communications of the ACM, 40(10):43-47, October [4] Gregor Kiczales, John Lamping, Anurag Mendhekar, Chris Maeda, Cristina Videira Lopes, Jean- Marc Loingtier, John Irwin. "Aspect-Oriented Programming. In proceedings of the European Conference on Object-Oriented Programming (ECOOP), Finland. Springer-Verlag LNCS June [5] William Harrison and Harold Ossher. "Subject-oriented programming (a critique of pure objects)." In Proceedings of the Conference on Object-Oriented Programming: Systems, Languages, and Applications (OOPSLA), September [6] Harold Ossher and Peri Tarr. "Multi-Dimensional Separation of Concerns and the Hyperspace Approach." In Proceedings of the Symposium on Software Architectures and Component Technology: The State of the Art in Software Development. Kluwer, (To appear.)
Martin 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 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 informationA Unit Testing Framework for Aspects without Weaving
A Unit Testing Framework for Aspects without Weaving Yudai Yamazaki l01104@sic.shibaura-it.ac.jp Kouhei Sakurai sakurai@komiya.ise.shibaura-it.ac.jp Saeko Matsuura matsuura@se.shibaura-it.ac.jp Hidehiko
More informationMulti-Dimensional Separation of Concerns and IBM Hyper/J
Multi-Dimensional Separation of Concerns and IBM Hyper/J Technical Research Report Barry R. Pekilis Bell Canada Software Reliability Laboratory Electrical and Computer Engineering University of Waterloo
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 informationAbstract. Introduction
Aspect of Life-Cycle Control in a C++ Framework Lutz Dominick Siemens AG, Corporate Technology, ZT SE 1 D-81730 Munich, Germany Lutz.Dominick@mchp.siemens.de April 1999 Abstract This paper presents some
More informationDesign Patterns. Gunnar Gotshalks A4-1
Design Patterns A4-1 On Design Patterns A design pattern systematically names, explains and evaluates an important and recurring design problem and its solution Good designers know not to solve every problem
More informationDynamic Weaving for Building Reconfigurable Software Systems
Dynamic Weaving for Building Reconfigurable Software Systems FAISAL AKKAWI Akkawi@cs.iit.edu Computer Science Dept. Illinois Institute of Technology Chicago, IL 60616 ATEF BADER abader@lucent.com Lucent
More informationSeparation of Concerns
Separation of Concerns Erik Ernst Dept. of Computer Science, University of Aarhus, Denmark eernst@daimi.au.dk Abstract. Separation of concerns is a crucial concept in discussions about software engineering
More informationPattern Transformation for Two-Dimensional Separation of Concerns
Transformation for Two-Dimensional Separation of Concerns Xiaoqing Wu, Barrett R. Bryant and Jeff Gray Department of Computer and Information Sciences The University of Alabama at Birmingham Birmingham,
More informationAn Aspect-Based Approach to Modeling Security Concerns
An Aspect-Based Approach to Modeling Security Concerns Geri Georg Agilent Laboratories, Agilent Technologies, Fort Collins, USA geri_georg@agilent.com Robert France, Indrakshi Ray Department of Computer
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 informationAnalysing the navigational aspect
A. M. Reina Dpto. Lenguajes y Sistemas Informáticos Universidad de Sevilla. e-mail: reinaqu@lsi.us.es Analysing the navigational aspect J. Torres Dpto. Lenguajes y Sistemas Informáticos Universidad de
More informationDynamic Weaving for Building Reconfigurable Software Systems
Dynamic Weaving for Building Reconfigurable Software Systems JAGDISH LAKHANI lakhjag@iitedu Computer Science Dept Illinois Institute of Technology Chicago, IL 60616 FAISAL AKKAWI akkawif@iitedu Computer
More informationPublication granted for ECOOP 2000 purposes
Position paper: Instrumentation aspects require symmetric join points Lutz Dominick Siemens AG, Corporate Technology, ZT SE 2 D-81730 Munich, Germany Lutz.Dominick@mchp.siemens.de March 2000 Publication
More informationTowards a formal model of object-oriented hyperslices
Towards a formal model of object-oriented hyperslices Torsten Nelson, Donald Cowan, Paulo Alencar Computer Systems Group, University of Waterloo {torsten,dcowan,alencar}@csg.uwaterloo.ca Abstract This
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 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 informationTowards Reusable Heterogeneous Data-Centric Disentangled Parts
Towards Reusable Heterogeneous Data-Centric Disentangled Parts Michael Reinsch and Takuo Watanabe Department of Computer Science, Graduate School of Information Science and Technology, Tokyo Institute
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 informationProduct Line Evolution Using Source Packages
Product Line Evolution Using Source Packages Arie van Deursen Merijn de Jonge CWI P.O. Box 94079, 1090 GB Amsterdam, The Netherlands http://www.cwi.nl/ {arie,mdejonge} Abstract We present a language-independent
More informationModel-Driven Design Using Business Patterns
Model-Driven Design Using Business Patterns Bearbeitet von Pavel Hruby 1. Auflage 2006. Buch. xvi, 368 S. Hardcover ISBN 978 3 540 30154 7 Format (B x L): 15,5 x 23,5 cm Gewicht: 1590 g Wirtschaft > Volkswirtschaft
More informationMeta-architecture se parates business logic from
70 Meta-architecture se parates business logic from design issues Michel Coriat LCAT1 Thomson-CSF LCR Domaine de Corbeville -91404 Orsay Cedex -France michel.coriat@lcr.thomson -csf.com Abstract Reflection
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 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 informationTowards Better Support for Pattern-Oriented Software Development
Towards Better Support for Pattern-Oriented Software Development Dietrich Travkin Software Engineering Research Group, Heinz Nixdorf Institute & Department of Computer Science, University of Paderborn,
More informationA System of Patterns for Web Navigation
A System of Patterns for Web Navigation Mohammed Abul Khayes Akanda and Daniel M. German Department of Computer Science, University of Victoria, Canada maka@alumni.uvic.ca, dmgerman@uvic.ca Abstract. In
More informationBugdel: An Aspect-Oriented Debugging System
Bugdel: An Aspect-Oriented Debugging System Yoshiyuki Usui and Shigeru Chiba Dept. of Mathematical and Computing Sciences Tokyo Institute of Technology 2-12-1-W8-50 Ohkayama, Meguro-ku Tokyo 152-8552,
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 informationUsing Hyper/J to implement Product-Lines: A Case Study
Using Hyper/J to implement Product-Lines: A Case Study Roberto E. Lopez-Herrejon and Don Batory Department of Computer Sciences The University of Texas Austin, Texas 78712 {rlopez,batory@cs.utexas.edu
More informationA Meta-Model for Composition Techniques in Object-Oriented Software Development
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 E-Mail:
More informationPolicy evaluation contracts
Policy evaluation contracts Tom Goovaerts Bart De Win Wouter Joosen Report CW 543, May 2009 n Katholieke Universiteit Leuven Department of Computer Science Celestijnenlaan 200A B-3001 Heverlee (Belgium)
More informationSafe Aspect Composition. When dierent aspects [4] are composed, one must ensure that the resulting
Safe Composition Laurent Bussard 1, Lee Carver 2, Erik Ernst 3, Matthias Jung 4, Martin Robillard 5, and Andreas Speck 6 1 I3S { CNRS UPRESA 6070 { B^at ESSI, 06190 Sophia-Antipolis, France, bussard@essi.fr
More informationX-S Framework Leveraging XML on Servlet Technology
X-S Framework Leveraging XML on Servlet Technology Rajesh Kumar R Abstract This paper talks about a XML based web application framework that is based on Java Servlet Technology. This framework leverages
More informationAPPLYING OBJECT-ORIENTATION AND ASPECT-ORIENTATION IN TEACHING DOMAIN-SPECIFIC LANGUAGE IMPLEMENTATION *
APPLYING OBJECT-ORIENTATION AND ASPECT-ORIENTATION IN TEACHING DOMAIN-SPECIFIC LANGUAGE IMPLEMENTATION * Xiaoqing Wu, Barrett Bryant and Jeff Gray Department of Computer and Information Sciences The University
More informationObject-Oriented Software Development Goal and Scope
Object-Oriented Software Development Goal and Scope Koichiro Ochimizu Japan Advanced Institute of Science and Technologies School of Information Science Scope and Goal Goal enable you to understand basic
More informationAOSD Explained: ASPECT-ORIENTED SYSTEM DEVELOPMENT
Explained: ASPECT-ORIENTED SYSTEM DEVELOPMENT Background & Implications Professor Emeritus Birkbeck College 1 AOSD - Background AOSD - Aspect-Oriented Software Development, AOSD - Aspect-Oriented System
More informationFrameworks Representations & Perspectives Position Paper Workshop on Language Support for Design Patterns and Frameworks, ECOOP 97
Frameworks Representations & Perspectives Position Paper Workshop on Language Support for Design Patterns and Frameworks, ECOOP 97 Palle Nowack Department of Computer Science, Aalborg University Fredrik
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 information1 (ERTSDP) ERTSDP (Embedded Real-Time Systems Design Pattern) (1)
[ ] ERTSDP [ ] UML 1 Liskov [1-4] Gamma 25 [5] GammaBruce Douglas UML [6] ERTSDP Bruce Douglass 2 (ERTSDP) 2.1 [7-9] (problem) QoS (solution) (consequences) 2.2 ERTSDP (Embedded Real-Time Systems Design
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 informationPatterns in Software Engineering
Patterns in Software Engineering Lecturer: Raman Ramsin Lecture 8 GoV Patterns Architectural Part 2 1 Architectural Patterns: Categories From Mud to Structure Layers, Pipes and Filters, and Blackboard
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 informationWS01/02 - Design Pattern and Software Architecture
Design Pattern and Software Architecture: VIII. Conclusion AG Softwaretechnik Raum E 3.165 Tele. 60-3321 hg@upb.de VIII. Conclusion VIII.1 Classifications VIII.2 Common Misconceptions VIII.3 Open Questions
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 informationTowards a Global Component Architecture for Learning Objects: An Ontology Based Approach
Towards a Global Component Architecture for Learning Objects: An Ontology Based Approach Katrien Verbert, Joris Klerkx, Michael Meire, Jehad Najjar, and Erik Duval Dept. Computerwetenschappen, Katholieke
More informationL23.1 Introduction... 2
Department of Computer Science COS121 Lecture Notes: L23 Adapter Design Pattern 23 & 26 September 2014 Copyright c 2014 by Linda Marshall and Vreda Pieterse. All rights reserved. Contents L23.1 Introduction.................................
More informationModel Composition Directives
Model Composition Directives Greg Straw, Geri Georg, Eunjee Song, Sudipto Ghosh, Robert France, and James M. Bieman Department of Computer Science Colorado State University, Fort Collins, CO, 80523 {straw,
More informationFrom Contracts to Aspects in UML Designs
From Contracts to Aspects in UML Designs Jean-Marc Jézéquel, and Noël Plouzeau Irisa (INRIA & University of Rennes) Campus de Beaulieu +33 2 99 84 71 92 e-mail: {jezequel, plouzeau}@irisa.fr Torben Weis,
More informationProceedings of. The Three-Tier Architecture Pattern Language Design Fest
Proceedings of The Three-Tier Architecture Pattern Language Design Fest Introduction Three-tier applications have gained increasing acceptance and popularity in the software industry. Three-tier applications
More informationIngegneria del Software Corso di Laurea in Informatica per il Management. Design Patterns part 1
Ingegneria del Software Corso di Laurea in Informatica per il Management Design Patterns part 1 Davide Rossi Dipartimento di Informatica Università di Bologna Pattern Each pattern describes a problem which
More informationSlide 1. Design Patterns. Prof. Mirco Tribastone, Ph.D
Slide 1 Design Patterns Prof. Mirco Tribastone, Ph.D. 22.11.2011 Introduction Slide 2 Basic Idea The same (well-established) schema can be reused as a solution to similar problems. Muster Abstraktion Anwendung
More informationUML4COP: UML-based DSML for Context-Aware Systems
UML4COP: UML-based DSML for Context-Aware Systems Naoyasu Ubayashi Kyushu University ubayashi@acm.org Yasutaka Kamei Kyushu University kamei@ait.kyushu-u.ac.jp Abstract Context-awareness plays an important
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 informationA Metamodeling Approach to Model Refactoring
A Metamodeling Approach to Model Refactoring Sheena R. Judson, Doris L. Carver, and Robert France 2 Department of Computer Science, Louisiana State University Baton Rouge, Louisiana USA sheena.r.judson@lmco.com,
More informationArchitectural Patterns
Architectural Patterns Dr. James A. Bednar jbednar@inf.ed.ac.uk http://homepages.inf.ed.ac.uk/jbednar Dr. David Robertson dr@inf.ed.ac.uk http://www.inf.ed.ac.uk/ssp/members/dave.htm SEOC2 Spring 2005:
More informationEvolvable Pattern Implementations need Generic Aspects
Evolvable Pattern Implementations need Generic Aspects Günter Kniesel, Tobias Rho Dept. of Computer Science III, University of Bonn Römerstr. 164, D-53117 Bonn, Germany gk,rho@cs.uni-bonn.de Stefan Hanenberg
More informationAdvanced Object Oriented PHP
CNM STEMulus Center Web Development with PHP November 11, 2015 1/17 Outline 1 2 Diamond Problem Composing vs Inheriting Case Study: Strategy Design Pattern 2/17 Definition is when a class is based on another
More informationThe following topics will be covered in this course (not necessarily in this order).
The following topics will be covered in this course (not necessarily in this order). Introduction The course focuses on systematic design of larger object-oriented programs. We will introduce the appropriate
More informationUniversal Communication Component on Symbian Series60 Platform
Universal Communication Component on Symbian Series60 Platform Róbert Kereskényi, Bertalan Forstner, Hassan Charaf Department of Automation and Applied Informatics Budapest University of Technology and
More informationDesign Patterns. Architectural Patterns. Contents of a Design Pattern. Dr. James A. Bednar. Dr. David Robertson
Design Patterns Architectural Patterns Dr. James A. Bednar jbednar@inf.ed.ac.uk http://homepages.inf.ed.ac.uk/jbednar Dr. David Robertson dr@inf.ed.ac.uk http://www.inf.ed.ac.uk/ssp/members/dave.htm A
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 informationDesign Patterns For Object Oriented Software Development Acm Press
Design Patterns For Object Oriented Software Development Acm Press We have made it easy for you to find a PDF Ebooks without any digging. And by having access to our ebooks online or by storing it on your
More informationCSCD01 Engineering Large Software Systems. Design Patterns. Joe Bettridge. Winter With thanks to Anya Tafliovich
CSCD01 Engineering Large Software Systems Design Patterns Joe Bettridge Winter 2018 With thanks to Anya Tafliovich Design Patterns Design patterns take the problems consistently found in software, and
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 informationRecitation 13. Software Engineering Practices and Introduction to Design Patterns
Recitation 13 Software Engineering Practices and Introduction to Design Patterns Software Development is chaotic During that 90% time: Good engineers think, research, read the codebase, and recognize design
More informationControl-Flow-Graph-Based Aspect Mining
Control-Flow-Graph-Based Aspect Mining Jens Krinke FernUniversität in Hagen, Germany krinke@acm.org Silvia Breu NASA Ames Research Center, USA silvia.breu@gmail.com Abstract Aspect mining tries to identify
More informationCrash course on design patterns
Crash course on design patterns Yann-Gaël Guéhéneuc guehene@emn.fr From Olivier Motelet s course (2001/10/17) École des Mines de Nantes, France Object Technology International, Inc., Canada Design patterns
More informationAs a programmer, you know how easy it can be to get lost in the details
Chapter 1 Congratulations, Your Problem Has Already Been Solved In This Chapter Introducing design patterns Knowing how design patterns can help Extending object-oriented programming Taking a look at some
More informationCapturing and Formalizing SAF Availability Management Framework Configuration Requirements
Capturing and Formalizing SAF Availability Management Framework Configuration Requirements A. Gherbi, P. Salehi, F. Khendek and A. Hamou-Lhadj Electrical and Computer Engineering, Concordia University,
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 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 informationCS/CE 2336 Computer Science II
CS/CE 2336 Computer Science II UT D Session 20 Design Patterns An Overview 2 History Architect Christopher Alexander coined the term "pattern" circa 1977-1979 Kent Beck and Ward Cunningham, OOPSLA'87 used
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 informationUsing Structure and Dependency Tracing Patterns for Aspect Composition
Using Structure and Dependency Tracing Patterns for Aspect Composition Uwe Zdun New Media Lab, Department of Information Systems Vienna University of Economics and BA, Austria zdun@acm.org Abstract Aspects
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 informationA Metric of the Relative Abstraction Level of Software Patterns
A Metric of the Relative Abstraction Level of Software Patterns Atsuto Kubo 1, Hironori Washizaki 2, and Yoshiaki Fukazawa 1 1 Department of Computer Science, Waseda University, 3-4-1 Okubo, Shinjuku-ku,
More informationDESIGN PATTERN MATCHING
PERIODICA POLYTECHNICA SER. EL. ENG. VOL. 47, NO. 3 4, PP. 205 212 (2003) DESIGN PATTERN MATCHING Dániel PETRI and György CSERTÁN Department of Measurement and Information Systems Budapest University of
More informationPatterns for Decoupling
Patterns for Decoupling Ingolf H. Krueger Department of Computer Science & Engineering University of California, San Diego La Jolla, CA 92093-0114, USA California Institute for Telecommunications and Information
More informationUsing Design Patterns in Java Application Development
Using Design Patterns in Java Application Development ExxonMobil Research & Engineering Co. Clinton, New Jersey Michael P. Redlich (908) 730-3416 michael.p.redlich@exxonmobil.com About Myself Degree B.S.
More informationCharacteristics of Runtime Program Evolution
Characteristics of Runtime Program Evolution Mario Pukall and Martin Kuhlemann School of Computer Science, University of Magdeburg, Germany {pukall, kuhlemann}@iti.cs.uni-magdeburg.de Abstract. Applying
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 informationCHAPTER 6: CREATIONAL DESIGN PATTERNS
CHAPTER 6: CREATIONAL DESIGN PATTERNS SESSION I: OVERVIEW OF DESIGN PATTERNS, ABSTRACT FACTORY Software Engineering Design: Theory and Practice by Carlos E. Otero Slides copyright 2012 by Carlos E. Otero
More informationImproving Software Modularity using AOP
B Vasundhara 1 & KV Chalapati Rao 2 1 Dept. of Computer Science, AMS School of Informatics, Hyderabad, India 2 CVR College of Engineering, Ibrahimpatnam, India E-mail : vasu_venki@yahoo.com 1, chalapatiraokv@gmail.com
More informationDesign for Testability
Abstract Design for Testability Stefan Jungmayr Testability is a software quality characteristic that is of major relevance for test costs and software dependability. Still, testability is not an explicit
More informationPartial Acquisition Prashant Jain and Michael Kircher
1 Partial Acquisition Prashant Jain and Michael Kircher {Prashant.Jain,Michael.Kircher}@mchp.siemens.de Siemens AG, Corporate Technology Munich, Germany Partial Acquisition 2 Partial Acquisition The Partial
More informationAPICES - Rapid Application Development with Graph Pattern
APICES - Rapid Application Development with Graph Pattern Ansgar Bredenfeld GMD Institute for System Design Technology D-53754 Sankt Augustin, Germany bredenfeld@gmd.de Abstract In this paper, we present
More informationAn Automatic Visitor Generator for Ada
An Automatic Visitor Generator for Ada Martin C. Carlisle Department of Computer Science 2354 Fairchild Dr., Suite 1J133 US Air Force Academy, CO 80840 carlislem@acm.org Ricky E. Sward Department of Computer
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 informationAcyclic Visitor Pattern in Formulation of Mathematical Model
Acyclic Visitor Pattern in Formulation of Mathematical Model Ales CEPEK and Jan PYTEL, Czech Republic Key words: acyclic visitor pattern, mathematical model. SUMMARY This paper discusses the use and advantages
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 informationDesign Patterns. An introduction
Design Patterns An introduction Introduction Designing object-oriented software is hard, and designing reusable object-oriented software is even harder. Your design should be specific to the problem at
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 informationTransparent Remote Access
Abstract Transparent Remote Access Klaus Marquardt Käthe-Kollwitz-Weg 14, D-23558 Lübeck, Germany Email: marquardt@acm.org In distributed systems, the different processors communicate via network messages.
More informationA case in Multiparadigm Programming : User Interfaces by means of Declarative Meta Programming
A case in Multiparadigm Programming : User Interfaces by means of Declarative Meta Programming S. Goderis W. De Meuter J. Brichau Programming Technology Lab, Vrije Universiteit Brussel, Belgium Abstract.
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 informationINCORPORATING ADVANCED PROGRAMMING TECHNIQUES IN THE COMPUTER INFORMATION SYSTEMS CURRICULUM
INCORPORATING ADVANCED PROGRAMMING TECHNIQUES IN THE COMPUTER INFORMATION SYSTEMS CURRICULUM Charles S. Saxon, Eastern Michigan University, charles.saxon@emich.edu ABSTRACT Incorporating advanced programming
More informationComposition 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 informationApplying Aspect Oriented Programming on Security
Original Article Applying Aspect Oriented Programming on Security Mohammad Khalid Pandit* 1, Azra Nazir 1 and Arutselvan M 2 1 Department of computer Science and engineering, National institute of technology
More information