SOLID Principles of Object-Oriented Design and Architecture

SOLID Principles of Object-Oriented Design and Architecture

English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 4.5 Hours | 920 MB

Learn SOLID principles and incorporate the best practices of software architecture into your code

In this course you’re going to master SOLID principles of object-oriented design and architecture. These principles embody more than 40 years of academic research and industry experience, passed to us from previous generations of software engineers. Therefore, by learning SOLID, you gain universal, time-proven tools to build high-quality software.

SOLID is an acronym that stands for five different principles:

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

In this course, you will learn about all five SOLID principles in detail and understand their importance. You will see how these principles manifest themselves in real-world software architecture and discover how they translate into actionable guidelines for writing clean and maintainable code. Speaking about code… SOLID code is flexible, extensible and readable. It is a joy to work with!

In addition to in-depth discussion of SOLID, in this course you will also find many interesting historical facts about the people behind these principles. These short historical references will allow you to see the bigger picture, and they will also make the course much more interesting and engaging for you.

So, if you’re a professional software developer and you’re serious about design, architecture and clean code, this course is for you!

What you’ll learn

  • Discover the theory behind SOLID principles
  • See common SOLID use cases
  • Learn SOLID architecture practices
  • Understand the scope of applicability of SOLID principles
  • Discover the role of abstractions in software design
  • Acquire pragmatic mindset and treat SOLID principles as tools
+ Table of Contents

1 History of SOLID
2 Explanation of Udemy System

Single Responsibility Principle
3 Simplistic Definition
4 Definition Through Conjunction AND
5 Practical Definition Through Change
6 Simple Example Employee
7 Simple Example AuthManager
8 Advanced Example KaraokePlayer
9 Single Responsibility and Reusability
10 Single Responsibility Principle Summary

11 Abstractions in Digital World
12 Abstractions in Object-Oriented Design
13 Abstractions in This Course

Open Closed Principle
14 Open Closed Confusion
15 Historical Definition
16 Current Definition
17 Example Salary Calculator
18 Example Karaoke Application
19 Open Closed Principle Summary

Liskov Substitution Principle
20 Intuitive Example Rectangle and Square
21 Definition and History
22 Liskov Substitution Principle Rules
23 Method Signature Rules
24 Method Pre- and Post-Condition Rules
25 Class Property Rules
26 Example Rectangle and Square
27 Liskov Substitution Principle Summary

Interface Segregation Principle
28 Definition
29 Example Publish-Subscribe Architectural Pattern
30 Example Big Callback Interface
31 Interface Segregation Principle Summary

Dependency Inversion Principle
32 Definition
33 Example Open Closed Principle
34 Example Callback
35 Example Inter-Dependent Modules
36 Dependency Inversion Principle Summary

37 SOLID Summary
38 Bonus Lecture