Anyone can write code a computer can understand, but professional developers write code *humans* can understand. Clean code is a reader-focused development style that produces software that's easy to write, read and maintain.
Clean Code: Writing Code for Humans
3h 10m 36s
English
Paid
About the Author: Pluralsight
Pluralsight is one of the largest enterprise-focused online technology training platforms in the world, founded in 2004 by Aaron Skonnard and acquired by Vista Equity Partners in 2021. The platform has historically been the dominant choice for corporate IT training, with a catalog of over 7,000 courses covering software development, IT operations, security, data, and cloud across virtually every major vendor and open-source platform.
The instructor roster includes Microsoft Regional Directors, AWS / Azure / GCP MVPs, and named experts in essentially every active technology track. Course material is structured for the corporate-training market: each course covers a specific skill at a defined depth, and Pluralsight's role-based learning paths are widely used by enterprises for upskilling engineering teams.
The CourseFlix listing under this source carries 12 Pluralsight courses — a small slice of the broader platform's catalog. Material is paid; Pluralsight itself runs on a monthly / annual subscription on the original platform, with Pluralsight Skills (individual) and Pluralsight Flow (engineering analytics) as the main product lines.
Watch Online 91 lessons
0:00
/ #1: Introduction
All Course Lessons (91)
| # | Lesson Title | Duration | Access |
|---|---|---|---|
| 1 | Introduction Demo | 02:05 | |
| 2 | Why should I care | 03:26 | |
| 3 | The Foundation | 02:10 | |
| 4 | We are Authors | 02:33 | |
| 5 | Conventions | 00:56 | |
| 6 | Resources | 01:12 | |
| 7 | Three Core Principles | 02:01 | |
| 8 | The Right Tool for The Job | 01:51 | |
| 9 | Boundaries Matter Stay Native | 06:47 | |
| 10 | Potential Evil | 01:01 | |
| 11 | Signal to Noise Ratio | 03:22 | |
| 12 | DRY Principle | 02:19 | |
| 13 | Self-documenting Code | 01:38 | |
| 14 | Principles. Summary | 00:46 | |
| 15 | Naming. Introduction | 00:33 | |
| 16 | Naming Matters | 02:07 | |
| 17 | Classes | 03:46 | |
| 18 | Methods | 02:15 | |
| 19 | Rubber Ducking | 01:09 | |
| 20 | Warning Signs | 00:32 | |
| 21 | Side Effects | 00:50 | |
| 22 | Abbreviations | 01:39 | |
| 23 | Booleans | 01:14 | |
| 24 | Symmetry | 00:59 | |
| 25 | Naming. Summary | 00:56 | |
| 26 | Conditionals. Introduction | 02:19 | |
| 27 | Boolean Comparisons | 00:36 | |
| 28 | Boolean Assignments | 02:03 | |
| 29 | Positive Conditionals | 01:31 | |
| 30 | Ternary Elegance | 02:37 | |
| 31 | Stringly Typed | 02:51 | |
| 32 | Magic Numbers | 02:07 | |
| 33 | Complex Conditionals | 04:16 | |
| 34 | Polymorphism vs Enums | 02:16 | |
| 35 | Be Declarative | 02:45 | |
| 36 | Table Driven Methods | 02:39 | |
| 37 | Conditionals. Summary | 00:35 | |
| 38 | Functions. Intro | 01:14 | |
| 39 | When to Create A Function | 01:44 | |
| 40 | Avoid Duplication | 01:06 | |
| 41 | Excessive Indentation Overview | 01:16 | |
| 42 | Extract Method | 02:24 | |
| 43 | Return Early | 01:57 | |
| 44 | Fail Fast | 02:18 | |
| 45 | Convey Intent | 01:32 | |
| 46 | Do One Thing | 01:13 | |
| 47 | Mayfly Variables | 02:00 | |
| 48 | Parameters | 01:41 | |
| 49 | What's Too Long | 03:11 | |
| 50 | Exceptions | 04:00 | |
| 51 | Functions. Summary | 01:11 | |
| 52 | Classes. Intro | 01:23 | |
| 53 | When to Create | 02:45 | |
| 54 | Cohesion | 06:57 | |
| 55 | When is A Class too Small | 01:19 | |
| 56 | Primitive Obsession | 01:54 | |
| 57 | Principle of Proximity | 01:13 | |
| 58 | Outline Rule | 02:18 | |
| 59 | Classes. Summary | 00:54 | |
| 60 | Comments. Introduction | 01:43 | |
| 61 | Necessity and Crutch | 00:55 | |
| 62 | Redundant | 01:58 | |
| 63 | Intent | 00:49 | |
| 64 | Apologies and Warnings | 01:31 | |
| 65 | Zombie Code | 07:25 | |
| 66 | Dividers and Brace Trackers | 01:18 | |
| 67 | Bloated Header | 00:55 | |
| 68 | Defect Log | 00:41 | |
| 69 | Clean Comments | 02:53 | |
| 70 | Comments. Summary | 01:10 | |
| 71 | Demo. Introduction | 04:53 | |
| 72 | Registration Overview | 02:07 | |
| 73 | Code Metrics | 01:21 | |
| 74 | Automated Tests | 00:50 | |
| 75 | Comments | 02:14 | |
| 76 | Mayfly Variables | 03:01 | |
| 77 | Guard Clause | 02:08 | |
| 78 | Naming Issues | 01:10 | |
| 79 | Returning Early | 03:47 | |
| 80 | Refactor Red Flags | 02:59 | |
| 81 | Consolidate Guards and Clarify Intent | 05:45 | |
| 82 | Table Driven Method and Fail Fast | 01:28 | |
| 83 | Outline Rule | 02:58 | |
| 84 | Regression Test | 01:55 | |
| 85 | Bug Fixes What a contrast! | 02:06 | |
| 86 | Code Metric Results and Conclusions | 03:10 | |
| 87 | When to Refactor | 02:57 | |
| 88 | Broken Windows | 01:05 | |
| 89 | Code Reviews & Pair Programming | 01:32 | |
| 90 | Boy Scout Rule | 00:23 | |
| 91 | Stay clean. Conclusion | 01:17 |
Unlock unlimited learning
Get instant access to all 90 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.
Learn more about subscriptionRelated courses
-
Updated 2y agoMaster System Design and Design Pattern
By: UdemyThis course explains all the deep concepts of scalable system design problems and design patterns. These problems are frequently asked during interviews.11h 33m5/5 -
Updated 2y agoFundamentals of Backend Communications and Protocols
By: UdemyBackend engineering is an art. During my 18 years career working with and building backend applications, I discovered that certain communication design patterns15h 35m -
Updated 1mo agoDistributed Systems
By: Oz Nova (CS Primer)Discover the world of distributed systems - a dynamic field where the evolution of multiple computers has transformed both quantity and distribution.19h 12m
Frequently asked questions
What prerequisites should I have before taking this course?
Before enrolling in this course, you should have a fundamental understanding of programming concepts. Familiarity with basic coding principles and experience in writing code will help you grasp the clean code practices discussed. The course is designed for professional developers who want to improve the readability and maintainability of their code.
What kind of projects or exercises will I work on in this course?
The course focuses on various exercises and concepts like the DRY Principle, self-documenting code, and table-driven methods. These exercises are aimed at refining existing code to make it more understandable and maintainable. You'll engage with topics such as naming conventions, function creation, and managing conditionals to practice writing clean code.
Who is the target audience for this course?
This course is ideal for professional developers who aim to enhance their coding skills by focusing on writing code that is easy for humans to understand. It is particularly beneficial for those looking to improve their software development process by creating more readable and maintainable code.
How does this course compare in depth and scope to other courses on coding practices?
The course offers a thorough exploration of clean code principles with 91 lessons covering a wide range of topics including naming conventions, methods, classes, and conditionals. While some courses may focus on specific programming languages or tools, this course emphasizes universal principles applicable across various programming environments.
What specific tools or platforms are covered in this course?
The course primarily focuses on coding principles rather than specific tools or platforms. Lessons such as 'The Right Tool for The Job' and 'Boundaries Matter Stay Native' guide you on choosing the right tools and maintaining native boundaries within your code.
What topics are not covered in this course?
While the course extensively covers clean coding practices, it does not focus on advanced algorithms, data structures, or specific programming languages. The emphasis is on improving code readability and maintainability rather than deep-diving into technical programming constructs.
What is the expected time commitment for completing this course?
The course includes 91 lessons, which suggests a substantial time commitment to fully engage with the material. Although the exact runtime is not specified, prospective students should be prepared to dedicate sufficient time to practice and internalize the clean coding principles presented.