Aspect Oriented Software Development

Table of contents

The implementation of software applications using GOAD techniques results in a better implementation structure which has an impact on many important software qualities such as enhanced risibility and reduced complexity. In turn, these software qualities lead to an improved software development lifestyle and, hence, to better software. This report introduces to management and software development staff to the concepts of aspect- orientation software development.

It presents why aspect-orientation is needed in modern software development and what its contributions are to the improvement of software design and implementation structure. The report also highlight technology details though without probing much in particular, as it present the various concepts of GOAD. After reading this introduction, the reader will understand what GOAD is about, know its key concepts and terminology engaged to elaborate .


As software systems becomes more complex developers use new technologies to help manage development. The development of large and complex software applications is a challenging task. Apart from the enormous complexity of the software’s desired functionality, software engineers are also faced with many other acquirement that are specific to the software development lifestyle. Requirements such as risibility, robustness, performance, believability, etc. Re requirements about the design and the implementation of the software itself, rather than about its functionality. Nevertheless, these non-functional requirements cannot be neglected because they contribute to the overall software quality, which is eventually perceived by the users of the software application. For example, a better believability will ensure that future maintenance tasks to the implementation can be carried out relatively easily and consequently also with fewer errors.

Building software applications that adhere to all these functional and non-functional requirements is an ever more complex activity that requires appropriate programming languages and development paradigms to adequately address all these requirements throughout the entire software development lifestyle. To cope with this ever-growing complexity of software development, computer science has experienced a continuous evolution of development paradigms and programming languages. In the early days, software was directly implemented in machine-level assembly languages, leading to highly omelet implementations for even simple software applications.

The introduction of the procedural and functional programming paradigms provided software engineers with abstraction mechanisms to improve the design and implementation structure of the software and reduce its overall complexity. An essential element of these paradigms is the ability to structure the software in separate but cooperating modules (e. G. Procedures, functions, etc. ). The intention is that each of these modules represents or implements a well-identified subpart of the software, which renders the individual modules better reusable and evolvable.

Modern software development often takes place in the object-oriented programming paradigm that allows to further enhance the software’s design and implementation structure through appropriate object-oriented modeling techniques and language features such as inheritance, delegation, encapsulation and polymorphism. Aspect-oriented programming languages and the entire aspect-orientation paradigm are a next step in this ever continuing evolution of programming languages and development paradigms to enhance software development and hence, improve overall software quality.

Fundamental ideas underlying aspects and aspect-oriented software development The notion behind aspects is to deal with the issue of tangling and scattering. According to Ian Somerville (2009), tangling occurs when a module in a system includes code that implements different system requirements and scattering occurs when implementation of a single concern (logical requirement or set of requirements) is scattered across several components in a program.

What an Aspect Is

Aspect is an abstraction which implements a concern. Aspects are completely specification of where it should be executed. Unlike other abstractions like methods, you cannot tell by examining methods where it will be called from because there is clear separation between the definition and of the abstraction and its use. With Aspects, includes a statement that defines where the aspect will be woven into the program. This statement is known as a pinpoint. Below is an example of a pinpoint before: call public void update. This implies that before the execution of many method whose starts with update, followed by any other sequence of characters, the code in the aspect after the induct definition should be executed.

The wildcat matches any string characters that are allowed in the identifiers. The code to be executed is known as the advice and is implementation of the cross-cutting concern. In an example below of an aspect authentication (let’s say for every change of attributes in a payroll system requires authentication), the advice gets a password from person requesting the change and checks that it matches the password of currently logged -in user. If not user is logged out and update does not proceed.

Pinpoint: defines specific program events with which advice should be associated (I. E. , woven into a program at appropriate Join points) Events may be method calls/ returns, accessing data, exceptions, etc. Weaving: incorporation of advice code into the program (via source code preprocessing, link-time weaving, or execution time weaving). Why Separation of Concerns a good guiding principle for Software Development Separation of concerns is a key principle of software design and implementation. Concerns reflect the system requirements and the priorities of the system stakeholders.

Some examples of concerns are performance, security, specific categorized in several types. Functional concerns, quality of service concerns, Policy concerns, System concerns and Organizational concerns.

  • Functional: related to specific functionality to be included in a system.
  • Quality of service: related to the nonfunctional behavior of a system (e. G. , performance, reliability, availability).
  • System: related to attributes of the system as a whole (e. G. , maintainability, configurability).
  • Organizational: related to organizational goals and priorities (e. G. , staying within budget, using existing software assets).

In other areas concerns has been categorized according to different areas of interest or properties I. E. High level implies security and quality of service, Caching and buffering are Low level while Functional includes features, business rules and Non Functional (systematic) implies synchronization, transaction management. By reflecting the separation of concerns in a program, there is clear traceability from requirements to implementation. The principle of separation of concerns states that software should be organized so that each program element does one thing and one thing only.

In this case it means each aerogram element should therefore be understandable without reference to other elements. Program abstractions (subroutines, procedures, objects, etc) support the separation of concerns. Core concerns relate to a system’s primary purpose and are normally localized within separate procedures, objects, etc. And other concerns tend to scatter and cross multiple elements. These cross-cutting concerns are managed by aspect since they cannot be localized resulting in problems when changes are required due to tangling and scattering.

Separation of concerns provides modular dependency between aspects and components. For instance we would like to maintain a system that manages payroll and personnel functions in our organization, and there is a new requirement to create a log of all changes to an employee’s data by management. It would mean that changes will include in payroll, number of deduction, raises, employee’s personal data and sass of many other information associated with employee. This implies that there are several codes that will require changes.

This process could be tedious and you might end up forgetting changing other codes as well even not understanding each and every code. With aspects you old deal with a particular element only. In this case there won’t be redundancy of multiple codes doing the same thing. An update function could be implemented that would be called whenever you would want to implement a particular method.

Aspect-oriented Approach

Requirement Engineering

In requirements engineering there is need to identify requirements for the core system and the requirements for the system extensions. Viewpoints are a way to separate the concerns of different stakeholders that are core and secondary concerns. Each viewpoint represents the requirements of related groups of stakeholder. The requirements are organized according to stakeholder viewpoint then they are analyses to discover related requirements that appear in all or most viewpoints. These represent the core functionality of the system. There could be other viewpoint requirements that are specific to that viewpoint these then can be implemented as extensions to the core functionality.

These requirements (secondary functional requirements) often reflect the needs of that viewpoint and may not share there are non-functional requirements that are cross-cutting concerns. These generate requirements of to some or all viewpoint for instance requirements for security, performance and cost.

Software Design Aspect Oriented

Design is the process of designing a system that makes use of aspects to implement the cross-cutting concerns and extensions that are identified during the requirements engineering process.

ADD focuses on the explicit representation of cross-cutting concerns using adequate design languages. ADD languages consist of some way to specify aspects, how aspects are to be composed and a set of well-defined composition semantics to describe the details of how aspects are to be integrated. (Chitchat, Awls Rashes, Pete Sawyer, Alexandra Garcia, Monica Pinto Larson, Jotter Beaker, Bedim Ticonderoga, Skibobs Clarke, Andrew Jackson, 2005) Like in object orientation, several aspect-oriented extensions to ML design language to represent aspect-oriented concepts at the design level.

One of these ML extensions is ATOM. ADD in ML requires a means of modeling aspects using ML stereotypes. Is an approach of specifying the Join points where the aspect advice is to be composed with the core system. The high-level statement of requirements provides a basis for identifying some system extensions that may be implemented as aspects. Developing these in more details to identify further extensions and understanding the functionality required is to identify a set of use cases associated with each viewpoint. Each use case represents an aspect. Extension use cases naturally fit the core and extensions architectural model of system.

Aspect-oriented Design Process

Below is fugue 1 that illustrate the design activities of generic aspect-oriented design process Core system design is where you design the system architecture to support the core functionality of the system. Aspect identification and design Starting with the extensions identified in the system requirements, you should analyses these to see if they are aspects in themselves or if they should be broken down into several aspects.

Composition design At this stage, you analyses the core system and aspect designs to discover where the aspects should be composed with the core system. Essentially, you are identifying the Joint points in a program at which aspects will be woven Conflict analysis and resolution Conflicts occur when there is a pinpoint clash with different aspects specifying that they should be composed at the same point in the aerogram Name design is the essential to avoid the problem of accidental pinpoints.

These occur when, at some program Join point, the name accidentally matches that in a pinpoint pattern. The advice is therefore unintentionally applied at that point.


The goal of aspect-oriented programming is to provide an advance modularization scheme to separate the core functionality of software system from system-wide concerns that cut across the implementation of this core functionality. APP must address both what the programmer can say and owe the computer system will realize the program in a program system. APP system: mechanisms are conceptually straight forward and have efficient implementations.

Joint Point Model

A Join point model defines the kinds of Join points available and how they are accessed and used. They are specific to each aspect-oriented programming language for instance Aspects. In Aspects, Joint point are defined by grouping them into pinpoints.  A pinpoint is a predicate that matches Join points. A pinpoint is a relationship ‘Join point Boolean’, where the domain of the relationship is all possible Join points.

Advantages and Disadvantages of APP

APP promotes clear design and risibility by enforcing the principles of abstraction and separation of concerns. APP explicitly promotes separation of concerns, unlike earlier development paradigms. This separation of concerns provides cleaner assignment of responsibilities, higher modularization and easier system evolution, and should thus lead to software systems which are easier to maintain. The process is to collect scattered concerns into compact structure units, namely the aspects.

On the other hand, APP cannot be elegantly applied to every possible situation. Validation and Verification is the process of demonstrating that a program meets the real needs of its stakeholders and meets its specification. Validation or testing is used to discover defects in the program or to demonstrate that the program meets its requirements. Statement verification techniques focus on manual or automated analysis of the source code. Like any other systems, aspects-oriented systems can be tested as black-boxes using the specification to derive the tests.

However, program source code is problematic. Aspects also introduce additional testing (Ian Somerville (2006)  Testing problems with aspects. To inspect a program in a conventional language effectively, you should be able to read it from right to left and top to bottom. Aspects make this as the program is a web rather than a sequential document. One can’t tell from the source code where an aspect will be woven and executed. Flattening an aspect-oriented program for reading is practically impossible .

Challenges with Aspect-oriented Systems

One of the limitations of APP is that it is not supported by default on any programming platform. Although it seems to be gaining popularity, its implementation has been undertaken by third parties as extensions to development framework. This has resulted in some level of disparity on the features being implemented as some of the implementations only implement specific features making it difficult to use such frameworks in some situations in addition to creating some confusion over the feature. AAA programs can be “black-box tested” using requirements to design the tests, but program inspections and “white-box testing” can be problematic, since you can’t always tell from the source code alone where an aspect will be woven and executed.

Recommendations Adopting Aspect Oriented

Software development will reduce repetitions of coding or Component maintenance and reuse has a great impact to the company. On the part of cost, the company can determine whether it is easy to maintain its systems or not. Using other development paradigm can be cumbersome hence increasing tangling and scattering. System performance will also be affected in such a way that there could be more codes doing the same thing. GOAD concepts reduce redundancy and increase system performance. All functional and non-functional concerns are dealt with in GOAD. On implementation of security, Design flaws and code errors or bugs old be some of the causes of security flaws in software. Unlike SOD, GOAD approach made Software Development easy with the separation of concerns leading to modularization in reuse.

Calculate the price
Make an order in advance and get the best price
Pages (550 words)
*Price with a welcome 15% discount applied.
Pro tip: If you want to save more money and pay the lowest price, you need to set a more extended deadline.
We know how difficult it is to be a student these days. That's why our prices are one of the most affordable on the market, and there are no hidden fees.

Instead, we offer bonuses, discounts, and free services to make your experience outstanding.
How it works
Receive a 100% original paper that will pass Turnitin from a top essay writing service
step 1
Upload your instructions
Fill out the order form and provide paper details. You can even attach screenshots or add additional instructions later. If something is not clear or missing, the writer will contact you for clarification.
Pro service tips
How to get the most out of your experience with MyHomeworkGeeks
One writer throughout the entire course
If you like the writer, you can hire them again. Just copy & paste their ID on the order form ("Preferred Writer's ID" field). This way, your vocabulary will be uniform, and the writer will be aware of your needs.
The same paper from different writers
You can order essay or any other work from two different writers to choose the best one or give another version to a friend. This can be done through the add-on "Same paper from another writer."
Copy of sources used by the writer
Our college essay writers work with ScienceDirect and other databases. They can send you articles or materials used in PDF or through screenshots. Just tick the "Copy of sources" field on the order form.
See why 20k+ students have chosen us as their sole writing assistance provider
Check out the latest reviews and opinions submitted by real customers worldwide and make an informed decision.
Love this writer!!! Great work
Customer 452597, April 5th, 2021
Social Work and Human Services
Great work I would love to continue working with this writer thought out the 11 week course.
Customer 452667, May 30th, 2021
Thank you!
Customer 452545, February 6th, 2021
Business and administrative studies
Customer 452773, February 23rd, 2023
Business and administrative studies
looks good thank you
Customer 452773, March 3rd, 2023
Business and administrative studies
Thank you
Customer 452773, March 19th, 2023
Thank youuuu
Customer 452729, May 30th, 2021
Business and administrative studies
Customer 452773, February 23rd, 2023
English 101
great summery in terms of the time given. it lacks a bit of clarity but otherwise perfect.
Customer 452747, June 9th, 2021
Business and administrative studies
excellent paper
Customer 452773, March 3rd, 2023
Thank you!!! I received my order in record timing.
Customer 452551, February 9th, 2021
Business Studies
Thank you very much for a good job done and a quick turn around time.
Customer 452615, March 31st, 2021
Customer reviews in total
Current satisfaction rate
3 pages
Average paper length
Customers referred by a friend
15% OFF your first order
Use a coupon FIRST15 and enjoy expert help with any task at the most affordable price.
Claim my 15% OFF Order in Chat

Sometimes it is hard to do all the work on your own

Let us help you get a good grade on your paper. Get professional help and free up your time for more important courses. Let us handle your;

  • Dissertations and Thesis
  • Essays
  • All Assignments

  • Research papers
  • Terms Papers
  • Online Classes


eskişehir escort
- Korsan taksi Antalya


eskişehir escort
- Korsan taksi Antalya