Will JavaScript type annotations kill TypeScript?
The creators of Svelte and Turbo 8 both dropped TS recently saying that "it's not worth it".
Yes: If JavaScript gets type annotations then there's no reason for TypeScript to exist.
No: TypeScript remains the best language for structuring large enterprise applications.
TBD: The existing user base and its corpensource owner means that TypeScript isn’t likely to reach EOL without a putting up a fight.
I hope they both die. I mean, if you really need strong types in the browser then you could leverage WASM and use a real programming language.
I don’t know and I don’t care.
Microservices / Operations

Event-Driven Microservices Offer Flexibility and Real-Time Responsiveness

Event-driven microservices are a powerful architectural pattern that combines the modularity and flexibility of microservices with the real-time responsiveness and efficiency of event-driven architectures.
Sep 13th, 2023 10:00am by
Featued image for: Event-Driven Microservices Offer Flexibility and Real-Time Responsiveness
Feature image by sharkolot from Pixabay.

In today’s dynamic business environment, developers are increasingly pressured to deliver fast, reliable, scalable solutions to keep up with evolving business demands, and traditional applications are proving to be a hurdle in achieving these objectives. Microservices offer a well-understood and promising alternative, but there is a powerful augmentation to this approach that drives even more agility and time-to-value for developers: more specifically, what I refer to as an event-driven programming model, leveraging event-driven microservices.

Event-driven microservices are a powerful architectural pattern that combines the modularity and flexibility of microservices with the real-time responsiveness and efficiency of event-driven architectures. At their core, event-driven microservices rely on three fundamental principles: loose coupling, message-driven communication and asynchronous processing. These principles combine to create scalable, resilient and highly-performant distributed systems:

Loose Coupling

Loose coupling is a critical aspect of event-driven microservices, as it promotes modularity and separation of concerns. Loose coupling allows each microservice to evolve independently, minimizing the dependencies between individual services without impacting the overall system. Loose coupling enables faster development and deployment cycles and ensures that issues in one service do not cascade and affect other parts of the system.

Message-Driven Communication

In an event-driven microservice architecture, services communicate through messages, representing events or data changes occurring within the system. Events passed between services via event handlers serve as intermediaries that decouple event producers from event consumers. By adopting message-driven communication, event-driven microservices can effectively handle varying loads, ensuring the system remains responsive and resilient even during heavy traffic or peak usage.

Asynchronous Processing

Asynchronous processing is another fundamental principle of event-driven microservices. Instead of waiting for an immediate response or completion of a task, services in this architecture can continue processing other tasks while awaiting the completion of previous requests. This approach significantly reduces system latency and allows for greater parallelism, as multiple services can process events concurrently without being blocked by synchronous calls.

These fundamentals establish the foundation for event-driven microservices and, thus, event-driven programming, allowing developers to create highly scalable, resilient and responsive distributed systems. By embracing loose coupling, message-driven communication and asynchronous processing, event-driven microservices can efficiently handle complex, dynamic workloads and adapt to the ever-changing requirements of modern applications.

Embracing Loose Coupling: The Key to Scalable and Resilient Event-Driven Microservices

Loose coupling is an essential feature of event-driven microservices that facilitates the separation of concerns and modularity in a distributed system. This design principle helps to minimize the dependencies between individual services, allowing them to evolve and scale independently without impacting the overall system.

In a loosely coupled architecture, services are designed to react only to incoming commands, process them and emit events. This approach has several benefits:

  • Service Autonomy: By limiting a service’s responsibility to processing commands and emitting events, each service operates independently of others. This autonomy allows for flexibility in development, as teams can modify or extend a single service without affecting other components in the system.
  • Decoupled Communication: Instead of directly invoking other services or sharing data through APIs, services in a loosely coupled architecture communicate through events. This indirect communication decouples services from one another, reducing the risk of creating brittle dependencies or tight coupling that can hinder scalability and maintainability.
  • Enhanced Scalability: Each service is responsible for processing its commands and emitting events, which can be scaled independently to handle increased demand or improve performance. This feature enables the system to adapt to changing workloads or growth in user traffic without affecting other services or the entire system.
  • Improved Fault Tolerance: Loose coupling helps to contain failures within individual services. If a service encounters an issue, it can be isolated and fixed without causing a cascading failure across the entire system. This containment improves overall system reliability and resilience.
  • Easier Maintenance and Updates: With each service operating independently, developers can deploy updates, bug fixes or add new features to a single service without impacting others. This modularity simplifies maintenance and enables faster iteration cycles.

Developers can create more robust, maintainable and scalable event-driven microservices by embracing loose coupling and designing services that react only to incoming commands, processes, and emit events. This isolation allows for greater flexibility and adaptability in changing requirements and growing workloads, ensuring the system remains responsive and resilient.

Harnessing Message-Driven Communication in Event-Driven Systems: Events, Commands and Downstream Services

Message-driven communication is fundamental to event-driven systems, enabling services to communicate asynchronously and maintain loose coupling. This process involves the interaction between upstream services, events, commands, and downstream services in a coordinated manner. Let’s break down each step of this communication process:
  • Publishing Events: Upstream services, or event producers, generate events in response to specific actions or changes within the system. These events represent state changes or important occurrences that must be communicated to other services. Event producers publish these events to an event broker or journal, disseminating them to interested parties.
  • Transforming Events into Commands: Once the events are received by a message handler or an intermediary service, they are typically transformed into commands. Commands represent actions that need to be executed by downstream services. This transformation process often involves extracting relevant data from the event payload, validating the data and mapping it to the appropriate command structure.
  • Publishing Commands to Downstream Services: After transforming events into commands, the message handler or intermediary service publishes the commands to the downstream services or command consumers. These services are responsible for executing the actions specified in the commands, processing the data and, if necessary, generating new events to notify other services of the results.
Message-driven communication in event-driven systems offers several benefits:
  • Asynchronous Interaction: By communicating through events and commands, services can interact asynchronously without waiting for immediate responses. This approach reduces system latency, allows for better parallelism and enhances responsiveness.
  • Decoupling Services: Using events and commands as the primary means of communication between services promotes loose coupling, as services do not need to be aware of each other’s internal implementations or APIs. This decoupling simplifies development and allows services to evolve independently.
  • Scalability and Resilience: Message-driven communication enables better load balancing and resource utilization, as services can independently scale and adapt to changing workloads. Additionally, this communication pattern improves fault tolerance, as the failure of one service does not immediately impact the entire system.
In summary, message-driven communication in event-driven systems is essential for promoting loose coupling, asynchronous processing and scalability. By publishing events from upstream services, transforming them into commands, and publishing those commands to downstream services, event-driven systems can efficiently handle complex workloads and adapt to the ever-changing requirements of modern applications.

Transitioning from Synchronous to Asynchronous Event-Driven Architectures: Learning from Experience

Developers and teams are often accustomed to synchronous communication patterns, as they are familiar and intuitive from their experience with object-oriented or functional programming. In these paradigms, objects invoke methods on other objects or functions that synchronously call other functions. This familiarity often leads to adopting synchronous communication patterns between microservices in distributed systems.
However, synchronous processing flows may not be well-suited to distributed processing environments for several reasons:
  • Coupling: Synchronous communication leads to tight coupling between services, as they need to be aware of each other’s APIs and implementation details. This coupling makes it difficult to evolve, scale or maintain services independently.
  • Latency: When services communicate synchronously, they must wait for responses before proceeding, which increases system latency and reduces responsiveness, especially when dealing with complex workflows or high workloads.
  • Reduced fault tolerance: Synchronous communication can lead to cascading failures, where issues in one service can quickly propagate to other services, leading to system-wide instability.
  • Limited scalability: Synchronous communication patterns limit the system’s ability to scale horizontally. Services must always be available and responsive to handle incoming requests, which can be challenging in high-traffic scenarios or under heavy workloads.
As developers encounter production stability issues and recognize the limitations of brittle synchronous processing patterns, they begin to appreciate the merits of asynchronous event-driven architectures. These architectures offer several advantages:
  • Loose coupling: Asynchronous event-driven architectures use message-driven communication, which decouples services and allows them to evolve independently, promoting greater modularity and maintainability.
  • Improved responsiveness: Asynchronous processing enables services to continue working on other tasks without waiting for responses, reducing system latency and enhancing responsiveness.
  • Enhanced fault tolerance: Asynchronous communication helps to contain failures within individual services, preventing cascading failures and improving overall system resilience.
  • Scalability: Asynchronous event-driven systems can more effectively scale horizontally, as services can process events concurrently and independently without being blocked by synchronous calls.

By embracing asynchronous event-driven architectures, developers can address the limitations of synchronous communication patterns and build more scalable, resilient and efficient distributed systems. Learning from experience, they can create more robust and maintainable microservice applications that can better adapt to the ever-changing requirements of modern software development.


Adopting event-driven microservices is a strategic move transforming how businesses and developers approach software design and management. As noted here, the benefits for developers are immense in terms of time, resources, and quality code. Beyond simply business interests, there are significant benefits to individual industries. Consider, in the healthcare sector, how event-driven architectures enable hospital networks to monitor patient health data in real time and trigger alerts to healthcare professionals when anomalies are detected. This could save lives by ensuring immediate action in critical situations.

These examples demonstrate how the principles of event-driven microservices can revolutionize a wide range of industries by delivering robust, adaptable and responsive applications.

Group Created with Sketch.
THE NEW STACK UPDATE A newsletter digest of the week’s most important stories & analyses.