Aspect oriented programming: Code which can adapt design change easily

Introduction

Laymen explanation

As a developer When you add security checks for your banking software, then you will simply add a method which invokes security check code. But have you noticed that your code is tightly linked to current logic of security check? Think What happens if the security check flow changes? It will result in code change in too many places.

If you like to know how AOP helps in this regard, then this document helps.

Technical explanation

AOP is often defined as a technique that promotes separation of concerns in a software system. Systems are composed of several components, each responsible for a specific piece of functionality. But often these components also carry additional responsibilities beyond their core functionality. System services such as logging, transaction management, and security often find their way into components whose core responsibilities is something else. These system services are commonly referred to as cross-cutting concerns because they tend to cut across multiple components in a system.

Aspect-oriented programming (AOP) is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns. It does so by adding additional behavior to existing code without modifying the code itself.

Jargons explained

Aspect: A cross-cutting concern or a reusable module. You can have one or more aspects in an application.

Join Point: A point where you can plug an aspect in.

Weaving: Provides you solution to your tangled code. It enables you to link different aspects with other objects of the application. Note that depending on when weaving will happen, you can have compile time, load time or run-time weaving.

Pointcut: Specifies the weaving rules, i.e., it is used to define the join point where a particular advice can be applied in your application.

Benefits

When you take advantage of AOP in your applications, you can increase the modularity of your application through separation of concerns. You can use AOP to reduce code clutter by improving the readability and maintainability of your code.

Design patterns for achieving AOP

AOP can be reached in two main ways, by:

• the decorator pattern (Ref here and remember python decorators)

• the interceptor pattern (Ref here and below diagram)

Use-cases

• System services such as logging, transaction management, and security often find their way into components whose core responsibilities is something else.

• These system services are commonly referred to as cross-cutting concerns because they tend to cut across multiple components in a system.

  • Without AOP, Any change in these system services approach will result in code change in too many places

Reference

https://dev.to/rafalpienkowski/aspect-oriented-programming-aop-in-real-life-scenario-3ha

https://stackoverflow.com/questions/242177/what-is-aspect-oriented-programming

https://en.wikipedia.org/wiki/Aspect-oriented_programming

https://www.infoworld.com/article/3040557/my-two-cents-on-aspect-oriented-programming.html