#Design

 Aligning Bounded Contexts with Subdomains in Legacy Code

One way or another, each system contains some kind of boundaries. I would go so far and claim that even the dreaded Big Ball of Mud systems consist of parts that could be perceived as separate though undoubtedly only under deep scrutiny. The difference is in the “thickness” of the boundaries and the measure of interrelationships between the different parts of the system, the frequency and amount of data that is passed across the fences. It is the latter that leads to increased coupling resulting in systems that are hard to maintain and hard to change. This presentation will present a story of an attempt to achieve an alignment between perceived subdomains, logical boundaries and source code structure in a legacy system. Based on the use case from healthcare we will go into technical detail on concrete steps that were followed to create a new bounded context using strategic Domain-Driven Design and 4+1 Architectural View Models.

Architecture DDD Design Video

Dec 22 2022

 Balancing Coupling in Software Design

We are used to treating coupling as the necessary evil. Hence, we aim to break systems apart into the smallest services possible, in the ever-lasting quest of decoupling everything. But what results are we getting by following this reasoning? — Instead of the promised land of evolvable systems, many such “decouple everything” endeavors lead straight into the chains of distributed monoliths. Can we do better? What if there is a better way to handle coupling in distributed systems? Or even, what if instead of fighting coupling, we can use it as a heuristic for designing systems that are actually evolvable and maintainable? That’s exactly what you will learn in this session: what coupling is, and how you can use it as a design tool. We will start by taking a journey through time, and explore the different models of evaluating coupling. Next, we will combine the existing knowledge into a coherent model — a simple function for evaluating a system’s decomposition into components. This function will allow you to assess the expected effort for evolving a system and use it as a heuristic for optimizing architectural design decisions.

DDD Design Video

Dec 22 2022

 Workflows, a new abstraction for distributed systems

For the past 45 years, the database systems community has enjoyed an unparalleled developer experience: Database Transactions mitigate challenges such as failure on a platform level, entirely eliminating these challenges on an applications level. Unfortunately, the distributed systems community has not enjoyed a similar developer experience: There was no equivalent abstraction that mitigates challenges like failure on a platform level. However, many companies, including Snap, Uber, and Netflix, are adopting a new paradigm: Workflows. Workflows are to distributed systems what transactions are to databases. This talk explores how Workflow Systems mitigate challenges on a platform level and provide a developer experience for distributed systems that rivals the developer experience for databases, allowing you to literally code as if failure does not even exist!

Abstraction Architecture Design Video

Nov 7 2022

 Fractal Architecture

Why is software development so difficult? A major reason is that you spend more time reading than writing code. If you can decrease the time required to read existing code, you can increase productivity. You can decrease the time you waste reading complicated code by writing code that's easy to read - code that fits in your head. Code should fit in your head at all levels of abstraction. At the entry point, at the business logic level, and at the lowest levels of detail. This is fractal architecture - code that is organised according to that principle of self-similarity. Key to achieve fractal architecture are encapsulation, aggressive thresholds, and referential transparency. Code examples will be in C# - written in a style also readable to developers working in Java, TypeScript, C++, etc.

Design Video

Jul 29 2022

 CUPID—for joyful coding

What started as lighthearted iconoclasm, poking at the bear of SOLID, has developed into something more concrete and tangible. If I do not think the SOLID principles are useful these days, then what would I replace them with? Can any set of principles hold for all software? What do we even mean by principles?

Design SOLID

May 12 2022

 Strategic Domain-Driven Design

If you’re a software developer or architect who wants to play a more influential role in ensuring your software systems are optimised to support business goals, then you need to learn about the benefits and techniques of modern strategic domain-driven design. Many people think that DDD is about software design patterns, but that’s only a small part, and the least important part of DDD. In fact, Eric Evans wishes he’d focused more on the strategic aspects of DDD in his famous book (Domain-Driven Design: Tackling Complexity in the Heart of Software) and pushed the tactical coding patterns to the back! Strategic domain-driven design is about truly understanding the business domain. It involves collaboratively modelling business processes using advanced modelling techniques, like Event Storming and Domain Storytelling, with domain experts on an ongoing basis. One of the core outcomes of strategic DDD is identifying cohesive modules, known as bounded context. Bounded contexts help you to create a maintainable, comprehensible codebase by isolating dependencies and delineating concepts that reference different classes of business value. In this talk, you’ll see many of the most effective bounded context design heuristics, recurring patterns in the wild, and you’ll learn how to facilitate those vital modelling sessions so you can lead the adoption of strategic DDD in your organisation.

DDD Design Video

Mar 20 2022

 A Case for Outside In Design

Software architecture should enable business agility, but often it does not happen because of the mismatch between product design and software architecture. In this talk, Sandro will describe how a software design approach, focused on behavior and also driven by external interactions and business flows, can enable better collaboration between business and technology. This talk shows techniques (used in real projects) to bring product and software design together, at the same time, produce an Agile architecture that is more resilient, focused, and fully aligned to business goals.

Architecture Design Video

Jan 3 2022

 ES Evolving a Pragmatic, Clean Architecture - A Craftsman's Guide

Are you in a mood for a brainstorm? Join this critical review of the major decisions taken in a typical enterprise application architecture and learn to balance pragmatism with your design goals. Find out how to do just-in-time design to keep as much use-cases as simple as possible. The core purpose of this presentation is to learn to strike a **balance between pragmatism and maintainability** in your design. Without continuous refactoring, a simple design will inevitably degenerate into a Big Ball of Mud, under the assault of the new features and bugfixes. On the other hand, very highly-factored code can burden the take-off of the development and end up freezing the mindset in some rigid 'a-priori' design. The end goal of this talk is to challenge you to rethink critically the architecture of your own systems, and seek ways to simplify it to match your actual needs, with a pragmatic mindset. "Architecture is the art of postponing decisions", said Uncle Bob. This talk takes this idea further and explains an optimal mindset about designing enterprise applications: Evolving (Continuously Refactoring) a Pragmatic (Simple), Clean (aka Onion) Architecture, aiming to provide Developer Safety™️ and Comfort™️. It’s the philosophy that Victor distilled over the past 5 years, designing and implementing 9 applications as IBM Lead Architect, and delivering trainings and advises to many other companies. You’ll learn how to break data into pieces (Fit Entities, Value Objects, Data Transfer Objects), how to keep the logic simple (Facades, Domain Services, logic extraction patterns, Mappers, AOP), layering to enforce boundaries (keeping DTOs out of your logic, Dependency Inversion Principle), and many more, all in a dynamic, interactive and extremely entertaining session.

Design Hexagonal Architecture Video

Oct 20 2021

 Engineering You • Martin Thompson

What are the characteristics of a good software engineer? It's a topic many people would argue endlessly about. This is not surprising given we are effectively living in the era of software alchemy. Some of the best programmers draw on strong scientific and engineering backgrounds and combine this with craft-like coding skills in a virtuous feedback cycle. In this talk, we explore the individual practices and techniques that can help bring out the engineer in you.

Design Philosophy Video

Sep 16 2021