Core Coding Principles

This course is for developers who want to improve their ability to write good, clean, maintainable code

What you'll learn

Understand why code quality is important and how it enables effective software development

Describe key coding principles such as cohesion & coupling, DRY, and the SOLID principles

Improve your reasoning ability about code quality by using a variety of lenses

Write cleaner, more readable, more communicative, more flexible code than before

Discuss code quality ideas amongst a team and be able to, as a team, work towards agreement on a team’s coding standards

Requirements

Developers can code in C#

Visual Studio 2022

Description

The course is for developers who are looking to improve their ability to write good, clean, maintainable code. In it, we cover key coding principles that help to develop a language for discussion within the team. These include coupling and cohesion, the SOLID principles, DRY.Note: the course examples and exercises are in C#, but the theory covered is applicable in all OO languages.Goals -• To get developers thinking about code quality• To provide developers with the tools they need to discuss and evaluate code quality• To get developers to build alignment about what “good” code is• To provide developers with some guidelines about how to go about writing better codeCourse Structure -The following topics are covered:• Preparation – what is the team’s existing understanding of good code?• Lenses for Thinking about Code Quality - Thinking about programming like Kent Beck:Core Values of Software DevelopmentKey PrinciplesThe Four Rules of Simple Design• Cohesion and Coupling• DRY• SOLID Principles:Single Responsibility PrincipleOpen-Closed PrincipleLiskov Substitution PrincipleInterface Segregation PrincipleDependency Inversion Principle• The Practice of Writing Clean Code:Coding StandardsMeaningful namingFunctionsCommentsLearning OutcomesAt the end of this course developers will be able to:Understand why code quality is important and how it enables effective software developmentDescribe key coding principles such as cohesion & coupling, DRY, and the SOLID principlesReason about code quality using a variety of lensesDiscuss code quality ideas among a team and be able to, as a team, work towards alignment and agreement on the team’s coding standardsWrite cleaner, more readable, more communicative, more flexible code than before

Overview

Section 1: Welcome to Core Coding Principles

Lecture 1 Introduction

Lecture 2 Welcome to Core Coding Principles

Section 2: Axioms and Lenses

Lecture 3 Axioms: What are they, why talk about them?

Lecture 4 Axiom 1: Managing Complexity is at the Heart of Software Development

Lecture 5 Axiom 2: Code is Required for any Sufficiently Complex Problem

Lecture 6 Axiom 3: Coding is High Read, Low Write System

Lecture 7 Lemma 1: Code Quality Matters

Lecture 8 Axiom 4: We can use Lenses to Evaluate Code

Lecture 9 House of Lenses: How Lenses Relate to One Another

Lecture 10 Notes, Further Reading and Exercises

Section 3: Values

Lecture 11 Introduction: What are Values?

Lecture 12 Communication

Lecture 13 Simplicity

Lecture 14 Flexibility

Lecture 15 End Note

Lecture 16 Notes, Further Reading and Exercises

Section 4: Concept: Coupling & Cohesion

Lecture 17 Introduction

Lecture 18 Coupling Overview

Lecture 19 Types of Coupling: Semantic and Data Coupling

Lecture 20 Semantic Coupling 1: Content Coupling

Lecture 21 Semantic Coupling 2: Common Coupling

Lecture 22 Semantic Coupling 3: Subclass Coupling

Lecture 23 Semantic Coupling 4: Temporal Coupling

Lecture 24 Semantic Coupling 5: Control Coupling

Lecture 25 Semantic Coupling 6: External Coupling

Lecture 26 Data Coupling 1: Data Stamp Coupling

Lecture 27 Data Coupling 2: Simple Object Coupling

Lecture 28 Data Coupling 3: Simple Data Coupling

Lecture 29 Cohesion

Lecture 30 Encapsulation

Lecture 31 End Note

Lecture 32 Notes and Further Reading

Section 5: Concept: Refactoring

Lecture 33 What is Refactoring?

Lecture 34 The Practice of Refactoring

Lecture 35 Refactoring Demo 1: Rename

Lecture 36 Refactoring Demo 2: Move

Lecture 37 Refactoring Demo 3: Delete

Lecture 38 Refactoring Demo 4: Extract and Inline

Lecture 39 Refactoring Demo 5: Summary and Thoughts

Lecture 40 Notes, Further Reading and Exercises

Lecture 41 Worked Example: Tennis Refactoring Kata Intro

Lecture 42 Worked Example: Tennis Refactoring Kata Extended

Section 6: Concept: Cyclomatic Complexity

Lecture 43 Cyclomatic Complexity (and Nesting)

Lecture 44 Demo Part 1: Refactoring a Sample Project to Reduce Cyclomatic Complexity

Lecture 45 Demo Part 2: Move Parameter to the Constructor, Introduce Better Types

Lecture 46 Demo Part 3: Further Reduce Parameters by Introducing a Class

Lecture 47 Demo Part 4: Final Test Refactorings - Introducing a SUT Builder

Lecture 48 Further Reading and Extercises

Section 7: Principle: Kent Beck's Development Principles

Lecture 49 Introduction

Lecture 50 Local Consequences

Lecture 51 Minimize Repetition

Lecture 52 Symmetry

Lecture 53 Declarative Expression

Lecture 54 Rates of Change

Lecture 55 Summary

Lecture 56 Further Reading and Exercises

Section 8: Heuristic: DRY

Lecture 57 What is DRY and what is it not?

Lecture 58 Common Duplication Forms

Lecture 59 Pitfalls of DRY

Lecture 60 Notes and Further Reading

Section 9: Heuristic: Four Rules of Simple Design

Lecture 61 Introduction: Kent Beck's Formulation

Lecture 62 Martin Fowler's Formulation

Lecture 63 J.B Rainsberger's Formulation

Lecture 64 Applying the "Four Rules" of Simple Design

Lecture 65 Notes, Further Reading and an Exercise

Section 10: Principle: SOLID

Lecture 66 Introduction

Lecture 67 Single Responsibility Principle

Lecture 68 Exercise: Single Responsibility Priciple

Lecture 69 Open/Closed Principle

Lecture 70 Exercise: Open/Closed Principle

Lecture 71 Liskov Substitution Principle

Lecture 72 LSP Example: Invariants

Lecture 73 LSP Example: Pre- and Post- Conditions

Lecture 74 LSP Furthur Thoughts

Lecture 75 Exercise: Liskov Substitution Principle

Lecture 76 Interface Segregation Principle

Lecture 77 Dependency Inversion Principle

Lecture 78 Summary and Final Thoughts

Lecture 79 Notes, Further Reading and an Exercise

Section 11: Rule: Clean Code

Lecture 80 A Word on Clean Code

Lecture 81 What is Clean Code?

Lecture 82 The Scout Camp Rule

Lecture 83 Guidelines for Cleaning Code

Lecture 84 Coding Standards

Lecture 85 Naming: Introduction

Lecture 86 Naming: A Four Stage Process of Naming

Lecture 87 Naming Guidelines - General

Lecture 88 Naming Guidelines - Classes

Lecture 89 Naming Guidelines - Methods/Functions

Lecture 90 Naming - Finding Names

Lecture 91 Naming is Hard - ChilliTalk Podcast Episode

Lecture 92 Functions: Introduction

Lecture 93 Functions: Principles

Lecture 94 Functions: Keep them Small

Lecture 95 Functions: Naming, and One Level of Abstraction

Lecture 96 Functions: Parameters

Lecture 97 Functions: More General Principles and Recap

Lecture 98 Comments: Intro

Lecture 99 Comments: Why are they Dangerous

Lecture 100 Comments: When to use, When not to Use

Lecture 101 Notes, Further Reading and Exercise

C# Developers who are wanting to improve their ability to write good, clean, maintainable code