HOT
blank

Clean Code

Development

Rating4.5
Enroll Now

Clean Code, available at $129.99, has an average rating of 4.51, with 97 lectures, based on 20053 reviews, and has 94411 subscribers.

You will learn about 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 This course is ideal for individuals who are Developers who want to ensure that their code does not just work but it also easy to read, understand and maintain or Everyone who's serious about development and writing real-life code It is particularly useful for Developers who want to ensure that their code does not just work but it also easy to read, understand and maintain or Everyone who's serious about development and writing real-life code.

Enroll now: Clean Code

Summary

Title: Clean Code

Price: $129.99

Average Rating: 4.51

Number of Lectures: 97

Number of Published Lectures: 96

Number of Curriculum Items: 97

Number of Published Curriculum Objects: 96

Original Price: $129.99

Quality Status: approved

Status: Live

What You Will 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

Who Should Attend

  • 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

Target Audiences

  • 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

As a developer, you should be able to write code which works – of course!

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 that 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 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 along

  • NO prior experience with writing clean code is required

Course Curriculum

Chapter 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

Lecture 13: Course Setup

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

Lecture 1: Module Introduction

Lecture 2: Why Good Names Matter

Lecture 3: Choosing Good Names

Lecture 4: Casing Conventions & Programming Languages

Lecture 5: Naming Variables & Properties – Theory

Lecture 6: Naming Variables & Properties – Examples

Lecture 7: Naming Functions & Methods – Theory

Lecture 8: Naming Functions & Methods – Examples

Lecture 9: Naming Classes – Theory

Lecture 10: Naming Classes – Examples

Lecture 11: Exceptions You Should Be Aware Of

Lecture 12: Common Errors & Pitfalls

Lecture 13: Demo Time!

Lecture 14: Your Challenge – Problem

Lecture 15: Your Challenge – Solution

Lecture 16: Module Resources

Chapter 3: Code Structure, Comments & Formatting

Lecture 1: Module Introduction

Lecture 2: Bad Comments

Lecture 3: Good Comments

Lecture 4: What is "Code Formatting" Really About?

Lecture 5: Vertical Formatting

Lecture 6: Formatting: Language-specific Considerations

Lecture 7: Horizontal Formatting

Lecture 8: Your Challenge – Problem

Lecture 9: Your Challenge – Solution

Lecture 10: Module Resources

Chapter 4: Functions & Methods

Lecture 1: Module Introduction

Lecture 2: Analyzing Key Function Parts

Lecture 3: Keep The Number Of Parameters Low!

Lecture 4: Refactoring Function Parameters – Ideas & Concepts

Lecture 5: When One Parameter Is Just Right

Lecture 6: Two Parameters & When To Refactor

Lecture 7: Dealing With Too Many Values

Lecture 8: Functions With A Dynamic Number Of Parameters

Lecture 9: Beware Of "Output Parameters"

Lecture 10: Functions Should Be Small & Do One Thing!

Lecture 11: Why "Levels of Abstraction" Matter

Lecture 12: When Should You Split?

Lecture 13: Demo & Challenge

Lecture 14: Stay DRY – Don't Repeat Yourself

Lecture 15: Splitting Functions To Stay DRY

Lecture 16: Don't Overdo It – Avoid Useless Extractions

Lecture 17: Understanding & Avoiding (Unexpected) Side Effects

Lecture 18: Side Effects – A Challenge

Lecture 19: Why Unit Tests Matter & Help A Lot!

Lecture 20: Module Resources

Chapter 5: Control Structures & Errors

Lecture 1: Module Introduction

Lecture 2: Useful Concepts – An Overview

Lecture 3: Introducing "Guards"

Lecture 4: Guards In Action

Lecture 5: Extracting Control Structures & Preferring Positive Phrasing

Lecture 6: Extracting Control Structures Into Functions

Lecture 7: Writing Clean Functions With Control Structures

Lecture 8: Inverting Conditional Logic

Lecture 9: Embrace Errors & Error Handling

Lecture 10: Creating More Error Guards

Lecture 11: Extracting Validation Code

Lecture 12: Error Handling Is One Thing!

Lecture 13: Using Factory Functions & Polymorphism

Lecture 14: Working with Default Parameters

Lecture 15: Avoid "Magic Numbers & Strings"

Lecture 16: Module Summary

Lecture 17: Module Resources

Chapter 6: Objects, Classes & Data Containers / Structures

Lecture 1: Module Introduction

Lecture 2: Important: This is NOT an OOP or "Patterns & Principles" Course!

Lecture 3: Objects vs Data Containers / Data Structures

Lecture 4: Why The Differentiation Matters

Lecture 5: Classes & Polymorphism

Lecture 6: Classes Should Be Small!

Lecture 7: Understanding "Cohesion"

Lecture 8: The "Law Of Demeter" And Why You Should "Tell, Not Ask"

Lecture 9: The SOLID Principles

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

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

Lecture 12: The Liskov Substitution Principle

Lecture 13: The Interface Segregation Principle

Lecture 14: The Dependency Inversion Principle

Lecture 15: Module Resources

Chapter 7: Summary & Checklist

Lecture 1: Concepts Summary & Checklist

Chapter 8: Course Roundup

Instructors

Rating Distribution

  • 1 stars: 51 votes
  • 2 stars: 128 votes
  • 3 stars: 1434 votes
  • 4 stars: 7307 votes
  • 5 stars: 11133 votes

Frequently Asked Questions


How long do I have access to the course materials?


You can view and review the lecture materials indefinitely, like an on-demand channel.


Can I take my courses with me wherever I go?


Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

You may also like

Top 10 Ethical AI Courses to Learn in November 2024

Top 10 Game Development Courses to Learn in November 2024

Top 10 Software Testing Courses to Learn in November 2024