DOCSLIB.ORG

Aspect-Oriented Programming to Improve Modularity of Object-Oriented Applications

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Aspect-Oriented Programming to Improve Modularity of Object-Oriented Applications 2454 JOURNAL OF SOFTWARE, VOL. 9, NO. 9, SEPTEMBER 2014 Aspect-Oriented Programming to Improve Modularity of Object-Oriented Applications Jose M. Felix Principality of Asturias, Computer Science Department, Oviedo, Spain Email: [email protected] Francisco Ortin University of Oviedo, Computer Science Department, Oviedo, Spain Email: [email protected] Abstract— The separation of concerns design principle modularized with the mechanisms provided by common improves software reutilization, understandability, object-oriented languages [3]. extensibility and maintainability. By using the object- The different (functional and non-functional) oriented paradigm, it is not always possible to separate into requirements demanded to an application are called independent modules the different concerns of an concerns application. The result is that the source code of crosscutting software [4]. The Separation of Concerns (SoC) concerns are tangled and scattered across the whole design principle is aimed at separating a computer application. Aspect-oriented programming offers a higher application into distinct modules, such that each one level of modularity, providing a solution for the code addresses a separate concern [4]. tangling and scattering problem. To show how aspect- Some concerns cannot be directly modularized in oriented programming can be used as a suitable mechanism classic object-oriented languages because those languages to improve the modularity of object-oriented applications, have not sufficient expressiveness to implement them in this divulgative article presents the implementation of a independent modules. In that case, the implementations typical design pattern following both the object- and aspect- of those concerns cut across multiple abstractions in a oriented paradigms. The two approaches are compared from the modularity perspective, establishing a discussion program. For this reason, these concerns are said to be on the benefits provided and is current use. crosscutting [5]. Figure 1 shows a real example. This figure presents the modularization of the Apache Tomcat Index Terms—aspect-oriented programming, modularity, application server implementation [6]. Each vertical bar crosscutting concerns, AspectJ, separation of concerns shows one implementation module, and its size is proportional to the number of lines of code. The left-hand side of Figure 1 shows in red the lines of code whose I. INTRODUCTION concern is XML document parsing. It can be seen how that functionality is placed in one single module. The Designing modular systems is fundamental for right-hand side of Figure 1 shows the source code managing software complexity and improving its distribution of the logging concern. This is an example of reusability, understandability, extensibility and a crosscutting concern: its source code is not placed in a maintainability [1]. At the implementation level, unique module (code scattering), and every module, programming languages provide mechanisms to perform including XML parsing, contains code of this concern this modularization. Some common features of object- (code tangling). This code scattering and tangling issues oriented languages used to facilitate the modularization of indicate that the implementation-level modularization is application abstractions are methods, classes, packages, not appropriate, leading to reusability, understandability namespaces and annotations. There exist some other and maintainability limitations [4]. modularization mechanisms, not directly supported by The main contribution of this divulgative paper is a programming languages, which provide a higher level of practical analysis of how Aspect-Oriented Programming abstraction. Examples of these mechanisms are (AOP) provides an alternative mechanism to solve the components, design patterns, application frameworks, code tangling and scattering problems in the and architectural patterns. implementation of crosscutting concerns. In order to do In the software development process, there are cases that, Section II introduces the main AOP concepts and when some system abstractions cannot be directly AspectJ, one of the most widely used AOP tools modularized with the mechanisms provided by a nowadays [7]. Section III presents an example of a programming language [2]. A vector sorting algorithm common design problem, comparing the object- and can be implemented in a unique class method. However, aspect-oriented implementations. Afterwards, the functionalities such as error detection and correction, suitability of AOP for improving modularity is discussed logging, persistence and security cannot be directly © 2014 ACADEMY PUBLISHER doi:10.4304/jsw.9.9.24454-2460 JOURNAL OF SOFTWARE, VOL. 9, NO. 9, SEPTEMBER 2014 2455 a) Distribution of the XML parsing concern b) Distribution of the logging concern Figure 1. Distribution of concerns (source code per module) in the implementation of Apache Tomcat [6]. Modules of the Concerns Final Application Requirements Functional Concern 1 Functional Concern 2 Functional Concern 3 Weaver Persistence Concern Logging Concern Figure 2. Weaving the different concerns identified from the application requirements. in Section IV, and the conclusions and future work are other concerns (e.g., logging). However, the rest of presented in Section V. concerns are scattered among multiple modules, and tangled with the code of other concerns. Therefore, AOP II. ASPECT-ORIENTED PROGRAMMING raises the level of abstraction, offering the programmer a modularization mechanism superior to that provided by Separating the different concerns of an application is object orientation. The aspect weaver is the tool that an objective in all the steps of the software development translates the aspect-oriented abstractions into the object- process. Aspect-orientation is a particular mechanism to oriented ones. achieve the SoC goal. Aspect-Oriented Software There exist two approaches for representing concerns Development (AOSD) focuses on the identification, in AOP. Asymmetric AOP distinguishes the base code specification and representation of cross-cutting concerns (traditional classes in the classical object orientation) and their modularization in all the steps of the software from the aspects. Aspects represent crosscutting concerns development process. Therefore, aspect-orientation can that, due to the aspect weaver, can be modularized. be applied to requirement engineering, business process Therefore, in asymmetric AOP, an aspect must be used to management, system architecture, modelling and design be woven with a class (or another aspect). AspectJ is an [8]. In this article we focus on aspect-oriented example tool that provides asymmetric AOP [7]. On programming, which is centered on the programming contrary, symmetric AOP is based on the unique concept techniques and tools to support the modularization of of class/aspect. Any class can act as an aspect and be concerns at the level of the application source code [4]. woven with any other class (or aspect). Hyper/J is an As shown in Figure 2, the different concerns of an example of symmetric AOP [9]. application are identified from its requirements. Before In general, aspect weaving is performed statically, its implementation, the application concerns are before application execution. AspectJ also provides load- conceptually separated. These concerns comprise both time aspect weaving, when classes are about to be loaded functional (i.e., problem domain) and non-functional (e.g., into memory by the virtual machine. There are also AOP persistence or logging) requirements. The objective of tools that allows aspect weaving and unweaving at AOP is to modularize all these concerns. The aspect runtime, when the application is being executed [10]. weaver is the tool that takes the different concerns of an These dynamic weavers adapt running applications at application and generates the target program. If the final stable points of execution. Examples of these dynamic application is coded in an object-oriented language, such AOP tools are the JAsCo, PROSE and DSAW platforms as Java or C#, the target code of the different concerns [11]. may be tangled and scattered. Figure 2 shows how the Aspect-oriented programming has been included in final implementations of the functional concerns 1 and 2 widespread application server frameworks such as JBoss are placed in one single module, tangled with the code of or Spring. There are other implementations, such as JAC, © 2014 ACADEMY PUBLISHER 2456 JOURNAL OF SOFTWARE, VOL. 9, NO. 9, SEPTEMBER 2014 «interface» Subject «interface» -observers Observer + addObserver(Observer) + removeObserver(Observer) * + update() + updateObservers() Alarm Timer Clock - hour: int - hour: int + addObserver(Observer) -clock - minute: int - minute: int + removeObserver(Observer) - second: int System.out.println("Tick"); - second: int + tick() 1 - message: String this.updateObservers(); + updateObservers() + incrementOneSecond() + checkAlarm() + update() + update() for(Observer observer:observers) observer.update(); this.incrementOneSecond(); this.checkAlarm(); System.out.println(this); Figure 3. Object-oriented implementation of the Observer design pattern. aimed at developing an aspect-oriented middleware layer. Each Subject holds a collection of Observers by Another criterion to classify AOP tools is their domain. means of the observers field, and the addObserver They could be used for general purposes, such as AspectJ, and removeObserver methods. Although there
Load more

Recommended publications
  • A Brief Introduction to Aspect-Oriented Programming
    R R R A Brief Introduction to Aspect-Oriented Programming" R R Historical View Of Languages" R •# Procedural language" •# Functional language" •# Object-Oriented language" 1 R R Acknowledgements" R •# Zhenxiao Yang" •# Gregor Kiczales" •# Eclipse website for AspectJ (www.eclipse.org/aspectj) " R R Procedural Language" R •# Also termed imperative language" •# Describe" –#An explicit sequence of steps to follow to produce a result" •# Examples: Basic, Pascal, C, Fortran" 2 R R Functional Language" R •# Describe everything as a function (e.g., data, operations)" •# (+ 3 4); (add (prod 4 5) 3)" •# Examples" –# LISP, Scheme, ML, Haskell" R R Logical Language" R •# Also termed declarative language" •# Establish causal relationships between terms" –#Conclusion :- Conditions" –#Read as: If Conditions then Conclusion" •# Examples: Prolog, Parlog" 3 R R Object-Oriented Programming" R •# Describe " –#A set of user-defined objects " –#And communications among them to produce a (user-defined) result" •# Basic features" –#Encapsulation" –#Inheritance" –#Polymorphism " R R OOP (cont$d)" R •# Example languages" –#First OOP language: SIMULA-67 (1970)" –#Smalltalk, C++, Java" –#Many other:" •# Ada, Object Pascal, Objective C, DRAGOON, BETA, Emerald, POOL, Eiffel, Self, Oblog, ESP, POLKA, Loops, Perl, VB" •# Are OOP languages procedural? " 4 R R We Need More" R •# Major advantage of OOP" –# Modular structure" •# Potential problems with OOP" –# Issues distributed in different modules result in tangled code." –# Example: error logging, failure handling, performance
    [Show full text]
  • Weaving Ontology Aspects Using a Catalog of Structural Ontology Design Patterns
    Weaving Ontology Aspects Using a Catalog of Structural Ontology Design Patterns Ralph Schäfermeier and Adrian Paschke Corporate Semantic Web Group, Institute of Computer Science, Freie Universität Berlin, Germany {schaef,paschke}@inf.fu-berlin.de http://www.csw.inf.fu-berlin.de Abstract. Modular development of ontologies proves beneficial at dif- ferent stages of the ontology lifecycle. In our previous work, we proposed aspect-oriented ontology development as a flexible approach to modular ontology development and a-posteriori modularization of existing mono- lithic ontologies, inspired by aspect-oriented programming and based on so called cross-cutting concerns. Similar to other formalisms for mod- ular ontologies (e.g. E-Connections), aspect-oriented ontologies rely on an extension of the used ontology language. This derivation from the standard in turn requires specially adapted tools in order to use these ontologies in applications. In this paper, we present an approach to the recombination of aspect-oriented ontology modules to standard OWL 2 ontologies by using an aspect-weaving service. The weaving service relies on a preconfigured catalog of structural ontology design patterns. We show that the use of the weaving service yields syntactically correct and semantically complete ontologies while still allowing ontology developers to fully benefit from modular ontology development. Keywords: Aspect-Oriented Ontology Development, Aspect-Oriented Programming, Ontology Modularization, Ontology Design Patterns 1 Introduction Modular ontology development has proved beneficial when it comes to improve- ment of reasoning and query result retrieval performance, scalability for ontol- ogy evolution and maintenance, complexity management, amelioration of un- derstandability, reuse, context-awareness, and personalization [17]. A significant amount of research work has been dedicated in the field of ontology modular- ization, and various kinds of approaches tackle the problem from different per- spectives.
    [Show full text]
  • Aspectj in Action, Second Edition
    Introducing AspectJ This chapter covers ■ Writing an AspectJ “Hello, world!” application ■ Becoming familiar with the AspectJ language ■ Weaving mechanisms ■ Integrating with Spring In chapter 1, we focused on general concepts in AOP. With those behind us, we can now look at one specific AOP implementation: AspectJ. AspectJ is an aspect- oriented extension to the Java programming language. Like any AOP implementa- tion, AspectJ consists of two parts: the language specification, which defines the grammar and semantics of the language; and the language implementation, which includes weavers that take various forms such as a compiler and a linker. A weaver produces byte code that conforms to the Java byte-code specification, allowing any compliant Java virtual machine (VM) to execute those class files. The language implementation also offers support for integrated development environments (IDEs), to simplify building and debugging applications. AspectJ started and initially grew as a special language that extends the Java lan- guage with new keywords. It also provided a special compiler that could understand those extensions. But recently, a lot has changed in its form as a language, as well as 27 Licensed to Manning Marketing <[email protected]> 28 CHAPTER 2 Introducing AspectJ in the weaver. First, AspectJ offers an alternative syntax based on the Java annotation facil- ity to express crosscutting constructs. This lets you use a plain Java compiler instead of the special compiler. Second, AspectJ offers new options for weaving classes with aspects. Finally, it has gained a strong foothold in the Spring Framework with several integration options. All these changes have made adoption of AspectJ easier than ever before.
    [Show full text]
  • Aspect-Oriented Software Development for Real-Time and Internet Applications
    International Research Journal of Engineering and Technology (IRJET) e-ISSN: 2395-0056 Volume: 05 Issue: 09 | Sep 2018 www.irjet.net p-ISSN: 2395-0072 Aspect-Oriented Software Development for Real-Time and Internet Applications Ogbonna J. C.1, Nwokoma F. O.2, Nwala K. T.3, Nwandu I. C.4 1,3Reseacher, Dept. of Computer Science, Clifford University Owerrinta, Abia State Nigeria 2,4Reseacher, Dept. of Computer Science, Federal University of Technology Owerri, Imo State Nigeria ---------------------------------------------------------------------***--------------------------------------------------------------------- Abstract - Software development evolution has introduced and increasing the reusability of a software product, which a number of useful software development methods. Efficient in turns results in better software development. modularization of program artifacts that cut across multiple AOP is based on the idea that computer systems are better locations during software development called crosscutting programmed by separately specifying the various concerns concerns have been a major drawback for these software (properties or areas of interest) of a system and some development methods including the almighty Object-Oriented description of their relationships, and then relying on Software Development method. Concerns like recovery, mechanisms in the underlying AOP environment to weave or synchronization, logging, encryption, authentication, compose them together into a coherent program (Elrad, authorization, validation, verification,
    [Show full text]
  • Model-Based Aspect Weaver Construction
    Model-based Aspect Weaver Construction Suman Roychoudhury1, Frédéric Jouault2,1, and Jeff Gray1 1 University of Alabama at Birmingham, Birmingham, AL 35294 {roychous, gray}@cis.uab.edu 2 ATLAS group (INRIA & LINA), University of Nantes, France [email protected] Abstract. This paper describes an approach that combines model engineering with program transformation techniques to construct aspect weavers for general-purpose programming languages. The front-end of the weaver uses a high-level language (i.e., an aspect language) to specify aspects and is designed with a metamodel-based approach using the AMMA toolsuite. The back-end of the weaver uses transformation rules, which are generated from these high-level aspect specifications, to perform the actual low-level weaving. Both the aspect specification (front-end) and transformation rules (back-end) are captured as models within the AMMA platform. The translation from source aspect model to target transformation model is achieved using ATL, which is a model transformation language. Keywords: model transformation, program transformation, model engineering, aspect-oriented-programming, software engineering. 1 Introduction Program transformation systems have been used in the past to construct aspect weavers for programming languages [1]. Program transformation engines (PTEs) such as the Design Maintenance System (DMS) [2], or ASF+SDF [3], provide direct availability of scalable parsers and an underlying low-level transformation framework to modify source programs. This low-level transformation framework (that generally uses term-rewriting or graph-rewriting techniques to modify base code) can form the basis of constructing aspect weavers [4]. In our previous research, we demonstrated how a term-rewriting PTE like DMS can be used to construct an aspect weaver for a general-purpose programming language (GPL) like ObjectPascal [1].
    [Show full text]
  • Static and Dynamic Approaches to Weaving
    5th Slovakian-Hungarian Joint Symposium on Applied Machine Intelligence and Informatics January 25-26, 2007 ░ Poprad, Slovakia Static and Dynamic Approaches to Weaving Michal Forgáč, Ján Kollár Department of Computers and Informatics, Faculty of Electrical Engineering and Informatics, Technical University of Košice, Letná 9, 042 00 Košice, Slovakia [email protected], [email protected] Abstract: In this paper we present current state of principles and applications in static and dynamic weaving. We are concentrating on static weaving in AspectJ and dynamic weaving in PROSE - PROgrammable extenSions of sErvice. The contribution of this paper is in analyses of both approaches to weaving which we aim to apply as essential mechanisms when constructing software systems by automatic evolution. Keywords: Aspect oriented programming, systems engineering, weaving mechanisms, AspectJ, PROSE1 1 Introduction As a complexity of software systems grows, the need for advanced methods and tools of their specification and the development is the task of the high importance. Object oriented programming (OOP) has increased the productivity of systems rapidly. Benefits of object orientation include support for modular design, code sharing, and extensibility [15]. Object orientation has enabled using inheritance and polymorphism in sence of Strachey's original definition of polymorphism [16]. However, the key issue in application of object approach is that it is not sufficient for crosscutting concerns. One of the fundamental principles of the software engineering is a principle of separation of concerns. A concern is a particular goal, concept, or area of interest, it means that it is in substance semantical concern. From the structural point of view a concern may appear in source code as [4]: This work has been supported by the Scientific grant agency project (VEGA) No.
    [Show full text]
  • Efficient Runtime Aspect Weaving for Java Applications
    Efficient Runtime Aspect Weaving for Java Applications Oscar Rodriguez-Prietoa, Francisco Ortina,∗, Donna O'Sheab aUniversity of Oviedo, Computer Science Department, Calvo Sotelo s/n, 33007, Oviedo, Spain bCork Institute of Technology, Department of Computer Science, Rossa Avenue, Bishopstown, Cork, Ireland Abstract Context: The aspect-oriented paradigm is aimed at solving the code scattering and tangling problem, providing new mechanisms to support better separation of concerns. For specific scenarios where high runtime adaptability is an important requirement, dynamic Aspect-Oriented Programming (AOP) represents a useful tool. With dynamic AOP, components and aspects can be woven and unwoven at runtime, enabling appli- cations greater responsiveness when dealing with different or changing requirements. However, this responsiveness typically incurs a cost in terms of runtime performance and memory consumption. Objective: Build an efficient dynamic aspect weaver for Java that provides the best runtime performance compared to the existing approaches, minimum memory overhead consumption, and similar functionalities to the widespread runtime weavers. Method: We design and implement weaveJ, a dynamic aspect weaver for Java. This dynamic weaver leverages the invokedynamic opcode introduced in Java 7, which allows dynamic relinkage of method and field access. We compare the functionalities of weaveJ with the existing dynamic weavers for Java, and evaluate their runtime performance and memory consumption. Results: weaveJ shows the best runtime performance for all benchmarks and real applications executed. Method interception with invokedynamic is at least 142% faster than the techniques used by the existing runtime weavers. The average cost of dynamic weaving using invokedynamic is only 2.2% for short running programs, and 1.5% for long running applications.
    [Show full text]
  • Comprehensive Aspect Weaving for Java
    Science of Computer Programming 76 (2011) 1015–1036 Contents lists available at ScienceDirect Science of Computer Programming journal homepage: www.elsevier.com/locate/scico Comprehensive aspect weaving for Java Alex Villazón ∗, Walter Binder, Philippe Moret, Danilo Ansaloni Faculty of Informatics, University of Lugano, CH-6900 Lugano, Switzerland article info a b s t r a c t Article history: Aspect-oriented programming (AOP) has been successfully applied to application code Received 20 July 2009 thanks to techniques such as Java bytecode instrumentation. Unfortunately, with existing Received in revised form 19 October 2009 AOP frameworks for Java such as AspectJ, aspects cannot be woven into the standard Java Accepted 2 December 2009 class library. This restriction is particularly unfortunate for aspects that would benefit Available online 29 April 2010 from comprehensive aspect weaving with complete method coverage, such as profiling or debugging aspects. In this article we present MAJOR, a new tool for comprehensive aspect Keywords: weaving, which ensures that aspects are woven into all classes loaded in a Java Virtual Aspect-oriented programming Aspect weaving Machine, including those in the standard Java class library. MAJOR includes the pluggable Bytecode instrumentation module CARAJillo, which supports efficient access to a complete and customizable calling Profiling context representation. We validate our approach with three case studies. Firstly, we Debugging weave existing profiling aspects with MAJOR which otherwise would generate incomplete Detecting memory leaks profiles. Secondly, we introduce an aspect for memory leak detection that also benefits Recreating crashing conditions from comprehensive weaving. Thirdly, we present an aspect subsuming the functionality Java Virtual Machine of ReCrash, an existing tool based on low-level bytecode instrumentation techniques that generates unit tests to reproduce program failures.
    [Show full text]
  • Documentation: Using Aspectc++ for Qt Application Development
    Documentation: Using AspectC++ for Qt Application Development: Ute Spinczyk and Olaf Spinczyk Version 1.0, 28 April 2011 {us,os}@aspectc.org http://www.aspectc.org CONTENTS CONTENTS Contents 1 Introduction4 2 Installation5 3 Aspect Weaving6 4 Examples7 4.1 “Hello Qt World”............................7 4.2 “Connection Graph”..........................9 5 Further Information 11 6 Open Issues 11 3 1 INTRODUCTION 1 Introduction Qt1 is a state-of-the-art cross-platform application and UI framework. It provides C++ class libraries for user interfaces, graphics, networking, database access, and a lot more. Qt applications are typically written in C++ even though interfaces for other languages exist. AspectC++2 extends C++ by specific language constructs that enable Aspect- Oriented Programming. Figure 1: Implementation of crosscutting concerns without and with AOP Figure1 illustrates how a project can benefit from this paradigm: While most concerns of an implementation can be modularized using object-oriented pro- gramming alone, the so-called crosscutting concerns affect many parts. Typical examples are tracing and profiling code. This tangling of code, which implements different concerns, complicates the software maintenance, make re-use more dif- ficult, and contradicts with the principle of Separation of Concerns in general. Aspect Oriented Programming on the other hand allows designers to isolate the crosscutting concerns. In AspectC++ crosscutting concerns can be implemented as aspects. So called pointcuts define where the aspects will take effect, allowing the programmer to inject or replace code in any module. This manual explains how Qt and AspectC++ can be combined. The As- pectC++ tools are developed as an open source project and are available un- der the GPL.
    [Show full text]
  • Aspectj in Action, Second Edition Is a Fully Updated, Major Revision Spring Framework of Ramnivas Laddad’S Best-Selling Fi Rst Edition
    Enterprise AOP with Spring Applications IN ACTION SAMPLE CHAPTER Ramnivas Laddad FOREWORD BY ROD JOHNSON MANNING AspectJ in Action Second Edition by Ramnivas Laddad Chapter 1 Copyright 2010 Manning Publications brief contents PART 1 UNDERSTANDING AOP AND ASPECTJ .............................1 1 ■ Discovering AOP 3 2 ■ Introducing AspectJ 27 3 ■ Understanding the join point model 51 4 ■ Modifying behavior with dynamic crosscutting 87 5 ■ Modifying structure with static crosscutting 116 6 ■ Aspects: putting it all together 136 7 ■ Diving into the @AspectJ syntax 168 8 ■ AspectJ weaving models 199 9 ■ Integration with Spring 217 PART 2 APPLICATIONS OF ASPECTJ WITH SPRING ...................249 10 ■ Monitoring techniques 251 11 ■ Policy enforcement: keeping your design intact 288 12 ■ Learning design patterns 319 13 ■ Implementing concurrency control 344 14 ■ Managing transactions 373 vii viii BRIEF CONTENTS 15 ■ Securing applications 404 16 ■ Improving domain logic 431 17 ■ Taking the next step 459 appendix A ■ Setting up the example 469 appendix B ■ Using Ant with AspectJ 486 appendix C ■ Using Maven with AspectJ 491 brief contents Part 1 Understanding AOP and AspectJ Part 1 of this book introduces aspect-oriented programming (AOP), the AspectJ language, and how it integrates with Spring. We’ll discuss the need for a new programming methodology and the way this methodology is realized in AspectJ. Because AOP is a new methodology, we’ll devote the first chapter to introducing it: why it is needed, and what its core concepts are. Chapter 2 shows the overall flavor of the AspectJ language through examples. The next four chapters will delve deeper into the AspectJ syntax.
    [Show full text]
  • Aspectclang: Moving Aspectc++'S Weaver to the Clang C++ Front
    Bachelor’s Thesis AspectClang: Moving AspectC++’s Weaver to the Clang C++ Front End Benjamin Kramer September 6, 2013 Adviser: Prof. Dr.-Ing. Olaf Spinczyk Dipl.-Inf. Christoph Borchert Technische Universität Dortmund Fakultät für Informatik Lehrstuhl Informatik 12 Arbeitsgruppe Eingebettete Systemsoftware http://ess.cs.tu-dortmund.de Hiermit versichere ich, dass ich die vorliegende Arbeit selbstständig verfasst, keine an- deren als die angegebenen Quellen und Hilfsmittel verwendet sowie Zitate kenntlich gemacht habe. Dortmund, den 6. September 2013 Benjamin Kramer Abstract The source-to-source translator (weaver) that translates code using the aspect-oriented C++ language extension AspectC++ into standard C++ was built upon a C++ parsing framework called Puma. The framework is developed alongside the weaver; it is showing its age and the complexity of the C++ language drives up the upkeep of Puma. This thesis explores the replacement of Puma with the widely used Clang C++ front end. Clang is used in industry and academia and shares many design goals with Puma, making it a viable successor. A port of the weaver from Puma to Clang, using the code name AspectClang, is developed to show the feasibility of a Clang-based weaver and to evaluate its features in the context of AspectC++ weaving. The result is vastly improved conformance with the C++ language specification and the availability of C++11 support in the parser will benefit the AspectC++ community in the long term. Das Übersetzungsprogramm (Weaver), das aus AspectC++, einer aspektorientierten Spracherweiterung für C++, normalen C++-Quelltext erzeugt baut auf der Programm- bibliothek Puma auf. Die Bibliothek wird zusammen mit dem Weaver entwickelt und zeigt Alterungserscheinungen durch den hohen Aufwand um die Kompatibilität mit der komplexen C++-Sprache zu wahren.
    [Show full text]
  • An AOP Extension for C++
    Workshop Aspects AspectC++: Olaf Spinczyk Daniel Lohmann Matthias Urban an AOP Extension for C++ ore and more software developers are The aspect Tracing modularises the implementa- On the CD: getting in touch with aspect-oriented tion of output operations, which are used to trace programming (AOP). By providing the the control flow of the program. Whenever the exe- The evaluation version M means to modularise the implementation of cross- cution of a function starts, the following aspect prints of the AspectC++ Add- in for VisualStudio.NET cutting concerns, it stands for more reusability, its name: and the open source less coupling between modules, and better separa- AspectC++ Develop- tion of concerns in general. Today, solid tool sup- #include <cstdio> ment Tools (ACDT) port for AOP is available, for instance, by JBoss for Eclipse, as well as // Control flow tracing example example listings are (JBoss AOP), BEA (AspectWerkz), and IBM (As- aspect Tracing { available on the ac- pectJ) and the AJDT for Eclipse. However, all // print the function name before execution starts companying CD. these products are based on the Java language. advice execution ("% ...::%(...)") : before () { For C and C++ developers, none of the key players std::printf ("in %s\n", JoinPoint::signature ()); offer AOP support – yet. } This article introduces AspectC++, which is an as- }; pect-oriented language extension for C++. A compil- er for AspectC++, which transforms the source code Even without fully understanding all the syntactical into ordinary C++ code, has been developed as elements shown here, some big advantages of AOP an open source project. The AspectC++ project be- should already be clear from the example.
    [Show full text]