An Event-Driven Approach for the Separation of Concerns

Last week I presented a paper at the International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE 2012), at Wroclaw, Poland.

Title: “An Event-Driven Approach for the Separation of Concerns”

Abstract: “This paper presents an event-driven approach for the separation of concerns in software systems. We introduce the EventJ framework that provides an event-driven extension to the Java programming language. The paper describes a general methodology that can be used to identify the cross-cutting concerns and separate them from the main functionality using events and event handlers. We discuss the pre-requisites to perform this change and illustrate it with a concrete example. Finally, we make a comparison between the event-driven approach and the aspect-oriented one, and conclude that the use of events to separate concerns has a positive effect on software quality attributes such as maintainability, extensibility and reusability.”

You can freely download a full-copy of the paper.

You can also view the slides:

I hope you find that interesting. Feel free to leave a comment below.

About Hayim Makabee

Veteran software developer, enthusiastic programmer, author of a book on Object-Oriented Programming, co-founder and CEO at KashKlik, an innovative Influencer Marketing platform.
This entry was posted in AOP, OOD, OOP, Research and tagged , , , . Bookmark the permalink.

4 Responses to An Event-Driven Approach for the Separation of Concerns

  1. EDP as presented here is a subset of the Actor model , especially with typed events. Take a look at the Akka ( Framework for its implementation in Scala . Also , kudos for the IM & Presence based example 🙂

    • makabee says:

      Thanks for your comment, Benny. Most event-driven frameworks have been developed to improve concurrency and distribution, while in my work I used EDP as a tool to separate concerns. I believe it has many advantages when compared to AOP.

  2. Pavel Bekkerman says:

    Haim, hi!
    I totally agree that EDP has a case. Especially, in situations when the cross-cutting concerns can in fact be modeled as events. Hence the questions: 1) can ALL cross-cutting concerns be modeled as events? 2) is AOP scope goes beyond supporting cross-cutting concerns? 3) how should cross-cutting concerns be ultimately realized: single do-it-all tool OR several tools, each for it’s own “kind”?

    • makabee says:

      Thanks for your comment, Pavel. Here is my opinion about your questions:
      1) Not all cross-cutting concerns can be modeled as events. In my slides I’ve defined two pre-conditions: Concurrency and Non-dependency.
      2) I think AOP can be used in many situations, and not only to separate concerns. One example is extending the behavior of a function without changing the source code. Of course AOP can also be misused, for instance to violate encapsulation.
      3) I believe that if cross-cutting concerns can be separated through EDP, then that is better than using AOP. In my paper and slides I compared the two approaches and exposed the many advantages of EDP.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s