Event-driven architecture (EDA) is exciting until you deal with event versioning. The solution is a pattern, an Adapter, but with a twist. (Like 90% of the problems in Software Development) The Problem Your schema changed with some breaking changes. You have to update your Producer and 3 of your consumers. You may think you can have coordinated deployments. Good luck; you will be stuck in 27 meetings, and something will go wrong. A Solution Create a new Topic; use this topic to publish the new schema versions. Update the producer to generate the new schema and point it to the new topic. Create an Adapter listening for messages in the New Topic and translating the message to the old format, then saving it into the old topic. Start migrating the consumers and pointing them to the New Topic. Once you finish the migration, you can decommission the Adapter and get rid of the old topic. Benefits The Adapter ensures backward compatibility, allowing existing consumers to continue functioning. This allows for a gradual migration of consumers to the new event schema. There is no big coordinated deployment with downtimes and no endless meetings. Testing will be more focused and controlled, as each consumer's transition can be tested independently.
SmartIPlace’s Post
More Relevant Posts
-
Event-driven architecture (EDA) is exciting until you deal with event versioning. The solution is a pattern, an Adapter, but with a twist. (Like 90% of the problems in Software Development) The Problem Your schema changed with some breaking changes. You have to update your Producer and 3 of your consumers. You may think you can have coordinated deployments. Good luck; you will be stuck in 27 meetings, and something will go wrong. A Solution Create a new Topic; use this topic to publish the new schema versions. Update the producer to generate the new schema and point it to the new topic. Create an Adapter listening for messages in the New Topic and translating the message to the old format, then saving it into the old topic. Start migrating the consumers and pointing them to the New Topic. Once you finish the migration, you can decommission the Adapter and get rid of the old topic. Benefits The Adapter ensures backward compatibility, allowing existing consumers to continue functioning. This allows for a gradual migration of consumers to the new event schema. There is no big coordinated deployment with downtimes and no endless meetings. Testing will be more focused and controlled, as each consumer's transition can be tested independently. Say no to more meetings and start releasing the smart way! 😉
To view or add a comment, sign in
-
Software-intensive systems require continuous architecture refactoring in response to the company’s continuously evolving business strategy. Failing to cater to this will cause productivity and quality concerns over time and will require us to address this anyway by a major architecture overhaul or starting a high-risk and draining greenfield initiative. As we will be paying the effort anyway, it’s much better to continuously invest 10-25 percent of resources into refactoring and ensuring the offerings are always up to par technically and in relation to the business strategy.
To view or add a comment, sign in
-
Culture is often overlooked in managing architectural health. Many companies delay the start of architectural debt resolution to aggressively avoid opportunity costs early on. Involving an architect from the start helps greatly to gauge the financial risks and how far this can be stretched. What I rarely see managed well though, is the pervasive and persistent organizational culture of urgency this tends to establish. The urgency culture frequently frustrates efforts when it becomes time to start repaying the architectural debt, often leading to a dramatic loss in agility when it is needed most as the competitive landscape closes in.
Software-intensive systems require continuous architecture refactoring in response to the company’s continuously evolving business strategy. Failing to cater to this will cause productivity and quality concerns over time and will require us to address this anyway by a major architecture overhaul or starting a high-risk and draining greenfield initiative. As we will be paying the effort anyway, it’s much better to continuously invest 10-25 percent of resources into refactoring and ensuring the offerings are always up to par technically and in relation to the business strategy.
From Agile to Radical: architecture refactoring – Software Driven World
https://janbosch.com/blog
To view or add a comment, sign in
-
Continuous Architecture in Practice book gives a solid idea on how to understand other factors while dealing with security. It will give you light on scalability, reliability, performance, Maintainability, Cost, Security. This is a must read when we are dealing with Architecture reviews. Please support the author by buying and reading this wonderful book. I have shared my notes that i have taken while reading this book in my newsletter. Addison Wesley Signature Series is a good set of books to read in the current software trend and technology. https://lnkd.in/gG4Zp86Q
Continuous Architecture in Practice Notes
ram.beehiiv.com
To view or add a comment, sign in
-
Principles of Architectural Health Today’s enterprise software systems are so large that no one person can understand how everything works. Software systems are complex networks of unbounded abstractions with huge numbers of interconnections. So, designers use well-accepted architectural principles to gain control of this complexity. These principles allow decomposition of a complex system into more understandable chunks so that teams of cognitively bounded humans can work on different parts as independently as is practical. They also ensure that changes don’t propagate in unintended ways, creating defects and rework and slowing down future adaptation. https://lnkd.in/g-8X-uah
Project to Product: Modular Architectures Make You Agile in the Long Run
https://blog.planview.com
To view or add a comment, sign in
-
As you begin work on building your minimum viable product (MVP), the choice of software architecture can significantly shape your product's trajectory and overall success. In this post, I'll explore various architectural options and discuss when each should be considered: 1. Monolithic Architecture: This is your go-to approach when speed is paramount. Ideal for swiftly validating your concept or creating a straightforward application, a monolithic architecture simplifies your initial development. However, it is important to note that any downtime in one part of the application can impact the entire system also, upgrading one part means upgrading all of it. 2. Microservices Architecture: If rapid expansion, intricate functionalities, and the need for scalable, independent components are a priority for you, then microservices are your best bet. This architecture enables agile growth but can also introduce complexities in communication and management. 3. Serverless Architecture: This path suits scenarios with unpredictable workloads or a desire to focus primarily on coding, without the headache of infrastructure. So as you embrace the "pay-as-you-go" model, you should remember that complex applications might require a careful orchestration. 4. Event-Driven Architecture: In a situation where real-time responsiveness and effective handling of asynchronous tasks are paramount, the event-driven model becomes your go to architecture. This is because, it offers flexibility and resilience, but intricacies can arise in tracking events and managing event flows. In conclusion, for architectural choices, there is no universal solution. Each approach has distinct strengths and trade-offs which should be carefully considered before proceeding. PS: Picture with my friend and brother, Denu Bon, at the master class with Dr. Seun Fakorede, R.Eng, MNSE, M.ASCE.
To view or add a comment, sign in
-
Engineering Leader. Building Highly Scalable Systems and High-Performance Teams. Ex- {Amazon | Freshworks | Fourkites | HCL | Microsoft | Salesforce}. #TechInnovator #SaaSExpert #ScalableSystems
Documenting the current state architecture of a complex legacy software system with thousands of functionalities is a significant challenge that requires a systematic approach. The recommended steps are: 1. Create hundreds of detailed diagrams to model the current state of each individual business functionality or process, using tools like Miro, GitHub Copilot, and standard diagramming templates.[1][2][3] 2. Store these current state architecture diagrams in a central repository to establish a common standard across the organization. Persists the arch artefacts as much nearer to the codebase, its one way of making design docs and diagrams to be relevant with the code. [1][4] 3. Design the future state architecture for each business functionality, focusing on quality attributes like scalability, reliability, security, and performance.[1][2][3][5] 4. Conduct a gap analysis between the current and future state architectures to identify the technical, tooling, and operational changes required.[1][2][3][4] 5. Develop a comprehensive roadmap that integrates the individual domain-specific roadmaps (e.g., data, infrastructure, security) into a cohesive plan for the overall system modernization.[1][2][3][4] This structured approach to documenting the current state and planning the future state architecture enables teams to effectively manage the complexity of legacy system modernization.[1][2][3][4][5] Sources: [1] Start Your Architecture Modernization with Domain-Driven Discovery - InfoQ https://lnkd.in/gBfcrE3Y [2] Legacy System Modernization: How to Transform the Enterprise - AltexSoft https://lnkd.in/gu_fAh_8 [3] Software modernization: when, why, and how? – SOFTACOM https://lnkd.in/g6iHX-Tf [4] [PDF] Creating Software Modernization Roadmaps: The Architecture ... https://lnkd.in/gKNSrDmm [5] Accelerate Modernization with Architectural Observability - vFunction https://lnkd.in/gZG7jh9Q
Start Your Architecture Modernization with Domain-Driven Discovery
infoq.com
To view or add a comment, sign in
-
Exploring the Clean Architecture by Uncle Bob: A Blueprint for Software Design Excellence At its core, the Clean Architecture emphasizes a clear and hierarchical structure that revolves around the business logic of an application. It promotes the division of the system into distinct layers, each with its specific responsibilities and dependencies. The architecture comprises several concentric circles, each representing a different level of abstraction and isolation. The innermost circle encapsulates the entities or business objects representing the core domain logic. These entities are oblivious to any external concerns, ensuring purity and reusability. Moving outward, the next circle houses use cases or application-specific operations that orchestrate interactions between entities. This layer serves as the intermediary between the domain logic and the external world, enforcing business rules and workflows. Surrounding the use cases is the interface adapters layer, responsible for converting data from the external world into formats compatible with the application's internal representation. This layer includes controllers, presenters, and gateways, facilitating communication between the application and external systems such as databases, user interfaces, or APIs. By decoupling the core logic from the delivery mechanisms, the Clean Architecture promotes flexibility and facilitates changes without impacting the entire system. Finally, the outermost circle comprises frameworks and external tools, representing the infrastructure components necessary for the application to operate. These include databases, web frameworks, and third-party libraries. While essential for the system's functionality, these components should remain interchangeable and replaceable without affecting the core business logic. One of the primary benefits of the Clean Architecture is its support for testability. By isolating the core business logic from external dependencies, developers can easily write unit tests for the most critical parts of the system. This approach fosters a test-driven development (TDD) mindset, where tests guide the design and evolution of the software. What challenges have you faced when implementing the Clean Architecture in your projects, and how have you overcome them?? Share your experiences, tips, and ideas for maximizing the benefits of this architectural approach in software development.
To view or add a comment, sign in
-
Some time ago I came across 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐚𝐥 𝐃𝐞𝐜𝐢𝐬𝐢𝐨𝐧 𝐑𝐞𝐜𝐨𝐫𝐝𝐬 📑 . How many times have you screeched your head trying to understand Why certain decisions have been made? People come and go, memory is unreliable. I have not seen them used that much only until recently I saw them adopted on selected projects at Merix. For those of you that are new to the topic ADRs record certain design decisions for the benefit of future team members as well as for external oversight. It is a technique for capturing important architectural decisions along with their context and consequences ADRs’ greatest strength is their low barrier to entry. Since anyone on the team can write an ADR, everyone who wants can fill the role of software architect. - They are small text files, each describing a single design decision and rationale. - No special tools are required to write an ADR. - ADRs are stored in the same version control repository as the code to which those decisions apply. - They are subject to the same peer-review process as code. - They facilitate feedback and knowledge sharing ADRs are adopted practice by 𝐓𝐡𝐨𝐮𝐠𝐡𝐭𝐖𝐨𝐫𝐤𝐬 𝐓𝐞𝐜𝐡 𝐑𝐚𝐝𝐚𝐫 since Nov 2017. But are they becoming a standard practice across the software industry? Did they bridge the gap between architects and (particularly agile) development teams? Thumbs up 👍 if you use them and what are your thoughts. PS. At Merix we follow the model and process described here: https://adr.github.io/.
Architectural Decision Records (ADRs)
adr.github.io
To view or add a comment, sign in
-
Software Engineer @ FifthThought| Building & Scaling Startups (SaaS) | Helping Ideas Take Flight (SaaS)
I'm trying to figure out how to implement Clean Architecture in my project. 😊 Implementing Clean Architecture in a project involves adhering to a set of organizing principles that prioritize maintainability, testability, and scalability. Here are some key steps and considerations based on the insights from various sources: Understand the Core Principles: Clean architecture is a bundle of organizing principles that allow for personal adjustments while keeping the core ideas intact. It emphasizes the separation of concerns, testability, independence, and scalability Keep Options Open: Clean architecture is about keeping options open and minimizing regression risks. It encourages not committing to specific technologies for life, allowing flexibility in the choice of libraries, databases, and components Minimize Complexity: Clean architecture minimizes code complexity by dividing responsibilities into appropriate layers. It's essential to understand how to divide responsibilities into appropriate layers, which can be tedious without a clear idea of how each layer works. Follow Dependency Rule: Clean architecture follows the dependency rule, where dependencies can only point inward. This ensures a well-structured and maintainable architecture. Use Abstractions and Layers: Adding abstractions, such as interfaces or abstract base classes, to the application layer and implementing these abstractions in layers outside of the core can aid in achieving clean architecture goals Consider the Learning Curve: Clean architecture might not be preferable for simple projects, as it involves a steep learning curve. It's important to assess the complexity of the project before deciding to implement clean architecture Implement Interactors: In clean architecture, Interactors are used to build specific parts of the application. Understanding how to build and use Interactors is crucial for implementing clean architecture. Testability and Independence: Clean architecture enables testing of domain entities and use cases without a framework, UI, or infrastructure. It allows technology decisions to change without affecting domain code and vice versa Modularity and Encapsulation: Clean architecture supports modularity and encapsulation, allowing for the swapping out of technologies and the enforcement of business invariants Consider Stability and Flexibility: More abstract entities are usually more stable, while specific implementations that change more often are less stable. Clean architecture aims to balance stability and flexibility in software development. Incorporating these principles and considerations can help in effectively implementing clean architecture in a software project, leading to robust, adaptable, and maintainable systems.
To view or add a comment, sign in
42,092 followers