You open a file, ready to make a small change and suddenly you’re staring at hundreds of lines of code that you can’t make much sense of...

One wrong move, and you’re worried the whole system might collapse. Maybe you’re relatively new to a codebase and you’ve felt that sinking feeling: “If I touch this, I’ll break it.” Or the frustration of spending hours trying to understand what the code is doing, only to end up more confused than when you started. For many developers, especially when faced with complex legacy systems, it’s not just about the code, there’s the anxiety, the hesitation, and the fear of introducing bugs that could slow the whole team down. You’re not alone in feeling this way, and the good news is, is that it doesn’t have to stay that way.

Refactoring Made Simple: Gain Control and Confidence.

This course will help you move from those feelings of anxiety and confusion in front of legacy code to feeling confident, capable, and in control of your work.

You’ll learn how to look at complicated code and actually understand it. Spotting opportunities for improvement, knowing what to change, and how to do it safely. Instead of feeling blocked by the systems you’re working on, you’ll gain the tools and mindset to turn them into something you can work with confidently and even be proud of. 

Refactoring will no longer feel mysterious. You’ll know exactly what it looks like, why it matters, and how to apply it with powerful tools you may not have used before. Along the way, you’ll develop design instincts that guard against poor practices and help you to improve your code so that it becomes “a more habitable space”, creating more room in your work for creativity and enhancing productivity. What we are all really here for.

By the end of the course, you won’t just understand refactoring, you’ll see it as a superpower. Work faster, with fewer errors, and with the confidence that you can improve even the most complex systems without fear of breaking everything.

Refactoring can and will unlock a new level of independence, skill, and pride in the work you produce as a developer.

Who Is This Course For?

This course is designed for developers who want to feel more in control of their code, especially when faced with complexity or with legacy systems. Whether you’re early in your career or building confidence with unfamiliar projects, this training will give you the tools to tackle code safely and effectively.


You’ll benefit most if you are:

- A junior or mid-level developer who wants to strengthen your refactoring skills and stand out on your team.


- Daunted by complex or legacy code and unsure how to change it without breaking things.


- Working in a startup or a new job, needing to deliver features quickly while dealing with unfamiliar codebases.


- Someone with limited exposure to refactoring, who wants to finally see it demonstrated properly and apply it hands-on.


- A developer looking to expand your toolkit and improve your ability to read, understand, and safely transform code.


- A manager looking to invest in your team’s growth, seeking practical, confidence-building training that helps engineers work faster with fewer bugs.


If you’ve ever opened a piece of code and thought “where do I even start?”. This course is built for you.

Key Benefits of Refactoring

  • Improved Readability and Maintainability

    Refactoring simplifies complex code, making it easier for developers to read, understand, and modify. This reduces the effort required for future maintenance and updates.

  • Reduced Technical Debt

    Eliminate "code smells" and other issues that accumulate over time, preventing the codebase from becoming hard to manage and costly to maintain.

  • Fewer Bugs and Defects

    By making the code cleaner and more efficient, refactoring makes it easier to find and fix bugs, and it can prevent new issues from being introduced during future development.

  • Enhanced Performance

    Streamlining code structures and eliminating inefficiencies can lead to better application performance.

  • Better System Design and Scalability

    A well-refactored codebase has a cleaner internal architecture, making it more adaptable to new requirements and easier to scale as the application grows.

  • Faster Development

    Developers spend less time navigating complex or tangled code, allowing them to implement new features and fix bugs more quickly.

  • Increased Developer Productivity

    Cleaner code reduces the cognitive load on developers, leading to higher productivity and better focus on new feature development and innovation.

  • Facilitates Onboarding

    New team members can understand the code more quickly, reducing the time and effort it takes for them to become productive.

  • Improved Code Reusability

    By breaking down complex code into smaller, well-defined components, refactoring creates more modular and reusable code snippets.

So, What's Involved In The Course?

This course comprises a series of short video lessons by Emily, guiding you through demonstartions and examples, in Java,  showing you the techniques you can apply to tackle the challenges you face. The exercises are manageable but powerful, giving you the opportunity to practice real techniques while seeing how an expert approaches the same problems.


You’ll not only learn what to do when confronted with complicated code, but also why these techniques work, helping you build lasting confidence in your development process.


What’s included in the course:

  • Learn directly from Emily’s list of code katas and see how an experienced developer  trainer tackles real refactoring challenges.

  • Access to all sample code on GitHub, so you can try techniques for yourself, hands-on.

  • Practical skills for dealing with unfamiliar or complex code: what to do when you don’t know where to start.

  • Techniques for extracting methods to improve readability and increasing maintainability.

  • Safe transformations to handle complex conditionals and simplify design.

  • Guidance on moving from procedural to object-oriented design.

  • Workflows to help you spot opportunities, apply changes incrementally, and feel confident and in control of the legacy code you’re faced with.


Course curriculum

    1. Course Introduction

      FREE PREVIEW

    2. IntelliJ access code - free offer from JetBrains

    3. Turning off your AI Assistant in IntelliJ

    1. Making Sense of Conditional Logic

    2. Initial 'scan' of Gilded Rose Code

    3. Practicalities: Getting the Code

    4. Code Reading: Folding

    5. Ensuring Adequate Test Coverage

    6. Initial Simplifications

    7. Manipulating Conditionals Safely

    8. Lift Up Conditional

    9. Lift Up Conditional on Gilded Rose

    10. Strategy So Far and Next Steps

    11. Alternative Option: Incremental Rewrite

    12. Gilded Rose Refactoring Quiz

    13. Gilded Rose Solution Summary

    14. Exercise: Conditionals Refactoring Practice

    15. Exercise: Gilded Rose Refactoring Kata

    1. Separate Intention from Implementation

    2. Scanning Tennis

    3. Code Reading with IDE Tools

    4. Extract Method on TennisGame6

    5. When and why to Extract Method

    6. Extract Method on TennisGame1

    7. Strategy Overview for Improving Unfamiliar Code

    8. Analysis of TennisGame2

    9. Improving TennisGame3

    10. Analysis of TennisGame4

    11. Improving TennisGame5

    12. Tennis Refactoring Quiz

    13. Chapter Summary

    14. Exercise: Tennis Refactoring Kata

    1. Replace Conditional with Object Oriented Design

    2. Initial Design Ideas

    3. Repeated Switches Design Smell

    4. Target Design: Polymorphism

    5. Replace Constructor with Factory Method

    6. Refactoring without Tools

    7. Create Subclasses

    8. Push Down Method

    9. Handling the Type field

    10. Refused Bequest Code Smell

    11. Lazy Element Code Smell

    12. Parrot Refactoring Quiz

    13. Chapter Summary

    14. Exercise: Parrot Refactoring Kata

    1. Separating Concerns

    2. Identifying Code Smells

    3. Divergent Change

    4. Creating Structural Separation

    5. Split Loop and Extract Method

    6. Split Phase: Introduce StatementData

    7. Split Phase: Move Logic

    8. Replace Loop with Pipeline

    9. Repeated Switches

    10. Theatrical Players Quiz

    11. Chapter Summary

    12. Exercise: Theatrical Players Refactoring Kata

    1. CONGRATULATIONS!!

    2. Find Emily on Social Media

About this course

  • £399.00
  • 60 lessons
  • 2.5 hours of video content

Start Learning Now

By the end of this course, you’ll have a whole new and concrete understanding of refactoring, and how to put it into practice confidently, no matter what codebase you’re working with.

Who Has Designed The Course?

Modern Software Engineering Expert Emily Bache

Emily Bache is an independent and experienced Technical Coach, and a pioneer of the Samman method for technical coaching. Alongside that accomplished coaching side to her work, Emily has over 25 years in the software engineering industry. In that time she has helped legions of developers and organisations alike develop essential modern software engineering skills around refactoring and test-driven development. Emily is also an author of 2 books that have been well received by ambitious software engineers, garnering strong reviews from developers at different stages of their career, and is a prominent presenter at software engineering conferences held across the globe. She is also one of the experts we are proud to host on the Modern Software Engineering channel.

Emily's Impact On Learners

CEO at 3T Software Labs

Peter Caron

Emily combines a high-level of technical knowledge and experience with sensitivity and understanding of the practical challenges developers face on a daily basis. This makes her an effective and rare kind of technical coach.

⭐⭐⭐⭐⭐

Sohnee, Amazon Review

“An indispensable companion for lead software developers and anyone who wants to run Coding Dojos. A great mix of theory and practical advice.”

Good Reads Review

4.48 Star Rated Book

Technical Agile Coaching with the Samman method By Emily Bache

Don't fear legacy code. Start mastering it with refactoring.

Get Started With Refactoring NOW

Get Full Access