Event-Driven Architecture

In modern Web 2.0 applications, terms like Reactive programming and Event-driven architecture have gained popularity. Concepts like Blocking and Non-blocking are also important to understand. Technologies like NodeJS, Play, and Akka.io are becoming more popular for modern application development compared to traditional tech like Java and PHP.

But what is the reason behind this shift? Is it just because developers are bored with traditional tech and attracted to shiny new stuff, or are there technical reasons behind it? In this article, we will explore these concepts step by step and understand the demands of modern software application development.

To start, let's discuss the concepts of Blocking and Non-blocking. In web applications, blocking refers to the flow of execution being blocked while waiting for a process to complete. This means that until the process completes, the flow cannot move forward. On the other hand, non-blocking approach allows the flow to continue executing the next lines of code without waiting for the first function to return a response.

Non-blocking approach is particularly useful for IO Input-Output intensive operations, including communication and network operations. This approach facilitates handling a large number of concurrent connections with minimal resource consumption.

Event-driven architecture, also known as Reactive architecture, is gaining popularity in modern web application development. Technologies like NodeJS, Play, and Akka.io are built for high IO scalable applications. These frameworks provide reliable behavior in a distributed environment and are capable of handling large scale concurrent scenarios.

Event-driven architecture is all about processing asynchronous data streams. It allows the application to react to events occurring regularly, instead of sequentially moving through lines of code. Events can be anything from a tweet to a click of a button, an HTTP request, or a change in the value of a variable. Handling a stream of events is crucial for real-time applications.

Implementing an event-driven architecture can be challenging with thread-based frameworks. That's why technologies like NodeJS, Play, and Akka.io are preferred, as they treat everything as a stream and provide a higher level of abstraction. They eliminate the need to worry about managing low-level memory and enable developers to focus on writing code without being concerned about multi-threading and memory issues.

It's important to note that while non-blocking tech is gaining popularity, it doesn't mean that traditional tech is obsolete. Each technology has its use cases. For example, NodeJS is ideal for IO intensive tasks but not suitable for CPU intensive tasks that require a significant amount of computational power.

In the upcoming lessons, we will discuss general guidelines for choosing the right server-side technology, providing further insight into backend technology selection.

Stay tuned for more articles on event-driven architecture and modern application development!