Skip to content
New this month 24 fresh C++, C#, F#, JavaScript, TypeScript and Lua courses just landed. Browse new releases Use code WELCOME10 for 10% off your first order · 14-day refund
WisdomCharms — home
Cart 0 items in cart
Programming Languages All levels

Clean Code in Practice: Naming, Boundaries and Safe Refactoring

Improve messy code without breaking it, using small moves you can defend in review.

Rated 5.0 out of 5 from 2 reviews 31 students

TE Created by Tom Eriksen

  • Last updated August 2026
  • English
  • 3h 6m of material
  • 23 lessons

What you will learn

8 concrete outcomes

Every bullet below is something you will have built, shipped or be able to explain by the time you finish the last lesson.

  • Name functions, variables and types so that comments become unnecessary
  • Identify the code smells that reliably predict defects and rework
  • Apply extract function, parameter object and guard clauses as verified small steps
  • Write characterisation tests before changing code you do not understand
  • Reduce nesting and conditional complexity without inventing abstractions
  • Keep refactoring commits small, reviewable and individually revertible
  • Apply the strangler pattern to replace a subsystem gradually
  • Give and receive code review feedback that improves code rather than morale

Course curriculum

5 modules · 23 lessons · 3h 6m of material

5 lessons running 40m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

5 lessons running 38m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

5 lessons running 42m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

4 lessons running 32m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

4 lessons running 34m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

5 modules · 23 lessons

3h 6m total length

Requirements

Short list, and deliberately so. If you meet these you can start today.

  • Experience writing code in any language; examples use TypeScript and C#
  • Access to a codebase of your own to practise on, ideally an imperfect one

About this course

Most clean code advice is either a list of rules with no context or a philosophy with no code. This course is neither. It works through realistic messy code, functions that are too long, classes that know too much, conditionals nested five deep, and improves them step by step with named refactorings you can point at during review.

The first half is about reading. You learn to spot the specific smells that predict future defects: unclear names, boolean parameters, primitive obsession, feature envy, shotgun surgery and temporal coupling. Each smell is paired with the refactoring that resolves it, extract function, introduce parameter object, replace conditional with polymorphism, guard clauses, and the mechanics of each are shown as small verified steps rather than a rewrite.

The second half covers doing this safely in a real codebase: adding characterisation tests before touching legacy code, using the compiler and type system as a refactoring tool, keeping commits small enough to revert, the strangler pattern for gradual replacement, and how to raise these changes in code review without sounding like a style pedant. Examples appear in TypeScript and C#, and the principles are language-neutral.

Topics covered

Frequently asked questions

Still unsure about something? Write to misteryjj100@gmail.com and a human answers, usually the same working day.

No. The examples are readable to anyone with general programming experience, and every technique is stated language-neutrally before the code appears.

No. It borrows the vocabulary of refactoring literature but focuses on mechanics and safety in existing codebases, including the parts that popular advice gets wrong.

That is a specific goal. The final module covers phrasing feedback so that suggestions land as improvements rather than as criticism.

Checkout is handled on our provider's secure payment page. The moment your payment clears we email your personal access link and access code to the address you used at checkout, and the same link appears in your account library. There is nothing to install and nothing to wait for.

Email misteryjj100@gmail.com within 14 days of your purchase, quote your order number, and we refund the full amount to your original payment method. No form to fill in and no questions about how much of the course you watched.

What students say

Reviews are written by people who bought this course. We publish the critical ones too.

5.0

Rated 5.0 out of 5

Course rating · 2 reviews

Rating distribution

  • 5 stars 100%
  • 4 stars 0%
  • 3 stars 0%
  • 2 stars 0%
  • 1 star 0%
  • RF

    Ronan Fitzgerald

    Senior developer

    Mar 2026
    Rated 5.0 out of 5

    Characterisation tests unlocked our worst module

    We had a billing file nobody would touch. Pinning down its current behaviour first, including the parts we suspected were wrong, is what finally let us refactor it without a fortnight of regression hunting afterwards.
  • LB

    Lena Brandt

    Tech lead

    Nov 2025
    Rated 5.0 out of 5

    Never more than one thing broken at once

    That discipline sounds obvious written down and is emphatically not how anyone I work with operates. Watching a large extraction performed across eleven commits, every one of them green, was the most instructive twenty minutes in the course.

Your instructor

TE

Tom Eriksen

Platform engineer and DevOps instructor

  • 219 students taught
  • 13 courses published
  • 4.8 instructor rating
  • Docker
  • Kubernetes
  • CI/CD
  • Testing and tooling

Tom has built delivery pipelines for teams of three and teams of three hundred, and openly prefers the smaller ones. He teaches Docker, Kubernetes and CI/CD outward from a single commit, so nothing ever appears by magic, and he treats the test suite as part of the pipeline rather than a separate subject. Every course includes a deliberate outage that you have to diagnose from logs and metrics before you can continue. He is a CNCF contributor and a reluctant but formidable YAML expert.

See every course by Tom Eriksen
$15 USD

One-time payment · lifetime access

The WisdomCharms dispatch

One useful email a week. No fluff, no spam.

New course releases, discount codes before anyone else, and a short, practical breakdown of one technique — a prompt pattern, a C++ idiom, a TypeScript trick — that you can use the same day.

  • Subscriber-only launch pricing
  • Unsubscribe in one click
  • We never sell your address

By subscribing you agree to our Privacy Policy. Questions? Write to misteryjj100@gmail.com.