Boss Logic’s Post

Did you miss chapter 2.4? Domain modeling explores how to defend good architecture by embracing domain driven design. This week's chapter walks through applying domain modeling to our model use case. https://bit.ly/3z8Sc9y #modeling #DDD

Just out! Chapter 2.4, Domain modeling, explores how you can defend against poorly thought out, poorly understood architectures. In this chapter of the playbook, we walk through applying domain modeling to our model use case. https://bit.ly/3z8Sc9y #modeling #DDD

Just out! Chapter 2.3, Domain modeling, explores how you can defend against poorly thought out, poorly understood architectures. In this chapter of the playbook, we walk through applying domain modeling to our model use case. https://bit.ly/3z8Sc9y #modeling #DDD

📢 Dependency Inversion + Domain-Driven Design (DDD) = Domain-Centric Architecture Sponsor : https://defi-central.net Several popular architectural patterns exemplify this approach, including: • Hexagonal (Ports & Adapters) • Onion Architecture • Clean Architecture Clean Architecture, in particular, positions business logic and the domain model at the core of the application. The use cases, forming part of the application core, orchestrate the domain model’s actions. Understanding Layer Dependencies: The inner layers define abstractions (interfaces), while the outer layers implement these interfaces. During runtime, concrete implementations replace the abstractions. This dependency inversion enables: • Hiding Internal Implementation Details: The internal workings are encapsulated, promoting cleaner and more maintainable code. • Improved Testability: The application core remains independent of infrastructure, facilitating easier unit testing. A Practical Perspective: Despite its benefits, the rigid structure of Clean Architecture might not always be advantageous. An alternative to consider is Vertical Slice Architecture, which organizes code around feature slices. Use cases are written as transaction scripts, and logic can be pushed down to domain entities if needed. This approach can simplify complex implementations. Experience Matters: The ability to maintain such a system, introduce abstractions, or refactor use cases comes from experience and building multiple systems (and learning from mistakes). When to Choose Clean Architecture? Clean Architecture is ideal when: • You have a complex domain that benefits from clear separation of concerns. • Long-term maintainability and testability are priorities. • You anticipate frequent changes in infrastructure or external dependencies. Your thoughts? When do you find Clean Architecture most beneficial? #SoftwareArchitecture #CleanArchitecture #DomainDrivenDesign #TechLeadership

Part Two of Jason Baragry and my blog series on Generative AI and Enterprise Architecture is now out. This time we're exploring fundamental questions about how architects model the enterprise given the radical new technologies now available to us. Like all of us, we're feeling our way into this new era of EA and are just as interested to hear your own thoughts and ideas. https://lnkd.in/epXgNSPW

𝑳𝒂𝒚𝒆𝒓𝒆𝒅 𝑨𝒓𝒄𝒉𝒊𝒕𝒆𝒄𝒕𝒖𝒓𝒆 𝒊𝒔 𝒂𝒍𝒔𝒐 𝒂 𝒄𝒉𝒐𝒊𝒄𝒆 𝒇𝒐𝒓 𝑫𝒐𝒎𝒂𝒊𝒏-𝑫𝒓𝒊𝒗𝒆𝒏 𝑫𝒆𝒔𝒊𝒈𝒏 Domain-driven design (DDD) is itself architecture-agnostic. Choosing the exact architecture for your DDD application depends on your business requirements, organizational structure, team skills, scalability approach, and so on. 𝑨𝒑𝒑𝒍𝒚𝒊𝒏𝒈 𝐋𝐚𝐲𝐞𝐫𝐞𝐝 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 𝒕𝒐 𝐃𝐃𝐃 A layered architecture promotes separation of concerns, making the code easier to understand and maintain, especially for larger systems. In DDD, a complex domain can be broken down into well-defined layers. This keeps the core business logic (domain layer) isolated from presentation and persistence concerns. DDD emphasizes modeling the problem domain effectively. A layered architecture ensures the domain layer remains the central focus, with other layers providing supporting functionality. 𝐂𝐡𝐨𝐨𝐬𝐢𝐧𝐠 𝐋𝐚𝐲𝐞𝐫𝐞𝐝 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 𝐟𝐨𝐫 𝐈𝐧𝐢𝐭𝐢𝐚𝐥 𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭 If your team is already familiar with and comfortable working in a layered architecture, it might be a more efficient choice for initial development. 𝐏𝐨𝐭𝐞𝐧𝐭𝐢𝐚𝐥 𝐈𝐬𝐬𝐮𝐞𝐬 𝐰𝐢𝐭𝐡 𝐋𝐚𝐲𝐞𝐫𝐞𝐝 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 𝐢𝐧 𝐃𝐃𝐃 An infrastructure layer positioned below the domain layer can cause problems from a dependency perspective. Referencing from the infrastructure layer up to the domain layer violates the principles of layered architecture. 𝑆𝑜𝑙𝑢𝑡𝑖𝑜𝑛𝑠 Fortunately, solutions like using modules or applying the Dependency Inversion Principle (DIP) can help us address this issue. #ddd #domaindrivendesign #applyingdomaindrivendesign #dddwithlayeredarchitecture

If you've ever found it difficult to develop an architecture for an opaque black box, or found that your SysML model does not align well with what your software team is doing, you might consider trying to drive your logical architecture from a good solid domain model. As you can see in this video, adding a subsystem layer to the domain model and then decomposing any nested subsystems down to the component level is quick and easy, especially when assisted by AI. Domain Driven Design (DDD) is a mainstay in the software community but often still a mystery in the MBSE world.

Based on my experience in previous projects, I encountered various architecture patterns. In conversations about the motivation behind architectural decisions, some recurring patterns stand out: ▪️This has grown organically ("implicit / random architecture") ▪️We took company XYZ as orientation („it worked for company XYZ“) ▪️We wanted to use latest state-of-the art technology („tech driven architecture“) ▪️This is mirrored from the organizations structure („Conway’s law architecture) ▪️We relied on a modern framework („hype architecture“) ▪️We choosed what worked already well in other successful projects („one size fits all architecture“) All patterns lead to the same wish. We use a well functioning architecture as a pattern and that’s about it. It saves effort and time, however often not leads to the desired outcomes. Architecture - why are we doing this at all and what is it actually supposed to do? Every enterprise is unique, hence the context matters a lot. Take conscious and explicit decisions (architecture trade-offs) on what matters most for your organization. (Written by human, formatted by AI) #enterprisearchitecture #patterns #techleadership ---------- You like it? 🔔 Follow: Marcel Weigel ♻️ Share and let others benefit, too. 💾 Save for later.

Ai & Enterprise Governance For once, and as far as generative copilots are considered, software engineering, usually a laggard, could announce a general overhaul of traditional organisational architectures and governance paradigms. Two driving factors are behind the momentum: Bounded contexts: unambiguous semantics, no uncertainties, time capsules Overhaul of processes and tasks designs according to the nature of tasks: observation, orientation, decisions, actions Both forces can significantly reduce the complexity of governances enterprises governance and thus further their competitive edge.  https://lnkd.in/eitvXznx