Experiences In Migrating An Industrial Application To Aspects

Aspect-Oriented Software Development (AOSD) is a paradigm aiming to solve problems of object-oriented programming (OOP). With normal OOP it’s often unlikely to accomplish fine system modularity due to crosscutting concerns being scattered and tangled throughout the system. AOSD resolves this problem by its capability to crosscut the regular code and as a consequence transfer the crosscutting concerns to a single model called aspect. This thesis describes an experiment on industrial application wherein the effectiveness of aspect-oriented techniques is explained in migration the OOP application into aspects. The experiment goals at first to identify the crosscutting concerns in source code of the industrial application and transform these concerns to a functionally equivalent aspect-oriented version. In addition to presenting experiences gained through the experiment, the thesis aims to provide practical guidance of aspect solutions in a real application

Aspect oriented programming: Concepts, characteristics and implementation

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

Towards a Taxonomy of Aspect-Oriented Programming.

As programs continue to increase in size, it has become increasingly difficult to separate concerns into well localized modules, which leads to code tangling- crosscutting code spread throughout several modules. Thus, Aspect-Oriented Programming (AOP) offers a solution to creating modules with little or no crosscutting concerns. AOP presents the notion of aspects, and demonstrates how crosscutting concerns can be taken out of modules and placed into a centralized location. In this paper, a taxonomy of aspect-oriented programming, as well as a basic overview and introduction of AOP, will be presented in order to assist future researchers in getting started on additional research on the topic. To form the taxonomy, over four-hundred research articles were organized into fifteen different primary categories coupled with sub-categories, which shows where some of the past research has been focused. In addition, trends of the research were evaluated and paths for future exploration are suggested

EFFICIENT RUNTIME SECURITY SYSTEM FOR DECENTRALISED DISTRIBUTED SYSTEMS

Distributed systems can be defined as systems that are scattered over geographical distances and provide different activities through communication, processing, data transfer and so on. Thus, increasing the cooperation, efficiency, and reliability to deal with users and data resources jointly. For this reason, distributed systems have been shown to be a promising infrastructure for most applications in the digital world. Despite their advantages, keeping these systems secure, is a complex task because of the unconventional nature of distributed systems which can produce many security problems like phishing, denial of services or eavesdropping. Therefore, adopting security and privacy policies in distributed systems will increase the trustworthiness between the users and these systems. However, adding or updating security is considered one of the most challenging concerns and this relies on various security vulnerabilities which existing in distributed systems. The most significant one is inserting or modifying a new security concern or even removing it according to the security status which may appear at runtime. Moreover, these problems will be exacerbated when the system adopts the multi-hop concept as a way to deal with transmitting and processing information. This can pose many significant security challenges especially if dealing with decentralized distributed systems and the security must be furnished as end-to-end. Unfortunately, existing solutions are insufficient to deal with these problems like CORBA which is considered a one-to-one relationship only, or DSAW which deals with end-to-end security but without taking into account the possibility of changing information sensitivity during runtime. This thesis provides a proposed mechanism for enforcing security policies and dealing with distributed systems’ security weakness in term of the software perspective. The proposed solution utilised Aspect-Oriented Programming (AOP), to address security concerns during compilation and running time. The proposed solution is based on a decentralized distributed system that adopts the multi-hop concept to deal with different requested tasks. The proposed system focused on how to achieve high accuracy, data integrity and high efficiency of the distributed system in real time. This is done through modularising the most efficient security solutions, Access Control and Cryptography, by using Aspect-Oriented Programming language. The experiments’ results show the proposed solution overcomes the shortage of the existing solutions by fully integrating with the decentralized distributed system to achieve dynamic, high cooperation, high performance and end-to-end holistic security

Agent-based methodology for developing agroecosystems simulations

The agent-based modeling (ABM) approach allows modeling complex systems, involving different kinds of interacting autonomous agents with heterogeneous behavior. Agro-ecosystems (ecological systems subject to human interaction) are a kind of complex system whose analysis and simulation is of interest to several disciplines (e.g. agronomy, ecology or sociology). In this context, the ABM approach appears as a suitable tool for modeling agro-ecosystems, along with a corresponding agent-oriented software engineering (AOSE) methodology for the construction of the simulation. Nevertheless, existing AOSE methodologies are general-purpose, they have not yet accomplished widespread use, and clear examples of applications to agro-ecosystems are hard to find. This thesis sets the ground for a new software development methodology for developing agro-ecosystem simulations based on the ABM approach as well as on these already existing AOSE methodologies, but tailored to tackle specific agro-ecosystem features.El enfoque de modelado basado en agentes (ABM) permite el modelado de sistemas complejos en los que interactúan diferentes tipos de agentes autónomos con comportamientos heterogéneos. Los agro-ecosistemas (sistemas ecológicos sujetos a la presencia humana) son un tipo de sistema complejo cuyo análisis y simulación resulta de interés para diversas disciplinas (ej.: agronomía, ecología o sociología). En este contexto, el enfoque ABM aparece como una herramienta adecuada para el modelado de agro-ecosistemas, junto con una correspondiente metodología de desarrollo de software también orientada a agentes (AOSE) para la construcción de dicha simulación. Si bien ya existen metodologías AOSE, éstas son de propósito general, no han logrado un amplio uso y ejemplos claros de aplicaciones a agro-ecosistemas son difíciles de encontrar. Esta tesis establece los fundamentos para crear una nueva metodología de desarrollo de software basada en el enfoque de agentes para el desarrollo de simulaciones de agro-ecosistemas, basándose en las metodologías AOSE ya existentes, pero personalizada para soportar las características específicas de los agro-ecosistemas

Improving Reuse of Distributed Transaction Software with Transaction-Aware Aspects

Implementing crosscutting concerns for transactions is difficult, even using Aspect-Oriented Programming Languages (AOPLs) such as AspectJ. Many of these challenges arise because the context of a transaction-related crosscutting concern consists of loosely-coupled abstractions like dynamically-generated identifiers, timestamps, and tentative value sets of distributed resources. Current AOPLs do not provide joinpoints and pointcuts for weaving advice into high-level abstractions or contexts, like transaction contexts. Other challenges stem from the essential complexity in the nature of the data, operations on the data, or the volume of data, and accidental complexity comes from the way that the problem is being solved, even using common transaction frameworks. This dissertation describes an extension to AspectJ, called TransJ, with which developers can implement transaction-related crosscutting concerns in cohesive and loosely-coupled aspects. It also presents a preliminary experiment that provides evidence of improvement in reusability without sacrificing the performance of applications requiring essential transactions. This empirical study is conducted using the extended-quality model for transactional application to define measurements on the transaction software systems. This quality model defines three goals: the first relates to code quality (in terms of its reusability); the second to software performance; and the third concerns software development efficiency. Results from this study show that TransJ can improve the reusability while maintaining performance of TransJ applications requiring transaction for all eight areas addressed by the hypotheses: better encapsulation and separation of concern; loose Coupling, higher-cohesion and less tangling; improving obliviousness; preserving the software efficiency; improving extensibility; and hasten the development process

Context-Oriented Algorithmic Design

Currently, algorithmic approaches are being introduced in several areas of expertise, namely Architecture. Algorithmic Design (AD) is an approach for architecture that takes advantage of algorithms to produce complex designs, to simplify the exploration of variations, or to mechanize tasks, including those related to analysis and optimization of designs. However, architects might need different models of the same design for different kinds of analysis, which tempts them to extend the same code base for different purposes, typically making the code brittle and hard to understand. In this paper, we propose to extend AD with Context-Oriented Programming (COP), a programming paradigm based on context that dynamically changes the behavior of the code. To this end, we propose a COP library and we explore its combination with an AD tool. Finally, we implement two case studies with our context-oriented approach, and discuss their advantages and disadvantages when compared to the traditional AD approach

Towards Multi-Paradigm Software Development

Multi-paradigm software development is a possible answer to attempts of finding the best paradigm. It was present in software development at the level of intuition and practiced as the “implementation detail” without a real support in design. Recently it is making a twofold breakthrough: several recent programming paradigms are encouraging it, while explicit multi-paradigm approaches aim at its full-scale support. In order to demonstrate this, a survey of selected recent software development (programming) paradigms (aspect-oriented approaches and generative programming) and multiparadigm approaches (multi-paradigm programming in Leda, multi-paradigm design in C++, and intentional programming) is presented. The survey is preceded and underpinned by the analysis of the concept of paradigm in computer science in the context of software development, since there is no common agreement about the meaning of this term, despite its wide use. The analysis has showed that there are two meanings of paradigm: large-scale and small-scale

Levering object-oriented knowledge for service-oriented proficiency

As more and more enterprise systems endeavour to interconnect seamlessly by using a service-oriented architecture (SOA) a number of challenges are beginning to surface as a result of the differences in understanding between object-orientated programming (OOP) and service-orientation in technical development teams. These differences are thus explored to determine the potential of subsidising gaps in knowledge through relational learning in order to better prepare development environments for service migration. It emerges that the principles of service-oriented programming can be used within OOP by selectively identifying the existing knowledge found within object-orientation and traditional programming methodologies. The benefit of this approach proposes to lever the expertise of object-oriented developers so as to build service-ready computer software and encourage the seamlessness of SOA

Locating Potential Aspect Interference Using Clustering Analysis

Software design continues to evolve from the structured programming paradigm of the 1970s and 1980s and the object-oriented programming (OOP) paradigm of the 1980s and 1990s. The functional decomposition design methodology used in these paradigms reduced the prominence of non-functional requirements, which resulted in scattered and tangled code to address non-functional elements. Aspect-oriented programming (AOP) allowed the removal of crosscutting concerns scattered throughout class code into single modules known as aspects. Aspectization resulted in increased modularity in class code, but introduced new types of problems that did not exist in OOP. One such problem was aspect interference, in which aspects meddled with the data flow or control flow of a program. Research has developed various solutions for detecting and addressing aspect interference using formal design and specification methods, and by programming techniques that specify aspect precedence. Such explicit specifications required practitioners to have a complete understanding of possible aspect interference in an AOP system under development. However, as system size increased, understanding of possible aspect interference could decrease. Therefore, practitioners needed a way to increase their understanding of possible aspect interference within a program. This study used clustering analysis to locate potential aspect interference within an aspect-oriented program under development, using k-means partitional clustering. Vector space models, using two newly defined metrics, interference potential (IP) and interference causality potential (ICP), and an existing metric, coupling on advice execution (CAE), provided input to the clustering algorithms. Resulting clusters were analyzed via an internal strategy using the R-Squared, Dunn, Davies-Bouldin, and SD indexes. The process was evaluated on both a smaller scale AOP system (AspectTetris), and a larger scale AOP system (AJHotDraw). By seeding potential interference problems into these programs and comparing results using visualizations, this study found that clustering analysis provided a viable way for detecting interference problems in aspect-oriented software. The ICP model was best at detecting interference problems, while the IP model produced results that were more sporadic. The CAE clustering models were not effective in pinpointing potential aspect interference problems. This was the first known study to use clustering analysis techniques specifically for locating aspect interference