Autoplay
Autocomplete
Previous Lesson
Complete and Continue
Clean Code
Getting Started
Welcome to the Course! (2:27)
What is "Clean Code"? (5:57)
Clean Code - Key Pain Points & How To Write Clean Code (3:31)
How Is This Course Structured? (1:22)
Course Prerequisites (3:16)
Clean Code & Strongly Typed Languages (2:31)
About The Course Code Examples (2:04)
Functional, OOP, Procedural: The Course Concepts Always Apply! (1:29)
Clean Code, Principles & Patterns & Clean Architecture (3:17)
Clean Code vs Quick Code (5:01)
Module & Course Resources
The Academind Pro Referral Program
Naming - Assigning Names to Variables, Functions, Classes & More
Module Introduction (1:01)
Why Good Names Matter (3:23)
Choosing Good Names (4:03)
Casing Conventions & Programming Languages (3:07)
Naming Variables & Properties - Theory (3:48)
Naming Variables & Properties - Examples (4:44)
Naming Functions & Methods - Theory (2:36)
Naming Functions & Methods - Examples (3:10)
Naming Classes - Theory (1:56)
Naming Classes - Examples (2:34)
Exceptions You Should Be Aware Of (6:24)
Common Errors & Pitfalls (7:50)
Demo Time! (10:29)
Your Challenge - Problem (1:11)
Your Challenge - Solution (10:01)
Module Resources
Code Structure, Comments & Formatting
Module Introduction (1:06)
Bad Comments (3:52)
Good Comments (3:50)
What is "Code Formatting" Really About? (2:26)
Vertical Formatting (8:03)
Formatting: Language-specific Considerations (2:03)
Horizontal Formatting (3:36)
Your Challenge - Problem (1:01)
Your Challenge - Solution (6:19)
Module Resources
Functions & Methods
Module Introduction (1:12)
Analyzing Key Function Parts (1:38)
Keep The Number Of Parameters Low! (6:38)
Refactoring Function Parameters - Ideas & Concepts (3:43)
When One Parameter Is Just Right (2:12)
Two Parameters & When To Refactor (4:07)
Dealing With Too Many Values (4:26)
Functions With A Dynamic Number Of Parameters (2:41)
Beware Of "Output Parameters" (4:19)
Functions Should Do One Thing! (9:51)
Why "Levels of Abstraction" Matter (6:11)
When Should You Split? (2:51)
Demo & Challenge (13:09)
Stay DRY - Don't Repeat Yourself (2:03)
Splitting Functions To Stay DRY (5:41)
Don't Overdo It - Avoid Useless Extractions (6:51)
Understanding & Avoiding (Unexpected) Side Effects (12:01)
Side Effects - A Challenge (9:21)
Why Unit Tests Matter & Help A Lot! (6:15)
Module Resources
Control Structures & Errors
Module Introduction (2:52)
Useful Concepts - An Overview (1:22)
Introducing "Guards" (2:53)
Guards In Action (6:33)
Extracting Control Structures & Preferring Positive Phrasing (3:17)
Extracting Control Structures Into Functions (4:03)
Writing Clean Functions With Control Structures (7:32)
Inverting Conditional Logic (8:07)
Embrace Errors & Error Handling (6:57)
Creating More Error Guards (4:27)
Extracting Validation Code (4:10)
Error Handling Is One Thing! (3:35)
Using Factory Functions & Polymorphism (8:56)
Working with Default Parameters (1:14)
Avoid Magic Numbers & Strings
Module Summary (3:37)
Module Resources
Objects, Classes & Data Containers / Structures
Module Introduction (1:42)
Important: This is NOT an OOP or "Patterns & Principles" Course! (2:14)
Objects vs Data Containers / Data Structures (4:10)
Why The Differentiation Matters (3:57)
Classes & Polymorphism (12:54)
Classes Should Be Small! (6:20)
Understanding "Cohesion" (4:49)
The "Law Of Demeter" And Why You Should "Tell, Not Ask" (11:40)
The SOLID Principles (2:05)
The Single-Responsibility-Principle (SRP) & Why It Matters (7:04)
The Open-Closed Principle (OCP) & Why It Matters (5:43)
The Liskov Substitution Principle (5:56)
The Interface Segregation Principle (4:18)
The Dependency Inversion Principle (7:00)
Module Resources
Summary & Checklist
Concepts Summary & Checklist (9:05)
Course Roundup
Staying Clean! (2:56)
Possible Next Steps (2:43)
Thanks & Goodbye! (1:14)
Bonus!
Clean Code, Principles & Patterns & Clean Architecture
Download
Complete and Continue