Our school does not support Internet Explorer. For a much better experience, please download the latest version of Google Chrome, Safari, Opera or Firefox
Software Architecture: Meta and SOLID Principles

Teachers:

About:

  • 5½ hours
  • 62 lessons
  • 0 quizzes

Certificate of Completion Offered

SOLID is an acronym which stands for SRP, OCP, LSP, ISP and DIP. These five acronyms in their turn stand for: 
Single Responsibility Principle 
Open/Closed Principle 
Liskov Substitution Principle 
Interface Segregation Principle 
Dependency Inversion Principle 

In this course, you’ll learn how to apply meta and SOLID principles so that your application will live a long healthy life. It means you are going to learn how to write code of the high quality: readable, understandable and reliable.

Improve your knowledge in object-oriented programming 
Understand the meta-principles on which all the other dev
Take this course for $45.00 30 Day Money Back Guarantee
Do you have a coupon?

What You'll Learn In This Course

Apply SRP
Apply OCP
Apply ISP
Apply LSP
Apply DIP
Build IoC-Container
Build cleaner API in C

What You Need For This Course

Solid C Background
At least half of a year of experience in a real-world project

Description

SOLID is an acronym which stands for SRP, OCP, LSP, ISP and DIP. These five acronyms in their turn stand for: 

  • Single Responsibility Principle 
  • Open/Closed Principle 
  • Liskov Substitution Principle 
  • Interface Segregation Principle 
  • Dependency Inversion Principle 

In this course, you’ll learn how to apply meta and SOLID principles so that your application will live a long healthy life. It means you are going to learn how to write code of the high quality: readable, understandable and reliable.

Improve your knowledge in object-oriented programming 
  • Understand the meta-principles on which all the other development principles are based 
  • Understand the symptoms of code defects 
  • Learn the foundations of SOLID principles 
  • Learn how to detect the violations of SOLID principles and how to fix the problems 
  • Learn how meta-principles and SOLID principles are related to each other and how to find the balance between them

Foundations of writing object-oriented code 

Despite the fact that C# is a very rich on features language, it's very common to see poorly designed and implemented applications in a real world. Language by itself does not guarantee that the architecture of an application will be great. In order to design and build maintainable software, we need to understand the principles of software development. This video course is exactly about how to achieve clean and maintainable software. 

You probably have already heard the following well-known statement: most code sucks. Well, this course is all about how to produce code which doesn't suck.

Owning skills of producing a well-designed and well-implemented types is the prerequisite for the other developers to treat you as a decent professional.

Content and Overview

This course is aimed at middle and senior developers. Solid experience in C# is required.  There are plenty of code examples throughout this course so that you will learn both theoretical and practical material.  Starting with SOLID principles we will go further to the meta-principles. Going through the SOLID principles, you’ll also learn about the related patterns. Then we will get to the problem of contradictions between different principles. You’ll learn about the relationships between SOLID principles and meta-principles. 

In general, you’ll learn in this course:

  • SRP 
  • OCP 
  • LSP 
  • ISP 
  • DIP 

These are the SOLID principles. You’ll learn the background problems that can be solved by particular principle, you’ll see the demonstrations in code, you’ll learn the related patterns to every principle.

Learning DIP you’ll, in addition, learn what is Dependency Injection, Inversion of Control, IoC-Containers and what are the architectural implications of DI

Here are other topics you’ll learn in the course:

  • DRY – don’t repeat yourself 
  • KISS – keep it simple stupid 
  • YAGNI – You Ain’t Gonna Need It 
  • SoC – separation of concerns 
  • CQS – command query separation 
  • Law of Demeter 
  • Principle of Least Astonishment 
  • Information Hiding and Encapsulation 
  • API Development Principles 
  • Contradiction between SOLID and YAGNI 
  • Contradiction between OCP and YAGNI 
  • What is Architecture and Design 

How long is this course: The course is around 4.5 hours. All are video lectures. You will be able to download all the slides and code samples used in the course.

Syllabus

All the lessons in this course
  • Introduction
  • How to Ask Questions
  • Download Source Code and Slides
  • Outline 00:38
  • Introduction to SOLID 08:54
  • SRP Definition. Problem Statement 08:07
  • Demo of the Problem 03:31
  • Refactoring to a Better Design 05:37
  • More Examples of SRP Violation 04:22
  • SRP-Related Patterns 05:20
  • Conclusion 01:52
  • Getting Started
  • Outline 01:12
  • OCP Definition. Problem Statement 08:07
  • Demo of the Problem 02:04
  • Refactoring to a Better Design 06:16
  • OCP-Related Patterns 10:43
  • Common Smells of OCP Violation 01:31
  • Conclusion 01:55
  • Conclusion
  • Outline 01:39
  • LSP Definition. Problem Statement 03:52
  • Contracts 06:59
  • Demo of the Problem 05:49
  • Refactoring to a Better Design 02:20
  • More Examples of LSP Violation 06:11
  • Common Smells of LSP Violation 02:07
  • Conclusion 01:52
  • Interface Segregation Principle (ISP)
  • Outline 01:37
  • ISP Definition. Problem Statement 04:52
  • Demo of the Problem 06:50
  • Refactoring to a Better Design 03:00
  • Demo of the Problem. Example 2 05:51
  • Refactoring to a Better Design. Example 2 01:52
  • Common Smells, Fixes and Related Patterns 07:39
  • Conclusion 02:21
  • Dependency Inversion Principle (DIP)
  • Outline 01:34
  • DIP Definition. Problem Statement 03:31
  • Dependencies 04:13
  • Volatile and Stable Dependencies 02:53
  • IoC and DI Definitions 03:19
  • DIP Violation Demo 02:25
  • Refactoring to a Better Design Applying Dependency Injection 08:12
  • DI Techniques 05:54
  • Architectural Implications 05:24
  • Pure DI and IoC-Containers 04:31
  • Demo of a Real-World App Built with an IoC-Container 10:27
  • Common Smells of DIP Violation 02:11
  • Conclusion 02:15
  • Metaprinciples and SOLID
  • Outline 02:17
  • DRY - Don't Repeat Yourself 09:50
  • KISS - Keep it Simple, Stupid 07:38
  • YAGNI - You Ain't Gonna Need It 11:42
  • SoC - Separation of Concerns 04:28
  • CQS - Command Query Separation Principle 02:15
  • Violation of Law of Demeter 07:01
  • Principle of Least Astonishment 03:04
  • Encapsulation and Information Hiding 05:59
  • General Principles of Building APIs 14:28
  • SOLID vs YAGNI 02:58
  • OCP vs YAGNI 02:48
  • SRP and ISP. What's the Difference? 01:48
  • Architecture and Design 04:56
  • Conclusion 04:23
  • BONUS Lecture