Clean Code

Learn how to write readable, understandable and therefore maintainable code – step by step, in an example-driven way
Clean Code
File Size :
2.16 GB
Total length :
6h 41m



Academind by Maximilian Schwarzmüller


Last update

Last updated 11/2022



Clean Code

What you’ll learn

Learn how to write code which is readable and understandable
Keep code alive by increasing maintainability with clean code
Learn about key principles, rules and concepts that allow you to write clean code
Learn with hands-on examples and “bad to good code” transformations

Clean Code


Basic programming knowledge (no matter which language) is required
NO prior experience on the topic of clean code is required
You DON’T need to know a specific programming language or paradigm


As a developer, you should be able to write code which works – of course!Unfortunately, a lot of developers write bad code nonetheless – even though the code works. Because “working code” is not the same as “clean code”!This course teaches you how to write clean code – code which is easy to read and understand by humans, not just computers!In this course, you’ll learn what exactly clean code is and, more importantly, how you can write clean code. Because if your code is written in a clean way, it’s easier to read and understand and therefore easier to maintain. Because it’s NOT just the computer who needs to understand your code – your colleagues and your future self needs to be able to understand it as well!In this course, we’ll dive into all the main “pain points” related to clean code (or bad code – depending on how you look at it) and you will not just learn what makes up bad code but of course also how to turn it into clean code.Specifically, you will learn about:Naming “things” (variables, properties, classes, functions, …) properly and in a clean wayCommon pitfalls and mistakes you should avoid when naming thingsComments and that most of them are badGood comments you might consider adding to your codeCode formatting – both horizontal and vertical formattingFunctions and how to limit the number of function parametersHow to write clean functions by focusing on “one thing”How levels of abstraction help you split functions and keep them smallHow to write DRY functions and avoid unexpected side effectsAvoiding deeply nested control structures with guards and by extracting functionality into functionsErrors and error handling as a replacement for if-statementsObjects & data containers/ data structures and why that differentiation could matterCohesion and how to write good (small!) classesThe Law of Demeter and why it matters for clean codeWhat the SOLID principles are and why they matter when it comes to writing clean codeMuch more!This course is a compilation of common patterns, best practices, principles and rules related to writing clean code.In this course, you’ll learn about a broad variety of concepts, rules, ideas, thoughts and principles and by the end of course, you’ll have a good idea of what to keep in mind when it comes to writing clean code.This is not a design patterns or general patterns course though – we will entirely focus on patterns, rules and concepts that help with writing clean code specifically.All these concepts and rules are backed up by examples, code snippets and demos. And to ensure that you get the most out of this course, and you don’t just learn a bunch of theory which you forget soon after, there also are plenty of challenges for you to apply what you learned!This course uses Python, JavaScript and TypeScript for code examples but you don’t need to know these languages to follow along and get a lot out of the course. In addition, the course does not focus on a specific programming style or paradigm (like functional programming, object-oriented programming etc) but instead covers general concepts and techniques which will always apply.What are the course prerequisites?Basic programming knowledge (no matter which language) is required!You don’t need to know any specific programming language or programming paradigm to follow alongNO prior experience with writing clean code is required


Section 1: Getting Started

Lecture 1 Welcome to the Course!

Lecture 2 What is “Clean Code”?

Lecture 3 Clean Code – Key Pain Points & How To Write Clean Code

Lecture 4 How Is This Course Structured?

Lecture 5 Course Prerequisites

Lecture 6 Clean Code & Strongly Typed Languages

Lecture 7 About The Course Code Examples

Lecture 8 Join Our Learning Community!

Lecture 9 Functional, OOP, Procedural: The Course Concepts Always Apply!

Lecture 10 Clean Code, Principles & Patterns & Clean Architecture

Lecture 11 Clean Code vs Quick Code

Lecture 12 Module & Course Resources

Section 2: Naming – Assigning Names to Variables, Functions, Classes & More

Lecture 13 Module Introduction

Lecture 14 Why Good Names Matter

Lecture 15 Choosing Good Names

Lecture 16 Casing Conventions & Programming Languages

Lecture 17 Naming Variables & Properties – Theory

Lecture 18 Naming Variables & Properties – Examples

Lecture 19 Naming Functions & Methods – Theory

Lecture 20 Naming Functions & Methods – Examples

Lecture 21 Naming Classes – Theory

Lecture 22 Naming Classes – Examples

Lecture 23 Exceptions You Should Be Aware Of

Lecture 24 Common Errors & Pitfalls

Lecture 25 Demo Time!

Lecture 26 Your Challenge – Problem

Lecture 27 Your Challenge – Solution

Lecture 28 Module Resources

Section 3: Code Structure, Comments & Formatting

Lecture 29 Module Introduction

Lecture 30 Bad Comments

Lecture 31 Good Comments

Lecture 32 What is “Code Formatting” Really About?

Lecture 33 Vertical Formatting

Lecture 34 Formatting: Language-specific Considerations

Lecture 35 Horizontal Formatting

Lecture 36 Your Challenge – Problem

Lecture 37 Your Challenge – Solution

Lecture 38 Module Resources

Section 4: Functions & Methods

Lecture 39 Module Introduction

Lecture 40 Analyzing Key Function Parts

Lecture 41 Keep The Number Of Parameters Low!

Lecture 42 Refactoring Function Parameters – Ideas & Concepts

Lecture 43 When One Parameter Is Just Right

Lecture 44 Two Parameters & When To Refactor

Lecture 45 Dealing With Too Many Values

Lecture 46 Functions With A Dynamic Number Of Parameters

Lecture 47 Beware Of “Output Parameters”

Lecture 48 Functions Should Be Small & Do One Thing!

Lecture 49 Why “Levels of Abstraction” Matter

Lecture 50 When Should You Split?

Lecture 51 Demo & Challenge

Lecture 52 Stay DRY – Don’t Repeat Yourself

Lecture 53 Splitting Functions To Stay DRY

Lecture 54 Don’t Overdo It – Avoid Useless Extractions

Lecture 55 Understanding & Avoiding (Unexpected) Side Effects

Lecture 56 Side Effects – A Challenge

Lecture 57 Why Unit Tests Matter & Help A Lot!

Lecture 58 Module Resources

Section 5: Control Structures & Errors

Lecture 59 Module Introduction

Lecture 60 Useful Concepts – An Overview

Lecture 61 Introducing “Guards”

Lecture 62 Guards In Action

Lecture 63 Extracting Control Structures & Preferring Positive Phrasing

Lecture 64 Extracting Control Structures Into Functions

Lecture 65 Writing Clean Functions With Control Structures

Lecture 66 Inverting Conditional Logic

Lecture 67 Embrace Errors & Error Handling

Lecture 68 Creating More Error Guards

Lecture 69 Extracting Validation Code

Lecture 70 Error Handling Is One Thing!

Lecture 71 Using Factory Functions & Polymorphism

Lecture 72 Working with Default Parameters

Lecture 73 Avoid “Magic Numbers & Strings”

Lecture 74 Module Summary

Lecture 75 Module Resources

Section 6: Objects, Classes & Data Containers / Structures

Lecture 76 Module Introduction

Lecture 77 Important: This is NOT an OOP or “Patterns & Principles” Course!

Lecture 78 Objects vs Data Containers / Data Structures

Lecture 79 Why The Differentiation Matters

Lecture 80 Classes & Polymorphism

Lecture 81 Classes Should Be Small!

Lecture 82 Understanding “Cohesion”

Lecture 83 The “Law Of Demeter” And Why You Should “Tell, Not Ask”

Lecture 84 The SOLID Principles

Lecture 85 The Single-Responsibility-Principle (SRP) & Why It Matters

Lecture 86 The Open-Closed Principle (OCP) & Why It Matters

Lecture 87 The Liskov Substitution Principle

Lecture 88 The Interface Segregation Principle

Lecture 89 The Dependency Inversion Principle

Lecture 90 Module Resources

Section 7: Summary & Checklist

Lecture 91 Concepts Summary & Checklist

Section 8: Course Roundup

Lecture 92 Staying Clean!

Lecture 93 Possible Next Steps

Lecture 94 Course Roundup

Lecture 95 Bonus!

Developers who want to ensure that their code does not just work but it also easy to read, understand and maintain,Everyone who’s serious about development and writing real-life code

Course Information:

Udemy | English | 6h 41m | 2.16 GB
Created by: Academind by Maximilian Schwarzmüller

You Can See More Courses in the Developer >> Greetings from

New Courses

Scroll to Top