All decks
  • 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, 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.