A Framework for Aspectual Requirements Validation: an Experimental Study

Requirements engineering is a discipline of software engineering that is concerned with the identification and handling of user and system requirements. Aspect-Oriented Requirements Engineering (AORE) extends the existing requirements engineering approaches to cope with the issue of tangling and scattering resulted from crosscutting concerns. Crosscutting concerns are considered as potential aspects and can lead to the phenomena “tyranny of the dominant decomposition”. Requirements-level aspects are responsible for producing scattered and tangled descriptions of requirements in the requirements document. Validation of requirements artefacts is an essential task in software development. This task ensures that requirements are correct and valid in terms of completeness and consistency, hence, reducing the development cost, maintenance and establish an approximately correct estimate of effort and completion time of the project. In this paper, we present a validation framework to validate the aspectual requirements and the crosscutting relationship of concerns that are resulted from the requirements engineering phase. The proposed framework comprises a high-level and low-level validation to implement on software requirements specification (SRS). The high-level validation validates the concerns with stakeholders, whereas the low-level validation validates the aspectual requirement by requirements engineers and analysts using a checklist. The approach has been evaluated using an experimental study on two AORE approaches. The approaches are viewpoint-based called AORE with ArCaDe and lexical analysis based on Theme/Doc approach. The results obtained from the study demonstrate that the proposed framework is an effective validation model for AORE artefacts.

Controlled Experiment in Crosscutting Concerns Identification from Software Requirements Specification

The concern is a group of requirements with the same purpose, which are known as crosscutting concerns when they are scattered and tangled in the system. Identifying and separating these concerns is a matter of huge importance to software maintainability and evolution. For this, some approaches are proposed. There are few experimental studies comparing and analyzing these approaches in detail. In this paper, our aim is to provide empirical evidence about two approaches in this context. We conducted a controlled experiment to compare the effectiveness of two approaches, which identify crosscutting concerns in the requirements specification, followed by an assessment of its perceived utility and ease of use. Our results indicate that, in this given context and planned scenario, there are significant differences between the effectiveness of ObasCId and Theme/Doc approaches.

Facets of Aspect Oriented Programming

AOP-Aspect Oriented Programming is a new programming paradigm for separating crosscutting concerns that are generally hard to do in object-oriented programming. As AOP has better ability to handle crosscutting concerns than Object-Oriented Programming (OOP,) it supports to write more modularized and more sustainable code. In addition, numerous publications discuss about the advantages of AOP design and implementation. However, for this new programming paradigm the work is in its early stages. The paper is all about the surveyed and reviewed several facets of AOP.

Runtime Reusable Weaving Model for Cloud Services Using Aspect-Oriented Programming

Cloud computing technology has opened an avenue to meet the critical need to securely share distributed resources and web services, and especially those that belong to clients who have sensitive data and applications. However, implementing crosscutting concerns for cloud-based applications is a challenge. This challenge stems from the nature of distributed Web-based technology architecture and infrastructure. One of the key concerns is security logic, which is scattered and tangled across all the cloud service layers. In addition, maintenance and modification of the security aspect is a difficult task. Therefore, cloud services need to be extended by enriching them with features to support adaptation so that these services can become better structured and less complex. Aspect-oriented programming is the right technical solution for this problem as it enables the required separation when implementing security features without the need to change the core code of the server or client in the cloud. Therefore, this article proposes a Runtime Reusable Weaving Model for weaving security-related crosscutting concerns through layers of cloud computing architecture. The proposed model does not require access to the source code of a cloud service and this can make it easier for the client to reuse the needed security-related crosscutting concerns. The proposed model is implemented using aspect orientation techniques to integrate cloud security solutions at the software-as-a-service layer.