English | MP4 | AVC 1920×1080 | AAC 48KHz 2ch | 96 lectures (6h 42m) | 2.25 GB
Learn how to write readable, understandable and therefore maintainable code – step by step, in an example-driven way
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 way
- Common pitfalls and mistakes you should avoid when naming things
- Comments and that most of them are bad
- Good comments you might consider adding to your code
- Code formatting – both horizontal and vertical formatting
- Functions and how to limit the number of function parameters
- How to write clean functions by focusing on “one thing”
- How levels of abstraction help you split functions and keep them small
- How to write DRY functions and avoid unexpected side effects
- Avoiding deeply nested control structures with guards and by extracting functionality into functions
- Errors and error handling as a replacement for if-statements
- Objects & data containers/ data structures and why that differentiation could matter
- Cohesion and how to write good (small!) classes
- The Law of Demeter and why it matters for clean code
- What the SOLID principles are and why they matter when it comes to writing clean code
- Much 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 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
Table of Contents
Getting Started
1 Welcome to the Course
2 What is Clean Code
3 Clean Code – Key Pain Points and How To Write Clean Code
4 How Is This Course Structured
5 Course Prerequisites
6 Clean Code and Strongly Typed Languages
7 About The Course Code Examples
8 Join Our Learning Community
9 Functional OOP Procedural The Course Concepts Always Apply
10 Clean Code Principles and Patterns and Clean Architecture
11 Clean Code vs Quick Code
12 Module and Course Resources
13 Course Setup
Naming – Assigning Names to Variables Functions Classes and More
14 Module Introduction
15 Why Good Names Matter
16 Choosing Good Names
17 Casing Conventions and Programming Languages
18 Naming Variables and Properties – Theory
19 Naming Variables and Properties – Examples
20 Naming Functions and Methods – Theory
21 Naming Functions and Methods – Examples
22 Naming Classes – Theory
23 Naming Classes – Examples
24 Exceptions You Should Be Aware Of
25 Common Errors and Pitfalls
26 Demo Time
27 Your Challenge – Problem
28 Your Challenge – Solution
29 Module Resources
Code Structure Comments and Formatting
30 Module Introduction
31 Bad Comments
32 Good Comments
33 What is Code Formatting Really About
34 Vertical Formatting
35 Formatting Language-specific Considerations
36 Horizontal Formatting
37 Your Challenge – Problem
38 Your Challenge – Solution
39 Module Resources
Functions and Methods
40 Module Introduction
41 Analyzing Key Function Parts
42 Keep The Number Of Parameters Low
43 Refactoring Function Parameters – Ideas and Concepts
44 When One Parameter Is Just Right
45 Two Parameters and When To Refactor
46 Dealing With Too Many Values
47 Functions With A Dynamic Number Of Parameters
48 Beware Of Output Parameters
49 Functions Should Be Small and Do One Thing
50 Why Levels of Abstraction Matter
51 When Should You Split
52 Demo and Challenge
53 Stay DRY – Dont Repeat Yourself
54 Splitting Functions To Stay DRY
55 Dont Overdo It – Avoid Useless Extractions
56 Understanding and Avoiding Unexpected Side Effects
57 Side Effects – A Challenge
58 Why Unit Tests Matter and Help A Lot
59 Module Resources
Control Structures and Errors
60 Module Introduction
61 Useful Concepts – An Overview
62 Introducing Guards
63 Guards In Action
64 Extracting Control Structures and Preferring Positive Phrasing
65 Extracting Control Structures Into Functions
66 Writing Clean Functions With Control Structures
67 Inverting Conditional Logic
68 Embrace Errors and Error Handling
69 Creating More Error Guards
70 Extracting Validation Code
71 Error Handling Is One Thing
72 Using Factory Functions and Polymorphism
73 Working with Default Parameters
74 Avoid Magic Numbers and Strings
75 Module Summary
76 Module Resources
Objects Classes and Data Containers – Structures
77 Module Introduction
78 Important This is NOT an OOP or Patterns and Principles Course
79 Objects vs Data Containers – Data Structures
80 Why The Differentiation Matters
81 Classes and Polymorphism
82 Classes Should Be Small
83 Understanding Cohesion
84 The Law Of Demeter And Why You Should Tell Not Ask
85 The SOLID Principles
86 The Single-Responsibility-Principle SRP and Why It Matters
87 The Open-Closed Principle OCP and Why It Matters
88 The Liskov Substitution Principle
89 The Interface Segregation Principle
90 The Dependency Inversion Principle
91 Module Resources
Summary and Checklist
92 Concepts Summary and Checklist
Course Roundup
93 Staying Clean
94 Possible Next Steps
95 Course Roundup
96 Bonus
Resolve the captcha to access the links!