Agile Architecture

Every system has an architecture, whether accidental or intentional, and regardless of whether it was put in place by a nominated architect or whether it emerged from the decisions and discussions of a team.

All too often the focus of what is often described as architecture is centred around a specific set of platform technologies, which forms only one part of the set of concerns an architecture should. And all too often architecture is seen as a separate concern from development process, whereas the two are intertwined — what you build is influenced by how you build it, and vice versa.

The course covers a wide range of topics through a number of practical exercises, with plenty of time dedicated to group discussion:

• The relationship between development process and architecture
• The roles and failure modes of testing, modelling and technology platforms
• Different architectural styles and design patterns
• How to transform product vision into architecture
• Future-proofing your architecture, and accounting for uncertainty
• How to ground your architecture and avoid overdesign

And much more!

Domain-Driven Design in Theory and Practice

Understand the concepts of DDD but feeling overwhelmed to implement? Feeling overwhelmed by complex examples and can't connect how to implement DDD in your project? Looking for more concrete guidance on the concepts and principles of DDD and want to learn how to connect it to real-world code? If this sounds familiar, then this masterclass is for you.

We cover both the theory and patterns of DDD, and connect it to code with hands-on examples in .NET 6.

In this masterclass, you'll learn:

• What problems DDD addresses, when to use it, and when not to use it
• The fundamental DDD building blocks — entities, value objects, domain services, etc.
• How to integrate DDD into your software delivery
• How to find and enforce service boundaries
• How to define bounded contexts between microservices
• How to craft and enforce a ubiquitous language
• How to continuously refactor our model as our domain understanding evolves
• How to pragmatically apply DDD in ASP.NET Core 6 and EF Core 6
• ...and much more!

We spend some time on the theory and concepts of DDD and then applying it to a real-world, complex example with hands-on code exercises.

We will be using .NET as our development platform, but the learned concepts will be applicable to other languages and platforms.

Programming in Kotlin: The Essential Parts

In this masterclass you'll learn the essential parts of Kotlin: an elegant, powerful, and a pleasant language to work with. We'll focus on fundamental parts of Kotlin, it's imperative and functional programming capabilities, how Kotlin provides elegance without compromising performance by tactfully channeling the JDK. We will also dive into how to interact between Kotlin and Java code.

You'll learn:

• How to work with ease to exploit the power of Kotlin
• How to write code in idiomatic Kotlin
• How to use powerful features of Kotlin, including extension functions and nullable types
• How to write type-safe, maintainable code
• How to leverage both imperative and functional style as appropriate
• How to use Kotlin's performance related features
• Intermix Kotlin with Java code
• and much more!

This masterclass is led by Marcin Moskala, an official JetBrains partner for Kotlin training, the author of Effective Kotlin: Best Practices, Kotlin Coroutines, and Advanced Kotlin books.

Evolutionary Design: Beyond the Basics

In this course, we discuss complex tradeoff decisions involved in making evolutionary design a core, everyday programming practice. You’ll learn how to start to make the design flex, how to balance production with protecting your production capacity, and how to expand your view from the elements of simple design to higher-level principles of modularity.

Key topics:

• How to crack the chicken-and-egg problem: I need to write tests in order to refactor, and I need to refactor in order to write tests.
• How to understand when to refactor and when to rewrite, and how to do that safely.
• How to break through your refactoring rut.
• How to balanace customer tests (BDD) with programmer tests (TDD).
• How to tame mock object madness!
• How to write good tests.
• How architecture relates to design.
• How to guide your colleagues to buy into evolutionary design.
• How to build effective refactoring habits.
• Learning to trust the habits you’ve built.

And much more!

Coding Practices for Professional Developers

Many of us are familiar with the challenges posed by legacy applications. Some have the luxury of starting with a clean slate, but over time, even greenfield projects can morph into something reminiscent of the legacy apps we once struggled with. These shared issues often lead both legacy and greenfield applications to a state where implementing even a minor change becomes a painful endeavor.

How can we circumvent these challenges? What path should we tread? What are our goals? What defines an exemplary application? Let's collaboratively construct such an application during this masterclass!

Join us for this masterclass where you will delve into practices that every professional developer should not only comprehend but also implement while building a Java-based business application. Throughout the course, you will:

• Engage extensively in Test-Driven Development (TDD)
• Craft tests using contemporary tools like Groovy and Spock
• Master patterns and practices for writing tests that don't break when you refactor code internals
• Construct robust business objects and rich domain models and understand the rationale behind it
• Write business code that is configurable and detached from external systems such as DB or HTTP services
• Develop a clear understanding of how to properly organize your code in packages and layers
• ...and much more!

This masterclass is dedicated to developers able to code and complete exercises in Java.

Embark on this journey to refine your coding practices and emerge as a more adept professional developer!

Prioritizing Technical Debt in Large-Scale Systems

Prioritizing technical debt is a hard problem as modern systems might have millions of lines of code and multiple development teams — no one has a holistic overview. Fortunately, a new set of techniques known as behavioral code analysis are here to help. These combine quality metrics with data on how the engineering organization works with the code. You can then prioritize improvements and risks so that you can balance short- and long-term goals guided by objective data. This new perspective on software development will change how you view code.

Together we will:

• Learn the principles of prioritizing technical debt
• Prioritize technical debt in large-scale systems
• Balance the trade-off between improving existing code versus adding new features
• Put quantitative numbers on the costs so that you can make the business case for larger improvements to non-technical stakeholders

Go through real-world case studies from both Microservices and Monoliths.

And much more!

Practical Leadership for Developers

We all have an opportunity every day to make a postive impact on folks around us. These are often called "soft skills," but they can be some of the hardest to learn! We could call them "people skills," "essential skills," or "core skills." But, how about "SKILLS OF AWESOMENESS?" Yes, what we all need is more ways we can be awesome to each other, and awesome together.

You'll learn:

• Why leadership and awesomeness skills matter to everyone
• How to become a better leader
• How to run effective meetings
• How to deal with conflict and find consensus
• How to get better at listening and communication
• How to encourage and motivate others

And much more!

Through a series of practical exercises, we will discover and discuss the most important and relevant topics you want to cover, so that you can get the most value out of this masterclass!

The masterclass is led by David Neal – #1 speaker of 2021.

Domain Modeling Made Functional

Functional programming can be an excellent approach to designing decoupled, reusable systems with a rich domain model. This masterclass will show you why and how.

You''ll learn the core concepts of FP, and how to apply them to crafting domain logic, capturing business rules, designing business workflows, error handling, and much more, including:

• Introduction to functional programming
• Functions and types
• Composition as the fundamental principle
• Overview of DDD principles
• The importance of bounded contexts
• Onion/Hexagonal architecture and how this works with functional programming
• Modeling requirements with algebraic types
• Modeling constraints, states, and workflows
• Keeping IO at the edges
• Handling domain errors
• Composing complex functions
• Evolving the domain
• Dealing with changes in requirements

We will be using F# as our development language. The principles will be applicable to other languages. No experience with F# needed.

Microservices, Modular Monoliths, and Event-Driven Systems

In this masterclass, I’ll take you through three different styles of enterprise service architecture: modular monoliths, distributed synchronous systems, and event-driven systems.

Together, we will design a non-trivial backend system and find out the strengths and weaknesses of each architectural approach. We will discuss the typical mistakes and problems developers face during service architecture design and how to solve them. You will learn how to choose the best architecture style for your project, and how to design hybrid solutions, leveraging the best parts of each architecture style.

Topics include:

• Understanding the main styles of service and backend architecture
• Microservies or monoliths? Is there a middle ground?
• How to improve monoliths with modularity; Intro to Modular Monoliths
• How and when to split the system into services with REST/RPC
• How and when to become event-driven and fully async
• How to design non-trivial backend and service architecture
• How to avoid common errors in designing backend and service architectures
• How to use C4 model to communicate your architecture
• ...and much more!

This masterclass covers fundamental concepts, relevant to all programming platforms and languages; developers and architects with different backgrounds can attend.

Practical Messaging

Increasingly developers are relying on distributed architectures to solve the problems of scaling their applications and their development teams. But that means they now have to consider the problem of getting the parts of their systems to talk to each other.

In this masterclass, we will look at distributed systems, such as microservices, and how we integrate them. We will understand why we would prefer messaging, the fundamentals and key concepts of messaging, and how to build an event-driven architecture.

Topics covered include:

• Why and when distribute?
• How messaging, distributed, and event-driven architectures work?
• Different integration styles
• Basic Messaging Patterns (work queues, publish-subscribe, dead letter channel...)
• Advanced Messaging Patterns (streams, ordering, guaranteed delivery...)
• Orchestration vs. Choreography
• CAP Theorem
• and much more!

We will use Rabbit MQ message broker. Hands-on exercises are offered in C#, JavaScript, Python and Go.

Incremental Architecture

You can’t simultaneously fight your code and be Agile—it slows you down too much. Your code’s design must evolve incrementally along with your understanding of the product. In this masterclass, you’ll learn everything you need to create highly adaptable designs. Along the way, you’ll also experience Event Storming and other Domain-Driven Design techniques.

You’ll learn:

• How to design a system that can evolve incrementally
• SOLDIER principles (Simple, Obvious, Lightweight, Domain focused, Independent, Essential, Refactorable)
• Architectural patterns appropriate for incremental development
• How to create strictly-isolated highly decoupled subsystems
• Domain-focused architectures (including DDD)
• How to use the domain to maintain system coherence as the architecture grows
• How to identify key abstractions, bounded contexts, entities, aggregates.

In all, you’ll learn how to build a coherent and highly maintainable system and architecture that can easily accommodate changing requirements and grow incrementally as the system evolves

Pragmatic Refactoring Towards Better Architecture

Are you struggling with your codebase which causes problems like poor maintenance, unreadability, performance, and poor testability? After this masterclass, you will be ready to identify and repair architectural and code root causes of those issues using proven patterns and techniques from Domain-Driven Design, Test-Driven Development, Object-Oriented Programming, and modularization.

During code exercises, we will walk through solutions to issues like:

• What to do with a “God Classes”?
• Modules/classes with huge coupling and with overload of business logic
• Mismatch between the code model and the business model of the reality
• How to repair data inconsistency?
• Inefficient reads from my database?
• No clear boundaries in my codebase, how to introduce some?
• and much more!

The masterclass will start with code that represents a huge legacy system that some of us have to work with on a daily basis. We will gradually refactor it and not only introduce patterns like CQRS, aggregates, policies, and parallel change, but also walk through how to talk about refactoring, technical debt, and how to sell our ideas to management.

The course is for developers able to code and complete exercises in Java, C#, or PHP.

Modern Software Engineering

In this masterclass, guided by continuous delivery expert David Farley, we'll learn durable principles at the heart of effective, modern software development.

Farley's techniques cohere into a unified, scientific, and foundational approach to solving practical software development problems within realistic economic constraints.

The topics include:

• Doing what works to build better software faster
• Distinguishing good software development ideas from bad ones
• Building a culture of experimentation and empiricism
• Staying in control as systems grow more complex
• Choosing your tools based on sensible criteria
• Organizing work and systems to facilitate continuing incremental progress
• Evaluating your progress toward thriving systems, not just more "legacy code"

And much more!

Clean and Pragmatic Architecture

In this masterclass, through code examples, hands-on exercises, and discussions you''ll learn how to design a clean and pragmatic architecture.

The topics include:

• Layered Architecture: strict and relaxed variants
• Onion Architecture (aka Clean, Hexagonal, Ports-and-Adapters, Universal)
• Controllers: typical design options with tradeoffs
• Entities: techniques and best practices for modeling expressive entities
• Domain Services: how to keep them small, what is the domain logic?
• Facade vs. Application Service (DDD): a pragmatic evolutionary design strategy
• DTOs: enemy structures and when to keep them out of our domain
• Entity/DTO mapping: Best practices, pitfalls of automatic mappers
• Dependency Inversion Principle: stopping external APIs from polluting our domain
• Repositories: designing a domain-friendly search DSL
• Domain Events: mainstream best practices
• CQRS: separating read/write models
• and much more!

This masterclass uses Java as a reference language.