Solid Principle with real world and live coding example

Name: Solid Principle with real world and live coding example
Rating: 5.0 (1 reviews)

Solid Principle with Object Oriented Programming Language

Created byRicha HarSivo

Last updated 4/2023

English

English [Auto],

What you'll learn

SOLID Principle with real world example & code example
Learn how to use SOLID principle to write testable & mainatanable code
Acquire foundational knowledge of software architecture through the implementation of SOLID principles.
Grasp the concepts accurately by using analogies from the real world.
Engage in practical sessions where you will redesign and enhance existing code by implementing SOLID design principles.
Acquire an understanding of the distinguishing factors between elegant and robust code and poorly designed code.
Coding may be accessible to anyone, but high-quality code is rare. Differentiate yourself by learning how to produce superior code.
As a software engineer, utilize SOLID principles to produce superior code quality.

Course content

7 sections • 26 lectures • 59m total length

Introduction2:12
Explore solid principles with real-world code examples, including single responsibility principle, open closed principle, Liskov substitution principle, interface segregation principle, and dependency inversion principle.
What is SOLID?1:43
Explore the solid principles—single responsibility, open-closed principle, Liskov substitution principle, interface segregation principle, and dependency inversion principle—and learn how they make code easier to understand, maintain, and reuse.
Why use SOLID?1:16
Explain why SOLID principle is essential for software development, showing how tight coupling makes changes risky and bug-prone, and how adhering to SOLID improves the end user experience.
Benefits of SOLID1:45
Explore the benefits of the SOLID principle, including maintainability, scalability, testability, reusability, and agility, to keep code easy to understand, modify, test, and evolve.

What is Single Responsibility Principle?1:42
Explore the single responsibility principle, which requires a class to have one job and one reason to change. Avoid combining responsibilities, like calculation and database operations, in a single class.
Why use Single Responsibility Principle?1:10
See why the single responsibility principle matters: avoid changing a multi-purpose class to prevent bugs, and split code into separate classes to ease debugging and locate the bug.
Single Responsibility Principle - Real World Example2:22
Explore real world examples that show the single responsibility principle in action, with developers, designers, testers, and product managers handling separate tasks.
Single Responsibility Principle - Code Example5:20
Apply the single responsibility principle with a real-world code example of a book and invoice system; separate calculating total, printing the invoice, and saving the invoice to a file.

What is Open Closed Principle?1:44
Learn how the open-closed principle keeps existing code intact while enabling new features through extension, using mobile phone basics and the app store as practical examples.
Why use Open Closed Principle?1:22
Understand why the open-closed principle guides you to add new features without touching proven production code, reducing bugs and preserving existing functionality.
Open Closed Principle - Real World Example2:40
Learn how the open closed principle keeps basic functionality closed for modification while allowing extension through new features, illustrated by a tourist package and a mixer grinder extension tool.
Open Closed Principle - Code Example5:07
Demonstrate the open-closed principle with an area calculator that uses a shape interface to compute areas for rectangles and circles, avoiding modification and enabling extension.

What is Liskov Substitution Principle?1:15
Explore the Liskov substitution principle and how a child class should replace its parent, preserving inherited properties and behaviors. Learn how incomplete implementations can break Liskov substitution principle in inheritance.
Why use Liskov Substitution Principle?1:51
Explain the Liskov substitution principle, where a subclass can replace its parent and must implement all parent features; otherwise, inherited methods may fail and cause bugs in code.
Liskov Substitution Principle - Real World Example2:47
Explore the Liskov substitution principle with real-world examples: a coffee-making robo and its water-only son reveal proper and broken substitutions, while adding ball kick to sportsman breaks substitution for runner.
Liskov Substitution Principle - Code Example4:08
Explore the Liskov substitution principle through a bird example: duck can fly via a flying-bird superclass, ostrich cannot, leading to two separate superclasses for compliant code.

What is Interface Segregation Principle?1:15
Explains the Liskov substitution principle, showing that a child class should replace its parent when using inheritance, and that missing implementations can break the principle.
Why use Interface Segregation Principle?1:51
Understand the Liskov substitution principle, which states a subclass must replace its parent and provide all parent functionality. Avoid bugs when using inheritance.
Interface Segregation Principle - Real World Example2:47
Explore the Interface Segregation Principle and the Liskov Substitution Principle through real-world examples, such as a coffee-making robo and a water-only mini robo, highlighting proper class responsibilities.
Interface Segregation Principle - Code Example4:08
Demonstrate the Liskov substitution principle using a bird hierarchy, splitting flight into a flying bird superclass so ducks can fly while ostriches cannot, ensuring proper eat and sleep behavior.

What is Dependency Inversion Principle?1:45
Explore the dependency inversion principle, a core solid concept where high-level modules depend on abstractions, not on low-level implementations, using car and ui examples to hide engine and database details.
Why use Dependency Inversion Principle?1:34
Learn why dependency inversion decouples high-level UI from low-level modules like networking or databases by hiding details behind an abstraction layer, making code more flexible, reusable, maintainable, and testable.
Dependency Inversion Principle - Real World Example1:56
Demonstrate the dependency inversion principle with real-world examples like power sockets and remote controls, showing how high-level modules stay decoupled from low-level details and maintenance remains unaffected.
Dependency Inversion Principle - Code Example4:19
Explore dependency inversion by refactoring a high-level employee module to depend on a storage interface, enabling easy swapping of file systems, databases, or NoSQL backends.

Requirements

Basics of programming

Description

It's essential to understand the foundational ideas behind SOLID. Writing good code will come naturally to you once you have a solid foundation. There are many free YouTube videos on SOLID, but they frequently lack coherence and don't use the right analogies or code examples. With carefully chosen analogies and code snippets that will help the concepts stick, this course aims to give a thorough overview of SOLID principles. The points are emphasized using concrete examples from everyday life and visual representations.

You will learn how to design clean and maintainable software systems using SOLID principles. You will gain a deeper understanding of software architecture by learning SOLID principles.

Over four decades of academic research and industry experience have distilled SOLID principles. SOLID principles provide universal, time-proven tools for delivering high-quality software.

The acronym SOLID stands for five principles:

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

Throughout this course, you will gain an in-depth understanding of the SOLID principles and their significance. You will come to realize how implementing these principles can enhance the flexibility, extensibility, and readability of your code. Ultimately, you will experience firsthand the sheer pleasure of working with SOLID code.

Who this course is for:

Software Developers

Solid Principle with real world and live coding example

What you'll learn

Explore related topics

Course content

Introduction4 lectures • 7min

Single Responsibility Principle4 lectures • 11min

Open Closed Principle4 lectures • 11min

Liskov Substitution Principle4 lectures • 10min

Interface Segregation Principle4 lectures • 10min

Dependency Inversion Principle4 lectures • 10min

Course Summary2 lectures • 1min

Requirements

Description

Who this course is for: