Design and Implementation of an Aspect-Oriented C Programming Language

For systems which deal with serious or dangerous things (for example nuclear power plant), programs are constrained by legislation to be safe in any case, which requires verification process during the execution, in other words “Runtime Verification” (RV). The field of runtime verification has many different names: runtime monitoring, runtime checking, runtime result checking, runtime reflection, monitoring oriented programming, design by contract, runtime analysis, dynamic analysis, trace analysis, fault protection, etc. Aspect-oriented programming (AOP) is a useful paradigm for monitoring programs, even if it was not created for this purpose. Indeed, AOP tries to deal with crosscutting concerns (tangled and scattered codes) by “capturing” them within a new entity called aspect, and runtime verification properties are conceptually transversal to the code they verify, unavoidably resulting in such crosscutting codes. AOP is always used as an extension of an existing language. Hence it is necessary to design an aspect language extending the target language, and to use what is called a weaver, to realize a binding operation between the target program and the aspects. Thus, one can find many aspect-programming extensions (including an aspect language and an aspect weaver) for most programming languages. The first one to be developed was AspectJ, designed for Java, and which has been the best-known reference among aspect-oriented tools until now. We use an AspectJ-like tool, straight inspired from AspectJ but designed for C, called ACC, which is itself an improved version of AspectC. The purpose of this paper is to explore the possibility of implementing and monitoring generic (also called parameterized) verification properties, i.e. which could be used on any target code, with ACC through a basic example. As ACC, contrary to AspectJ, does not provide abstraction for aspects, which would have made generic monitoring an easy task, we tried to simulate abstraction by making use of macros in the aspect code, which boils down to monitor every parameterized property within one macro function. We will see that despite losses of expressiveness without complexification of the monitoring code, the method still allows monitoring generically any property which is already monitorable directly in ACC.

The rapidly growing mobile market has stimulated the demand for more and more complex custom applications for embedded mobile devices, for example, smart phones. To manage this complexity and, at the same time, to keep the time to market small, advanced software engineering methods have to be applied. Aspect-oriented programming (AOP) provides advanced modularization and abstraction mechanisms. The main advantages of this concept are improved maintainability, reusability, and extensibility of applications. Furthermore, dynamic AOP can be used to implement the dynamic adaptation of mobile device applications to changing contexts, like the location. However, the overhead introduced by the additional abstraction mechanisms limits the applicability to embedded mobile devices because they have limited resources (CPU, memory) compared to desktop PCs. To overcome this problem, we present a set of optimizations that significantly reduce the overhead of common AOP mechanisms and, finally, make AOP applicable for embedded mobile devices. The foundation of our work is a thorough analysis of the overhead that is typically generated by the realization of AOP mechanisms. The key idea of our approach is a deep integration of AOP mechanisms into the virtual machine. To this end, we shift mechanisms like the registration of activated aspects to the level of the JVM. Furthermore, we optimize the execution of AOP programs by introducing caching mechanisms and specialized bytecode instructions that are tailored for the execution of AOP mechanisms. Moreover, we analyze AOP-specific semantic code properties in order to develop optimizations that utilize these AOP-specific semantic information and that exploit typical AOP usage schemes. In addition to the AOP optimizations, we realize an efficient dynamic aspect deployment mechanism. We apply our optimizations to the Java-based aspect-oriented programming language ObjectTeams [HHM07] by extending the extremely small and portable JamVM [Lou] Java virtual machine. To evaluate our approach, we execute micro benchmarks, investigate the effect of our optimizations on a real-world application, and finally discuss the transferability of our optimizations to other approaches. Our evaluation shows a considerable performance gain for the aspect activation and the aspect execution of ObjectTeams. In particular, we demonstrate that our optimizations improve the performance of commonly used AOP mechanisms by up to 90%. At the same time, we reduce the code size of the adapted classes, which is also important for small devices. Finally, with our case study, namely the OTPong game application, we show that our approach is capable of significantly optimizing the execution time of real-word applications. Our main contribution is a significant reduction of the overhead of high-level AOP constructs, which is also demonstrated by the results of our experiments. The success of the optimizations provides evidence that advanced high-level abstraction techniques like AOP can be efficiently used in embedded mobile devices. Furthermore, our work shows that efficient dynamic aspect deployment can be supported on the level of the JVM. This substantially enhances the dynamic capabilities of ObjectTeams.

Aspect-oriented programming is a promising approach to address separation of concerns. Aspect-oriented programming languages address the problems of scattering and entanglement by providing an abstraction for specifying cross-cutting concerns in a modular manner. The relevant aspects are then composed to derive the desired implementation. However, current aspect-oriented programming languages only allow this composition to be specified in terms of programming language constructs. This is restrictive and can only be used for simple compositions. Many situations in practice need a richer composition context that cannot be expressed using programming language constructs. Models, being at a higher level of abstraction and closer to the problem domain, can be used to capture this information. We propose an approach to extend aspect-oriented programming with a composition mechanism that can make use of the information captured in models. We also outline an implementation of the proposed approach. The proposed approach has been used to seamlessly integrate model-centric and code-centric development.

Aspect oriented programming (AOP) has been proposed as a new programming paradigm. The originality in AOP is the aspect, a single modularization unit for all those functionalities that were originally spread across several modules and tangled with each other (called crosscutting concerns). Using an aspect, a crosscutting concern can be factored out into a single, separate unit. This paper summarizes a PhD thesis that presents an approach to automatize the migration of existing object oriented systems towards AOP. Different techniques are proposed to cope with the migration and assessed on a large software basis.

Complex distributed systems pose great challenges for quality assurance. Size, complexity and concurrency of these systems often render traditional verification techniques impractical. In particular, this is true for systems integration efforts, where additional challenges arise from the independent evolution of the composed systems. Runtime verification provides a systematic strategy for analytical quality assurance of such systems. Key elements of runtime verification are system models, ways to inject these models into the observed system and a framework for analysing and monitoring the runtime behaviour against the models. The approach we present in this article is based on interaction models. We specify expected system interactions using Message Sequence Charts (MSC), from which we generate distributed runtime monitors for each of the components. We use aspect-oriented programming (AOP) techniques to inject the monitors into the implementation of the components. Thereby, we verify the adherence of the distributed system interactions with the MSC model. The focus of this article is the runtime verification in the systems integration domain; here, Enterprise Service Buses (ESB) have emerged as a powerful infrastructure for integrating complex distributed systems. In the context of an ESB we leverage the Spring AOP framework to inject the runtime monitors. As a result we obtain a comprehensive, tool-supported approach for model-based runtime verification of interactions. We demonstrate our approach using the Central Locking System as running example of an integrated embedded system.

AspectJ is a well-established programming language for the implementation of aspect-oriented programs. It supports the aspect-oriented programming paradigm by providing a special unit, called aspect, which encapsulates crosscutting code. While with AspectJ a suitable aspect-oriented programming language is at hand, no feasible modeling language is available that supports the design of AspectJ programs. In this work, such a design notation for AspectJ programs is presented based on the UML. It provides representations for all language constructs in AspectJ and specifies an UML implementation of AspectJ's weaving mechanism. The design notation eases the perception of aspect-orientation and AspectJ programs. It carries over the advantages of aspect-orientation to the design level.

Nowadays, software development has become more complex and dynamic; they are expected more flexible, scalable and reusable. Under the umbrella of aspect, Aspect-Oriented Software Development (AOSD) is relatively a modern programming paradigm to improve modularity in software development. Using Aspect-Oriented Programming (AOP) language to implements crosscutting concerns through the introduction of a new construct Aspect like Class is defined as a modular unit of crosscutting behavior that affect multiple classes into reusable modules. Several quality models to measure the quality of software are available in literature. However, keep on developing software, and acceptance of new environment (i.e. AOP) under conditions that give rise to an issue of evolvability. After the evolution of system, we have to find out how the new system needs to be extensible? What is the configurable status? Is designed pattern stable for new environment and technology? How the new system is sustainable? The objective of this paper is to propose a new quality model for AOSD to integrating some new quality attributes in AOSQUAMO Model based which is based on ISO/IEC 9126 Quality Model, is called Aspect- Oriented Quality (AOSQ) Model. Analytic Hierarchy Process (AHP) is used to evaluate an improved hierarchical quality model for AOSD.

Aspect-oriented programming (AOP) is a programming paradigm such that crosscutting concerns including synchronization policies, resource sharing and performance optimizations over objects are modularized as aspects that are separated from objects. A compiler, called a weaver, weaves aspects and objects together into a program. In AOP, however, it is not easy to verify the correctness of a woven program because crucial behaviors are strongly influenced by aspect descriptions. In order to deal with such problem, this paper proposes an automatic verification approach using model checking that verifies whether the woven program contains unexpected behaviors such as deadlocks. The objectives of this paper are as follows: 1) to verify the correctness of AOP-based programs using model checking, 2) to provide AOP-based model checking frameworks.

Separation of Concerns (SoC) is an important issue to reduce the complexity of software. Recent advances in programming language research show that Aspect-Oriented Programming (AOP) may be helpful for enhancing the SoC in software systems: AOP provides a means for describing concerns which are normally spread throughout the whole program at one location. The arguments for introducing aspects into programming languages also hold for modeling languages. In particular, modeling state-crosscutting behavior is insufficiently supported by UML state machines. This often leads to model elements addressing the same concern scattered all over the state machine. We present an approach to aspect-oriented state machines, which show considerably better modularity in modeling state-crosscutting behavior than standard UML state machines.

In central fields of software engineering, there are two competing directions of research.Component frameworks and advanced programming languages both seek to improve fundamental software quality properties, most notably: modularity.While both directions have produced specific benefits, harvesting these benefits still requires a trade-off in selecting one of the two technologies.In this paper, we present the integration of the aspect-oriented programming language ObjectTeams/Java into the OSGi component framework.By combining these technologies, the design space for modular architectures of components and applications is enriched with fundamentally new options.As a result, the best of both worlds is available for re-using software modules at realistic scales and for evolving systems over significant periods of time.

The rapid growth of the Internet of Things (IoT) and its applications requires high computational efficiency, low-cost, and low-power solutions for various IoT devices. These include a wide range of microcontrollers that are used to collect, process, and transmit IoT data. ESP32 is a microcontroller with built-in wireless connectivity, suitable for various IoT applications. The ESP32 chip is gaining more popularity, both in academia and in the developer community, supported by a number of software libraries and programming languages. While low- and middle-level languages, such as C/C++ and Rust, are believed to be the most efficient, TinyGo and MicroPython are more developer-friendly low-complexity languages, suitable for beginners and allowing more rapid coding. This paper evaluates the efficiency of the available ESP32 programming languages, namely C/C++, MicroPython, Rust, and TinyGo, by comparing their execution performance. Several popular data and signal processing algorithms were implemented in these languages, and their execution times were compared: Fast Fourier Transform (FFT), Cyclic Redundancy Check (CRC), Secure Hash Algorithm (SHA), Infinite Impulse Response (IIR), and Finite Impulse Response (FIR) filters. The results show that the C/C++ implementations were fastest in most cases, closely followed by TinyGo and Rust, while MicroPython programs were many times slower than implementations in other programming languages. Therefore, the C/C++, TinyGo, and Rust languages are more suitable when execution and response time are the key factors, while Python can be used for less strict system requirements, enabling a faster and less complicated development process.

In Aspect-Oriented Programming (AOP), a crosscutting concern is extracted from a base program and is modularized into a new construct called aspect. The aspect is weaved back to the program to incorporate the crosscutting behaviors. Many semantic problems, referred to as Aspect Weaving Problems (AWPs) in this paper, could be introduced in the aspect weaving process. The AWPs have been independently defined using different modeling approaches for their detections. In practice, it is difficult for AOP developers to detect these problems, because they have to switch between different tools/methods. This is a time consuming and error-prone process. Consequently, it could increase the production costs of Aspect-Oriented development. This paper proposes a taxonomy of the AWPs to clearly define and classify the problems. Based on the taxonomy and a unified modeling approach to detect the AWPs, a conceptual analysis framework for the AWPs is also proposed. The framework aims at the integration of the unified AWPs detection capabilities into legacy aspect weavers by reusing (adapting) the modeling approach for various AOP languages.

Developing a machine model natively supporting aspect-oriented programming (AOP) is fruitful not only for implementing interpreters and compilers for AOP languages but also for understanding the essence of the AOP paradigm. This position paper shows a machine model based on open classes and predicate dispatch and it briefly describes a list of predicates that are necessary for modeling AspectJ. This machine model is useful for comparing AOP and object-oriented programming (OOP) on a side-by-side basis. Our initial observation is that AOP is a natural extension to OOP with respect to language constructs.

There is nowadays a wide recognition that low coupling is a main tenet in the measurement of high-quality modular software. In fact, coupling is one of the few internal software attributes that has been both theoretically and empirically shown to have a large impact on a variety of external software qualities, such as reusability, maintainability, evolvability and testability. Aspect-oriented programming (AOP) is an emerging technique that advocates enhanced modularization of certain widely-scoped system properties, the so-called crosscutting concerns. However, there is a poor common understanding of coupling in the context of AOP. Most of the existing metrics and assessment frameworks concentrate on the coupling evaluation of the AspectJ programming language. In addition, they took their own particular view of what coupling means in this particular language. This paper presents the definition of a generic coupling framework that takes into account both AspectJ and CaesarJ, two representatives of the most well-known families of available AOP languages. The current version of the proposed framework allows for the definition of different coupling metrics, which in turn permits the analysis and comparison of Java, AspectJ and CaesarJ implementations. We also illustrate how the framework can be applied to the characterization of existing coupling metrics.

Programming techniques have been passed through many development stages in their progressing path to cope with the increasing complexity of systems requirements. So, one of the main goals of the programming languages designers is how to develop programming language that can handle and manage the spread and overlapping of different functionality concerns. Because unmanageable and uncontrollable scattering of concerns inside the system may cause many problems during system running in present or/and during applying maintenance and developing the system in future. One of the most recent and powerful solutions to overcome these problems is via using Aspect-Oriented Programming (AOP) approach. This research is demonstrates the features and the problems with implying AOP techniques in the software development process.