Navalia’s Post

In this article, I wanted to highlight the disruptive implications of the most common mistake of in DDD.

Check out this enlightening article about the real-life application of DDD!

𝐀𝐫𝐞 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 𝐒𝐭𝐲𝐥𝐞𝐬, 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬, 𝐚𝐧𝐝 𝐃𝐞𝐬𝐢𝐠𝐧 𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬 𝐝𝐢𝐟𝐟𝐞𝐫𝐞𝐧𝐭? These concepts can sometimes be ambiguous, as individuals may interpret them differently. Let's attempt to provide clearer definitions here: 𝟏. 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗮𝗹 𝘀𝘁𝘆𝗹𝗲𝘀: Architecture styles, also known as architectural patterns or architectural paradigms, are fundamental principles that dictate the overall structure and organization of a software system. These styles provide high-level design decisions and guidelines for organizing the components and interactions within an application. At the broadest level of detail, it delineates the layers and top-level modules of the application, illustrating their interconnections and mutual influence. Examples of architectural styles include: 🔸 Microservices Architecture 🔸 Microkernel Architecture 🔸 Client-Server Architecture 🔸 Event-Driven Architecture 𝟐. 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗮𝗹 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀: Architectural patterns are general solutions to recurring design problems that occur within the context of a specific architectural style. They provide templates and guidelines for solving common design challenges and implementing certain aspects of an architecture. Examples of architectural patterns include: 🔸 Model-View-Controller (MVC) 🔸 Model–View–Viewmodel (MVVM) 🔸 Model-View-Presenter (MVP) 🔸 Domain-Driven Design (DDD) 𝟑. 𝗗𝗲𝘀𝗶𝗴𝗻 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀: Design patterns are reusable solutions to common design problems encountered at a lower level of software design, typically within the context of individual classes or objects. They address specific design challenges related to object creation, composition, and behavior. We categorize Design Patterns into three main groups: 🔸 𝗖𝗿𝗲𝗮𝘁𝗶𝗼𝗻𝗮𝗹: We have Singleton, Factory Method, Builder, and Prototype. 🔸 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗮𝗹: We have Adapter, Bridge, Composite, Proxy, and Decorator. 🔸 𝗕𝗲𝗵𝗮𝘃𝗶𝗼𝗿𝗮𝗹: We have Command, State, Mediator and Strategy patterns. #architecture #softwaredesign #designpattern

###What Makes a “Good” Architecture? (process recommendations) ### #1-A software (or system) architecture should be the product of a single architect or a small group of architects with an identified technical leader. This approach is important to give the architecture its conceptual integrity and technical consistency. This recommendation holds for agile and open-source projects as well as “traditional” ones. There should be a strong connection between the architects and the development team, to avoid “ivory tower,” impractical designs. #2- The architect (or architecture team) should, on an ongoing basis, base the architecture on a prioritized list of well-specified quality attribute requirements. (Trade off that always occur. Functionality matters less). #3- The architecture should be documented using views. (A view is simply a representation of one or more architectural structures.) The views should address the concerns of the most important stakeholders in support of the project timeline. This might mean minimal documentation with the documentation then being elaborated later. Concerns usually are related to construction, analysis, and maintenance of the system, as well as education of new stakeholders. #4- The architecture should be evaluated for its ability to deliver the system’s important quality attributes. This should occur early in the life cycle, when it returns the most benefit, and repeated as appropriate, to ensure that changes to the architecture (or the environment for which it is intended) have not rendered the design obsolete. #5- The architecture should lend itself to incremental implementation, to avoid having to integrate everything at once (which almost never works) as well as to discover problems early. One way to do this is via the creation of a “skeletal” system in which the communication paths are exercised but which at first has minimal functionality. This skeletal system can be used to “grow” the system incrementally, refactoring as necessary.

𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗜𝗻𝘀𝗶𝗴𝗵𝘁: 𝗠𝗮𝘀𝘁𝗲𝗿 𝗘𝘃𝗲𝗻𝘁-𝗗𝗿𝗶𝘃𝗲𝗻 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗶𝗻 𝗝𝘂𝘀𝘁 𝟭 𝗠𝗶𝗻𝘂𝘁𝗲! When you encounter this question in an interview, focus on highlighting the key differences and real-world applications. Event-Driven Architecture (EDA) is a design paradigm in which system components communicate through the production, detection, and consumption of events. Unlike traditional architectures, where components interact through direct calls, EDA allows for a more decoupled and flexible system. 🎯 𝗔𝗻𝘀𝘄𝗲𝗿 𝗶𝗻 𝗮𝗻 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄: "Event-Driven Architecture (EDA) is centered around the concept of events—changes in state or occurrences of importance. In EDA, components emit events without worrying about how they will be processed, leading to a loosely coupled system. Traditional architectures, like monolithic or layered, rely on direct communication between components, often leading to tighter coupling and reduced flexibility." 🔧 𝗥𝗲𝗮𝗹-𝗪𝗼𝗿𝗹𝗱 𝗘𝘅𝗮𝗺𝗽𝗹𝗲: Imagine an e-commerce platform. In a traditional architecture, when a user places an order, the order service directly calls the payment, inventory, and notification services. In contrast, with EDA, the order service would emit an "Order Placed" event. The payment, inventory, and notification services would listen for this event and react accordingly, without direct dependencies between them. This approach allows for easier scalability and modification of individual services. Understanding architecture paradigms like EDA is crucial in modern software development. 𝗚𝗼𝘁 𝗮𝗻𝗼𝘁𝗵𝗲𝗿 𝘁𝗼𝗽𝗶𝗰 𝘆𝗼𝘂'𝗿𝗲 𝗰𝘂𝗿𝗶𝗼𝘂𝘀 𝗮𝗯𝗼𝘂𝘁? 𝗗𝗿𝗼𝗽 𝗶𝘁 𝗶𝗻 𝘁𝗵𝗲 𝗰𝗼𝗺𝗺𝗲𝗻𝘁𝘀! Let’s keep building your knowledge, one concept at a time! 💪 #SoftwareArchitecture #EventDriven #Microservices #Scalability #SoftwareDevelopment #TechTips #InterviewPrep

Hexagonal Architecture 101 I recently read the "Get Your Hands Dirty on Clean Architecture" book. Here are the 7 main takeaways about Hexagonal Architecture: 1) Hexagonal Architecture - architecture where the core of the application is isolated from external dependencies - also known as Ports and Adapters architecture 2) Application Core - contains the business logic - it should be independent of any specific external dependency - it exposes ports (interfaces) for communication with the external world 3) Ports - a fancy name for interfaces between the Application Core layer and the external dependencies - port defines a contract that adapters need to fulfill - it also defines the input & output points of the application 4) Adapters - adapter represents an implementation of the port(interface) - it is split into driving and driven adapters 5) Driving Adapters - responsible for handling user input - they interact with the user interface (UI) components - they can be web API controllers, command-line interface... - driving adapters convert external input into a format that the Application Core understands - tests can also use ports to interact with the Application Core and check that everything works inside it 6) Driven Adapters - these adapters handle communication with external dependencies, such as a database, email-sending service, third-party APIs, or message queues - they implement the interfaces defined by the Application Core and provide the required functionality to interact with these external systems - can also be fake implementations 7) Dependency rule - the Application Core does not depend on any specific implementation details of the adapters - but instead, the adapters depend on the interfaces the Application Core defines - this ensures that the Application Core remains decoupled from the external systems, - so it can be more testable and maintainable. P.S. Have you used Hexagonal Architecture?

Designing a well-defined system is like solving a jigsaw puzzle. When all the right pieces come together, the design in front of your eyes will fulfil all the business requirements and possibly be also extensible. A well-designed system is definitely an end goal, and the starting point is to understand fundamentals of system design. Here is a blog I wrote about the same which should provide you some pointers to get started! #systemdesign #design #fundamentals #softwarearchitecture

Understanding Hexagonal Architecture: Ports, Adapters, and Domain Model What is Hexagonal Architecture? Hexagonal architecture, also known as Ports and Adapters or the Onion architecture, is a software design pattern that has gained popularity due to its ability to improve the maintainability, testability, and adaptability of an application. The layers of the application are represented as a hexagon, with the innermost layer being the core of the application and the outer layers representing various external interfaces. Components of the Hexagonal Architecture Domain Model At the centre of the architecture is the Domain Model, which represents the application’s core business logic and entities. It is responsible for implementing the main functionality and rules that the application is built around. One of the critical principles of hexagonal architecture is that the core of the application should not depend on any specific external interface. Ports Ports are the interfaces that define the communication points between the application’s core logic and the external world. They can be categorized as: - Primary or Driving Ports - define the operations that the application exposes to external actors. They represent the use cases or application services that external systems or users initiate. - Secondary or Driven Ports - define the operations that the application needs from external services or components. They represent the dependencies or resources required for the application to function. Adapters Adapters are the components that translate the interactions between the external world and the core business logic by implementing the ports. There are two types: - Primary or Driving Adapters - convert external inputs into a format that the core logic can understand. - Secondary or Driven Adapters - implement secondary ports by providing the required functionality to interact with external services or resources. Have you worked with Hexagonal Architecture before? 💻 #hexagonalarchitecture #softwaredevelopment #softwarearchitecture #globalsoft

**Harnessing the Power of Event-Driven Architecture** I’ve seen firsthand how event-driven architecture (EDA) can transform systems. Here’s a quick overview of what it is, along with its key advantages and disadvantages. ### What is Event-Driven Architecture? Event-driven architecture is a design pattern where components of a system communicate through events. When an event occurs (like a user action or a system change), it triggers a response from other components that subscribe to that event. ### Advantages 1. **Scalability**: EDA allows systems to handle high loads by distributing events across multiple services. 2. **Flexibility**: It’s easy to add or modify features without disrupting the entire system. 3. **Resilience**: By decoupling components, EDA improves fault tolerance. If one service fails, others can continue to function. 4. **Real-Time Processing**: Ideal for applications needing immediate responses to events, such as live notifications or monitoring systems. ### Disadvantages 1. **Complexity**: EDA can be more complex to design and implement compared to traditional architectures. 2. **Debugging Challenges**: Tracing the flow of events through various services can make debugging more difficult. 3. **Consistency**: Ensuring data consistency can be tricky, as events might be processed out of order or get lost. 4. **Latency**: There may be slight delays as events propagate through the system. Event-driven architecture offers powerful benefits for building scalable, flexible, and resilient systems. However, it’s important to consider its complexities and potential challenges. When implemented correctly, EDA can greatly enhance the responsiveness and robustness of your applications. Interested in learning more or discussing how to implement EDA in your projects? Feel free to connect! #EventDrivenArchitecture #EDA #SoftwareEngineering #SystemDesign #Scalability #TechInsights

Let me tell you why 𝗲𝘃𝗲𝗿𝘆𝗯𝗼𝗱𝘆 benefits from a Message-Driven Architecture. "Don't you mean Event-Driven, Steven?" No, I do not. Events are messages, that's for sure. But messages are not necessarily events. Let us get something straight: an event is something that 𝗵𝗮𝘀 happened. Thus, events are a type of message describing something from the 𝗽𝗮𝘀𝘁. If a cashier at a supermarket said, "Requested payment option from the first person in the queue," after all my groceries had just been scanned, I would likely get the hint. But broadcasting that is not clear at all. And, frankly, a little weird. If the cashier would instead say, "Cash or card?" and direct it to me, the message would be much clearer. So why not benefit from this 𝗻𝗮𝘁𝘂𝗿𝗮𝗹 𝗳𝗹𝗼𝘄 when building applications? I believe that the 𝘀𝗲𝗽𝗮𝗿𝗮𝘁𝗶𝗼𝗻 of messaging-driven architectures is clear to everybody. Heck, that is, in part, why event-driven architectures became so big. In this style, a 𝗺𝗲𝘀𝘀𝗮𝗴𝗲 𝗯𝘂𝘀 gets messages from one place to another. Thus, the sender and receiver do not know how the message is transported—nor do they have to, as the message bus takes care of that! Hence, we achieve separation between the sending and receiving, making the application more flexible. But, if the only message you use is an event, all the communication would become as awkward as broadcasting facts in front of the cashier. You will get your point across, but your application will become tangled in a weird "past-tense blurting and waiting"-style. Adding current-tense 𝗮𝗰𝘁𝗶𝗼𝗻𝘀 to request changes and a request style for 𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 as specific message types will untangle this mess. Not just in the actual implementation but also when reasoning about the application! Both with your developers 𝗮𝗻𝗱 with the business. And thus by picking a 𝗻𝗮𝘁𝘂𝗿𝗮𝗹 𝗳𝗹𝗼𝘄, the development will flow naturally, leading to a successful end result. Hence, 𝗲𝘃𝗲𝗿𝘆𝗯𝗼𝗱𝘆 will benefit. Sure, there is more to it, but I have yet to see an application that does not benefit from a Message-Driven Architecture.