{ 1/7 } Software Design By Practice (limited seats)

The goal of this intensive, hands-on workshop, is to deepen your understanding of SOLID and other core software design principles and patterns. You'll be practicing those concepts under different constraints and requirements, devising elegant lightweight design, writing code, and discussing the tradeoffs.

Come experience the evolution of ideas into clean code by way of incremental development!

Note: this workshop runs from 9:00 until 16:00. Buy

Instructor

{ 2/7 } Surviving Legacy Code (limited seats)

We all have legacy code, meaning profitable code that we’re afraid to change. It doesn’t matter who wrote it, in which language, nor when. It matters that we feel the fear now and need to deal with it. Rewrite or refactor? How do we write tests? There’s so much to change; how do we get started? In the typical programmer’s day job, there’s no time to learn how to do this. We’re already behind schedule and the cost of fixing the legacy code is crushing us. We need a way to learn how to do this safely, correctly, and eventually, even quickly. You'll learn:

• When to refactor and when to rewrite, and how to do that safely.
• The killer technique for exposing in glorious detail exactly where the code wants us to break it apart.
• How to use statistical sampling and logs to cobble together the beginnings of a test suite.
• How to sterilise a legacy environment before even trying to change the code.
• 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.

We will work in short sessions on a diabolical-but-fun code base (available in at least 20 programming languages), practise micro-committing, a key technique to changing difficult code safely, practise a handful of refactoring and testing exercises that develop the most essential legacy code rescue skills and disciplines.

Note: this workshop runs from 11:00 until 17:00. Buy

Instructor

J.B. Rainsberger Software Coach, Mentor and Consultant, TDD Trainer tdd.training

{ 3/7 } Architecture with Agility (limited seats)

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!

Note: this workshop runs from 9:00 until 16:00. Buy

Instructor

Kevlin Henney Consultant, Trainer, Writer, Author of 97 Things Every Programmer Should Know

{ 4/7 } Clean and Pragmatic Architecture (limited seats)

In this workshop, 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 workshop uses Java as a reference language.

Note: this workshop runs from 8:00 until 16:00. Buy

Instructor

Victor Rentea Software Craftsman, Java Champion and Trainer

{ 5/7 } Building an Incremental Architecture (limited seats)

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 workshop, you’ll learn everything you need to create highly adaptable designs literally as you implement them. 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.

Note: this workshop runs from 14:00 until 19:00. Buy

Instructor

Allen Holub Principal @ Hollub Associates Ltd, Pluralsight Author, Author of Design Patterns in the Real World course

{ 6/7 } Microservices, Modular Monoliths, and Event-Driven Systems (limited seats)

In this workshop, 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 workshop covers fundamental concepts, relevant to all programming platforms and languages; developers and architects with different backgrounds can attend.

Note: this workshop runs from 9:00 until 16:00. Buy

Instructor

Jakub Nabrdalik Solution Architect, Developer and Mentor at Bottega IT Minds, ex-Head of Software Development

{ 7/7 } Practical Leadership for Software Developers (limited seats)

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

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 workshop! The workshop is led by David Neal – #1 speaker of 2020.

Note: this workshop runs from 9:00 until 16:00. Buy

Instructor

David Neal Principal Developer Evangelist @ Pluralsight, Microsoft MVP