CF

Clean Code: Writing Code for Humans

3h 10m 36s
English
Paid

Clean Code: Writing Code for Humans is a 91-lesson 3 hours 10 minutes self-paced course by Pluralsight. Anyone can write code a computer can understand, but professional developers write code *humans* can understand.

Course facts

Lessons
91
Duration
3 hours 10 minutes
Level
All levels
Language
English
Updated
Instructor
Pluralsight
Price
Premium

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.

Who teaches Clean Code: Writing Code for Humans? Pluralsight

Pluralsight thumbnail

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.

What lessons are included in Clean Code: Writing Code for Humans?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 91 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction
All Course Lessons (91)
#Lesson TitleDurationAccess
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 subscription

What courses are similar to Clean Code: Writing Code for Humans?

More courses by Pluralsight

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.