Before we Begin
Think about a piece of code you:
- Don't understand
- Want to change
Write it down.
We're going to work on that later!
Work Code
OSS Project
Scratch Refactoring to Understand: Unearthing your Domain
@barryosull
Scratch Refactoring to Understand: Unearthing your Domain
- Web Developer
- Contractor/Architect/Consultant
- Specialise in Legacy Web Apps
- Insanely good at Mario Kart
- DDD IE Organiser
- PHP Dublin Organiser
@barryosull
Barry O Sullivan
About me
- The difficulties of existing code
- Why it's difficult
- Scratch Refactoring
- Techniques
- Scratch Refactoring Session
Session Structure
Existing Code
How we want to write code
- Plan desired change to system
- Estimate it
- Look through the codebase
- Figure out where we need to change
- Make the change
- Verify it
How we actually write code
- Plan desired change to system
- Estimate it
- Look through the codebase
- Realise we don't understand it at all
- ** PANIC **
- Guess at where we need to change
- Hack it in
- Attempt to verify it (happy path only)
- Fix inevitable bugs
Most Existing Code is Hard to Understand
System Understanding
Developer
Knowledge
Useful
Abstractions
Accidental
Complication
x
%
(
)
Scratch Refactoring
Refactor a piece of code without worrying about it running.
The goal is to explore the code and gain understanding, not to write working code.
Scratch Refactoring
Refactor
Trash it
Where it's from
Different Perspectives
DDD Perspectives
Factory
Service
Repo
Value
Object
Entity
Constraint
- See which concepts work and which don't
- Spotted what's muddying the water
- An idea on how to isolate concepts
- Able to plan an iterative step forward
The End Results
Real World Example
public function save($class_name, $post, $id)
$rc = new \ReflectionClass("\\Elections\\". $class_name . "Director");
$director = $rc->newInstanceArgs(array($id));
Party
Director
Party
Builder
Party
Factory
Repo
Entity
Constraint
HTTP
Techniques
- Rename vars/methods/classes
- Private method extraction
- Extract Conditionals
- Extract Factories
- Extract Infrastructure
- DB / API Calls / Filesystem
- Extract Input
- HTTP / Message / Console
Tactical Techniques
- Extract ValueObjects
- Extract Entities
- Pretend a Class Exists
- Create Class inline
- Inline Abstractions
- Abstract class / Method calls
Useful Perspectives
Why are you changing this code?
Domain Language / Concepts
What is Input & Output
Driver
Adapters
Driven
Adapters
Application / Domain
- Lean on auto refactoring tools
- Describe the behaviour not the implementation
- Put like with like: Private vars, methods
- Focus on the code that matters, isolate and ignore the rest
- Do it in pairs/mobs
- Take notes of discoveries and concepts
- Scrap it all and start again, see where you end up!
+Scratch Refactoring Tips+
The Hands-on Session
Scratch Refactoring
- Find a messy piece of code and scratch refactor it
- Choose a technique, try it out for 30mins
- Reset, choose another and try that for 30mins
- Review: What's signal and what's noise
- Do it alone or in pairs
- If you don't have a laptop/code, pair up with someone
- Go mad, try out ideas and see where you get!
- No wrong answers, you can always start again
Increase Understanding
Increase Developer Knowledge by
Finding Consistent Patterns and
Diagnosing Accidental Complication
Through Scratch Refactoring
THX
@barryosull
DDD EU 2020 - Scratching Refactoring: Unearthing your domain
By Barry O' Sullivan
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
