Crosscutting score

6 - Improving Your Productivity

Software Testing is an evaluation mechanism that signifies the importance of software quality assurance, which will evaluate a particular system to check if it will satisfy all the requirements specified by the user. One cannot underestimate the importance of software testing. The wider perceptibility of software systems and the cost, which is related to the software failure are driving factors for efficient planning through testing. In this paper, we elaborate on the Unit testing and Data flow testing techniques applied on Object-oriented Programming and Aspect-oriented Programming. Moreover a tabular contrast of both the techniques is presented representing the differences between both the techniques.

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.

The modularity of aspect-oriented programming (AOP) has been a controversial issue. To investigate this issue compared with object-oriented programming (OOP), we propose a simple language providing AOP mechanisms, which are enhanced traditional OOP mechanisms. We also present its formal system and then show that programs in this language can be only mostly modularly ( i.e. separately) typechecked and compiled.We mention a source of this unmodularity and discuss whether or not it is appropriate to claim that AOP breaks modularity compared with OOP.

A code smell is any symptom in the source code that possibly indicates a bad design or programming problem. Many code smells in aspect-oriented programming (AOP) are very different from those in object-oriented programming. Therefore, new detection strategies should be conceived to identify whether a particular slice of aspect-oriented code is affected by a specific smell. Unfortunately, research on AOP usually focuses on providing abstract descriptions of code smells, without providing operational definitions of their detection strategies. Such strategies are becoming increasingly required due to the growing use of AOP in the development of long-living systems, including frameworks, libraries and software product lines. This paper presents a family of metric-based strategies that support the detection of recurring smells observed in existing aspect-oriented systems. We analyzed the accuracy of such smell detection strategies and also of those previously reported in the literature. Our study involved in total 17 releases of 3 evolving aspect-oriented systems from different domains. The outcome of our evaluation suggests that strategies for previously-documented AOP smells do not present a satisfactory accuracy. Our analysis also revealed that: (1) newly-discovered strategies achieved better results than well-known ones, and (2) the detection strategies seem to have high accuracy with respect to the identification of both trivial and non-trivial code smells.

A quantitative and qualitative assessment of aspectual feature modules for evolving software product lines

Feature-Oriented Programming (FOP) and Aspect-Oriented Programming (AOP) are programming techniques based on composition mechanisms, called refinements and aspects, respectively. These techniques are assumed to be good variability mechanisms for implementing Software Product Lines (SPLs). Aspectual Feature Modules (AFM) is an approach that combines advantages of feature modules and aspects to increase concern modularity. Some guidelines of how to integrate these techniques have been established in some studies, but these studies do not focus the analysis on how effectively AFM can preserve the modularity and stability facilitating SPL evolution. The main purpose of this paper is to investigate whether the simultaneous use aspects and features through the AFM approach facilitates the evolution of SPLs. The quantitative data were collected from a SPL developed using four different variability mechanisms: (1) feature modules, aspects and aspects refinements of AFM, (2) aspects of aspect-oriented programming (AOP), (3) feature modules of feature-oriented programming (FOP), and (4) conditional compilation (CC) with object-oriented programming. Metrics for change propagation and modularity stability were calculated and the results support the benefits of the AFM option in a context where the product line has been evolved with addition or modification of crosscutting concerns.KeywordsSoftware product linesfeature-oriented programmingaspectoriented programmingaspectual feature modulesvariability mechanisms

Nowadays, large numbers of organizations may prefer Aspect-Oriented Programming (AOP), which is an enhancement to Object-Oriented Programming (OOP). This is due to the concepts that have been added and helped in producing more flexible and reusable components. As a result, AOP has directed attention to software reuse, which is a significant topic for researchers and offers several advantages for organizations. Software reuse is based on reusability attributes which indicate the possibility of a component that was built to be reused in developing a new system. It is one of the most essential attributes to evaluate the quality of a system’s components. Many models have been built to estimate the reusability of the software but most of them are not dedicated to Aspect-Oriented Software (AOS). This study aims to establish a ground for AOS reusability estimation and measurement based on a new model and its associated equations depending on six attributes that impact AOS reusability negatively and/or positively. Four attributes of them have been included in previous studies which are coupling, cohesion, design size, and messaging. Two new attributes have been proposed in this study, which are complexity, and generality. Both of these attributes have been measured based on the metrics that have also been proposed in this study. A new equation to calculate AOS reusability has been proposed in this research work. Seven Aspect projects have been employed as a case study to apply the proposed equation.

You can measure a software system's value by its modularity. The more modular the system, the easier it is to produce and extend. Aspect-oriented programming technologies aim to improve system modularity by modularizing crosscutting concerns. Global properties and programming and design issues can lead to crosscutting concerns--for example, error handling or transaction code, interacting features, and reliability and security. The guest editors introduce aspect-oriented programming and describe this special issue's articles, which explain the use of aspect-oriented programming to simplify enterprise and system software, the need to expand an interface's meaning in the presence of aspects, and the application of aspects to design and requirements activities.

Although software developers look to the security concept as a non-functional side of application systems deny that this side represents one of the main pillars used to support the functional side of the applications, thus, increasing the recommendations of the application systems after achievement of user satisfaction. Unauthorized access to information represents one of the most important challenges faced by application systems developers. The privacy-preserving and security concepts have arisen from the usage of data resources, which sometimes leads to the sharing of personal identifying information (PII). Access control is one widely accepted security solution, by restricting the accessing of the data only to authorized users. Adding or updating access control concerns in system applications represents a difficult task for system developers because they need to track all program codes to detect where restriction methods should be inserted. At the same time, they have to define which piece of code needs to be applied for different access control policies. All of these concerns are accumulated in the problem of scattering and tangling of system software. A widely suggested but under-used solution to these problems is that of Aspect Oriented Programming (AOP). AOP is an effective technique for modularizing concerns and changing the execution behavior of existing codes with only the minimal need to change existing software implementations. In this paper we present a literature review in access control methods which used AOP to apply security concepts into application systems. Through our narration of the methods, we show the advantage of using AOP to modularize the access control policies and security concerns, and therefore increase the clarity, maintainability and reusability of system software.

Aspect-oriented programming is considered a promising new technology. As object-oriented programming did before, it is beginning to pervade all areas of software engineering. With its growing popularity, practitioners and academics alike are wondering whether they should start looking into it, or otherwise risk having missed an important development. The author of this essay finds that much of aspect-oriented programming's success seems to be based on the conception that it improves both modularity and the structure of code, while in fact, it works against the primary purposes of the two, namely independent development and understandability of programs. Not seeing any way of fixing this situation, he thinks the success of aspect-oriented programming to be paradoxical.

Many programs have crosscutting concerns for which neither procedural nor object-oriented programming adequately modularize, which has led to the idea of aspect-oriented programming (AOP). However, AOP has not found favor with the programming languages community due to a belief that AOP breaks classical modularity and modular reasoning. We propose a new AOP programming model that enables both crosscutting modularity and modular reasoning. This model is implemented by AspectJML, a general-purpose aspect-oriented extension to Java. It supports modular crosscutting concerns using key object-oriented mechanisms, such as hierarchical structure, and allows reasoning that scales to ever-larger programs.

Automation software systems usually implement the IEC 61131-3 and IEC 61499 standards. Nowadays, these applications request, among others, reusability, flexibility, reliability, and modularity via both standards. These characteristics can be achieved by a traditional paradigm called Object-Oriented Programming (OOP). OOP is an older method that applied with various programming languages to generate a replicable style of programming, i.e., code composed by Functions, Methods, etc. A well-defined programming method makes the code understandable for programmers. OOP defines the reusability, accessibility, adaptability, and robustness of software programs. It means that using gradual methods gained experience improves the quality of programs and simplifies their organization. OOP also increases the security of applications from its core features, i.e., Abstraction, Instantiation, Encapsulation, Polymorphism, and others. Therefore, OOP has been applied and discussed for both standards; however, OOP’s complexity and implementation using these IEC standards have not been compared yet. This work proposes the typical application of the Function Block (FB) to define classes and objects for industrial automation systems based on OOP. We implement one particular case of study for both standards. The FB employments are evaluated in order to compare OOP applicability and advantages of each standard. Adapting automation software regarding new industry requirements implies greater modularity. Code programmed by OOP generates abstractions levels which improve the design and make the software application in maintenance more comfortable to read and more adaptable to future extensions. This research shows how both standards (their latest updates) address OOP. Object-oriented programs in the field of automation engineering face another paradigm shift that impacts the methods used to program control systems. OOP would facilitate the design patterns implementations, which are a reusable understanding of common problems.

A new approach for programming that enables switching among contexts of commands during program execution is context-oriented programming (COP). This technique is more structured and modular than object-oriented and aspect-oriented programming and hence more flexible. For context-oriented programming, as implemented in COP languages such as ContextJ*and ContextL, this paper introduces accurate operational semantics. The language model of this paper uses Java concepts and is equipped with layer techniques for activation/deactivation of layer contexts. This paper also presents a logical system for COP programs. This logic is necessary for the automation of testing, developing, and validating of partial correctness specifications for COP programs and is an extension of separation logic. A mathematical soundness proof for the logical system against the proposed operational semantics is presented in the paper.

In an aspect-oriented program, the cross-cutting functionalities are defined in pieces of advice such that they apply to program-execution points for the core functionalities. Program changes can affect the application of pieces of advice. To that end, a source-code differencing tool, for two versions of an aspect-oriented program, needs to support the identification of changes in pieces of advice at locations of their applications. To alleviate this task, we introduce an extension of the existing differencing technique for object-oriented programs. We implemented a tool AjDiff and used it to evaluate our technique on the two examples of aspect-oriented programs: Tracing and Telecom. We manually verified that our tool can successfully identify changes in pieces of advice at locations of their application.