Resources

 Real World Micro Services

Over the years I’ve become pretty frustrated by the state of tech and engineering in general. One of the biggest issues we face in the industry is the lack of reusability in software. GitHub made a major revolutionary change for developers, enabling all of us to reuse libraries, and code through reuse rather than writing everything from scratch. Yet it never felt like that made it any further than that.

Go Microservices

Sep 29 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

 Event-Driven Architectures Done Right

Far from a controversial choice, Kafka is now a technology developers and architects are adopting with enthusiasm. And it’s often not just a good choice, but a technology enabling meaningful improvements in complex, evolvable systems that need to respond to the world in real time. But surely it's possible to do wrong! In this talk, we'll look at common mistakes in event-driven systems built on top of Kafka: -Deploying Kafka when an event-driven architecture is not the best choice. -Ignoring schema management. Events are the APIs of event-driven systems! -Writing bespoke consumers when stream processing is a better fit. -Using stream processing when you really need a database. -Trivializing the task of elastic scaling in all parts of the system. It's highly likely for medium- and large-scale systems that an event-first perspective is the most helpful one to take, but it's early days, and it's still possible to get this wrong. Come to this talk for a survey of mistakes not to make. Lecture took place on Wednesday 25th August 2021 at 13:30 in Room 1 Tim Berglund is a teacher, author, and technology leader with Confluent, where he serves as the Senior Director of Developer Advocacy. He can frequently be found at speaking at conferences in the United States and all over the world. He is the co-presenter of various training videos on topics ranging from Git to Distributed Systems to Apache Kafka. He tweets as @tlberglund, blogs very occasionally at http://timberglund.com, and lives in Littleton, CO, USA with his wife, their three children having grown up. Topics covered: -What is Event-Driven Architecture -Data Mesh Principles -Scaling -State management

Architecture Best Practices Event Sourcing Video

Jun 10 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

 Static Duck Typing in Python with Protocols

Protocols in Python provide a nice way to use duck typing while still having some static type guarantees. You can define contracts for your functions without caring too much about the actual types of your inputs.

Python

Nov 29 2021

 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

 Breaking Dependencies: The SOLID Principles

SOLID is an abbreviation for five of the most important software design principles: - (S)ingle Responsibility Principle - (O)pen-Closed Principle - (L)iskov Substitution Principle - (I)nterface Segregation Principle - (D)ependency Inversion Principle For almost two decades, these principles have proven to be a valuable set of guidelines to cope with software dependencies. Although initially introduced as guidelines for object-oriented programming, they have become a universal set of guidelines that can be used equally well for procedural, functional or generic programming. In this talk I'll recap the SOLID principles and explain why they form such a valuable set of universal design guidelines. Also, I'll go into detail about several common misconceptions.

SOLID Video

Oct 20 2021