Using test pain as a design guide: DDD EU 2022

Automated testing is a necessary part of software development, we need it if we intend to release our software with confidence. The problem is that writing and maintaining tests can be a painful process, especially in legacy code. Tests become brittle and awkward to use over time. What we don't realise is that this pain is telling us how our system should be structured, we just need to listen. In this talk we'll discuss test structure, mocking and system design. We'll then take real testcases and show how we can apply tactical patterns to refactor and express the appropriate design, resulting in an application that is easier to understand and maintain from both a testing and business perspective.

Cleaning up as we go

Automatic refactoring tools

Short lightning talk and demo on how to use PHPStorms automatic refactoring tools

Using test pain as a design guide (2021)

Automated testing is a necessary part of software development, we need it if we intend to release our software with confidence. The problem is that writing and maintaining tests can be a painful process, especially in legacy code. Tests become brittle and awkward to use over time. What we don't realise is that this pain is telling us how our system should be structured, we just need to listen. In this talk we'll discuss test structure, mocking and system design. We'll then take real testcases and show how we can apply tactical patterns to refactor and express the appropriate design, resulting in an application that is easier to understand and maintain from both a testing and business perspective.

Refactoring legacy: Turning monsters into friends

Slides from my DDDEU 2021 hands on lab on working with legacy code. When people talk about legacy they tend to use aggressive language, they view it as a nightmare that everyone should just ignore and forget. This is entirely the wrong attitude to take and it guarantees failure. Legacy can be a friend that will teach you more about programming than any green field project ever will, it’s all about changing your mindset. This session will take you through the approach you need to succeed with refactoring legacy. You’ll learn how to shift your perspective and how to deal with the uncertainty that’s ever present when working in legacy. You’ll learn how to make changes safely, gain understanding and uncover suitable patterns to apply. This is a hands-on session were you’ll tackle a messy piece of code and apply three simple techniques to gain clarity. At the end you’ll be much more comfortable dealing with legacy code and will have both the techniques and the mindset required to improve your existing system. Code samples will be available in several languages, so you just need to bring your favourite IDE and an environment that can run the code. Prerequisites: A laptop that can edit and run Java, C# or JavaScript.

DDD EU 2020 - Scratching Refactoring: Unearthing your domain

How do you deal with code that you don't understand? Not all code is well structured and easy to digest, most code isn't. It is our job to take this code and make changes without introducing bugs, and this is by no means an easy task. To make things harder, we actually want to improve this messy code, to refactor it into something more manageable. Well, the good news is that this is possible, you just need a foothold of understanding in that code, and Scratch Refactoring is that foothold. Scratch Refactoring is a technique that help us navigate and understand messy code, it's about trying out changes to code without committing to them, changes that could otherwise be expensive. It allows us to explore code and domain models without breaking the underlying code. The goal isn't to rewrite, it's to explore mental models of the underlying domain. This is very powerful when working with difficult code. This workshop will focus on Scratch Refactoring and how to apply it. We'll discuss the concept, look at techniques we can use to accelerate the process, different strategies for gaining clarity, and how tactical DDD patterns can be applied to explore potential domain concepts. Then we will apply these ideas to code we've brought in ourselves. That's right, we'll try out Scratch Refactoring on our own problem space. This is a great way to try out the technique in a domain or codebase

Layering Your Application: Increasing Signal by Removing Noise

This is a small workshop that teaches developers DDD skills that will benefit them on a day to say basis. Rather than focussing on the tactical patterns (ValueObjects, Aggregates, Factories, etc . . .) we're instead going to focus on high level architecture and the various layers they can use. From this we can figure out where code belongs and how to structure our applications so that they're easier to understand and test. The workshop will be broken down into three parts: 1. Overview of an Onion Architecture and Ports and Adapters - What are your inputs and outputs? 2. Mapping the existing system - List out all the libraries, services, concepts used in your system, where do they live currently? 3. Separating the layers - Take the results above and categorise each of them, where do they belong? How would we layer them in an ideal world?

Scratching Refactoring: Unearthing your domain

Have you ever worked with a piece of code and thought "WTH is this thing even doing?!"? Something so messy and convoluted that your brain just gives up? Of course you have; dealing with this kind of code is just part of the job, but it's a part that we don't discuss anywhere near enough. That's why we're holding a workshop on how to deal with this kind of code, via a technique known as Scratch Refactoring. Scratch Refactoring is a way to explore potential designs in messy code. In this workshop we'll explore how it can be applied to unearth domain concepts hidden in your application. We'll discuss practical real world techniques, which we will then apply to code we've brought in ourselves. That's right, we'll try out Scratch Refactoring then and there! DDD practitioners will be on hand to help. Afterwards we'll review our results and discuss what we've discovered.

Introducing DDD to your company: Roleplaying

Introducing DDD to your Company

DDD is about enabling developers and business owners to work together on a collaborative model, but how do you introduce the concept? In a world rife with acronyms, people can be hesitant to try out new ideas, especially one's that involve changing the status quo. In this meetup we'll discuss various techniques and ideas for introducing DDD to an organisation. Participants will be encouraged to discuss their experiences and the issues they've faced. DDD practitioners will be there to facilitate and offer advice. Afterwards you'll be better able to demonstrate the value of DDD to stakeholders, without scaring them off with a load of new jargon.

Event Storming Workshop: Building Noteworthy

Fresh from the experience of building Noteworthy.ie, we will be leveraging organiser Barry O'Sullivan's experience in using Event Storming to build a real software product. In previous meetups we have used Event Storming to show how we can discover and model an existing business domain. In this session, we will imagine back to the first concept stages of Noteworthy and use Event Storming to help turn a concept into a reality (actual software). This will be a hands-on session that will include participation from all attendees. At the end of the session we can reflect on where our Model finishes, and find out from Barry what actually ended up being built.

Event Storming Workshop

Mapping Constraints

How do we define the constraints of our system? A simple question, but one we often get wrong. Too often we model constraints mechanically rather than exploring and challenging them. This leads to brittle systems and bloated software. How do we move past this? This talk is an exploration of the very concept of constraints and how they affect the systems we build. We're going to look at the different types of constraints and the impact they have over time. We'll explore techniques we can use to map, define and refine these constraints, elevating what's important and dropping everything else. We'll also look at legacy, organisational and meta-system constraints and how they impact what we build and how we build it. Mapping constraints is core to what we do, let's get better at it.

The Apocalypse Meme in Software | DDD EU 2019

A lightning talk on the origins of the apocalypse meme and how it affects software today.

Applying DDD to your Business

Making your Career Happen

WTF is DDD

An explanation of DDD for both business owners and developers, explained with a hint of Irishness.

Tactical Patterns for Testable Applications

Testing is core to being a professional developer, it's one of main tools we use to design systems and prove they work. The thing is though, it's tricky to do. Tests are code and code must be maintained. So how do you test your code in a way that doesn't hamper change? That's the focus of this talk, a series of tactical design patterns that can applied to write testable applications.

Workshop: Using Interfaces Effectively

Slides to introduce the concepts of interfaces and the following workshop challenges.