Home
Search results “Solid principles object oriented design”
SOLID principles - part 1
 
13:51
In this video, we will discuss the strategies for object oriented design. We will take help of SOLID principles to shape our discussion.
Views: 87296 BBarters
SOLID Design Principles Introduction
 
06:14
In this video we will discuss 1. SOLID Acronym and Introduction 2. SOLID design principles 3. Why SOLID SOLID Introduction 1. SOLID principles are the design principles that enable us manage most of the software design problems 2. The term SOLID is an acronym for five design principles intended to make software designs more understandable, flexible and maintainable 3. The principles are a subset of many principles promoted by Robert C. Martin 4. The SOLID acronym was first introduced by Michael Feathers SOLID Acronym S : Single Responsibility Principle (SRP) O : Open closed Principle (OSP) L : Liskov substitution Principle (LSP) I : Interface Segregation Principle (ISP) D : Dependency Inversion Principle (DIP) Single Responsibility Principle 1. Robert C. Martin expresses the principle as, "A class should have only one reason to change” 2.Every module or class should have responsibility over a single part of the functionality provided by the software, and that responsibility should be entirely encapsulated by the class Liskov Substitution Principle 1. Introduced by Barbara Liskov state that “objects in a program should be replaceable with instances of their sub-types without altering the correctness of that program” 2. If a program module is using a Base class, then the reference to the Base class can be replaced with a Derived class without affecting the functionality of the program module 3. We can also state that Derived types must be substitutable for their base types Open/Closed Principle 1. “Software entities should be open for extension, but closed for modification” 2. The design and writing of the code should be done in a way that new functionality should be added with minimum changes in the existing code 3. The design should be done in a way to allow the adding of new functionality as new classes, keeping as much as possible existing code unchanged Interface Segregation Principle 1. “Many client-specific interfaces are better than one general-purpose interface” 2.We should not enforce clients to implement interfaces that they don't use. Instead of creating one big interface we can break down it to smaller interfaces Dependency Inversion Principle 1. One should “depend upon abstractions, [not] concretions" 2. Abstractions should not depend on the details whereas the details should depend on abstractions 3. High-level modules should not depend on low level modules If we don’t follow SOLID Principles we 1. End up with tight or strong coupling of the code with many other modules/applications 2. Tight coupling causes time to implement any new requirement, features or any bug fixes and some times it creates unknown issues 3. End up with a code which is not testable 4. End up with duplication of code 5. End up creating new bugs by fixing another bug 6. End up with many unknown issues in the application development cycle Following SOLID Principles helps us to 1. Achieve reduction in complexity of code 2. Increase readability, extensibility and maintenance 3. Reduce error and implement Reusability 4. Achieve Better testability 5. Reduce tight coupling Solution to develop a successful application depends on Architecture : choosing an architecture is the first step in designing application based on the requirements. Example : MVC, WEBAPI, MVVM..etc Design Principles : Application development process need to follow the design principles Design Patterns : We need to choose correct design patterns to build the software If you are confused on how we can apply these design principles in the application development? Don’t worry as we are going to take a look at them in greater details in the upcoming videos. In the next video we will discuss single responsibility principle in detail with a sample example. Text version of the video http://csharp-video-tutorials.blogspot.com/2017/11/solid-design-principles-introduction.html Slides http://csharp-video-tutorials.blogspot.com/2017/11/solid-design-principles-introduction_20.html SOLID Design Principles Tutorial https://www.youtube.com/watch?v=HLFbeC78YlU&list=PL6n9fhu94yhXjG1w2blMXUzyDrZ_eyOme SOLID Design Principles Text Articles & Slides http://csharp-video-tutorials.blogspot.com/2018/01/solid-design-principles.html All Dot Net and SQL Server Tutorials in English https://www.youtube.com/user/kudvenkat/playlists?view=1&sort=dd All Dot Net and SQL Server Tutorials in Arabic https://www.youtube.com/c/KudvenkatArabic/playlists
Views: 87989 kudvenkat
S.O.L.I.D. Principles of Object-Oriented Design - A Tutorial on Object-Oriented Design
 
10:04
Learn more advanced front-end and full-stack development at: https://www.fullstackacademy.com In this tutorial, we give an overview of the S.O.L.I.D. Principles of Object-Oriented Design, a concept introduced by Robert C. Martin in 1995. These rules are designed to help a programmer develop software that is easy to maintain and extend. Watch this video to learn: - Three major signs of bad code - How coding with S.O.L.I.D. in mind can help you avoid these pitfalls - How S.O.L.I.D. can apply when coding in JavaScript
Views: 24016 Grace Hopper Academy
Liskov's Substitution Principle | SOLID Design Principles (ep 1 part 1)
 
16:08
What is the Liskov Substitution Principle? In this series we talk about the SOLID design principles. 📣 Ask Me Anything https://app.scaleabout.com/christopherokhravi 💪 Patreon Community https://www.patreon.com/christopherokhravi 📚 Products I Recommend http://amazon.christopherokhravi.com 🎧 Audiobooks for the win http://audible.christopherokhravi.com/ ⭐️Donations BTC: bc1q4k330f3g0mjd70g8ws4zwxheu4ym065f8j8djh ETH: 0xa9342b308d480239d64c967bf7d53c4877474f25 LTC: ltc1q7ja5xvnkj32knp3mnhmgagdcwk8atevdswnft0 BCH: qqa8xpggmx68udkwjvpmmmv22rw6rx68p5ehe5rgmu ZEC: t1XyiVNTTEoSxWT8WdESwsUsp6fbySesYc2
Views: 24210 Christopher Okhravi
SOLID Design Patterns
 
57:18
In this episode, Robert is joined by Phil Japikse for a chat about design patterns. Software design patterns have been around long before the MVC Framework gained momentum. Phil starts with a review of Robert C. Martin's (Uncle Bob) SOLID macronym. After building the proper foundation,he reviews several design patterns, their C# implementation and when and how they should be used in modern software development. Get the code samples here: http://www.skimedic.com/samples/Japikse_SolidPatterns.zip
Views: 100325 Microsoft Visual Studio
SOLID Principles
 
04:30
A brief introduction to the SOLID principles for programming. The accompanying post is here: http://www.d80.co.uk/post/2013/02/25/SOLID-Principles-in-4-minutes.aspx
Views: 32100 d80
GORUCO 2009 - SOLID Object-Oriented Design by Sandi Metz
 
47:12
Help us caption & translate this video! http://amara.org/v/GUQO/
Views: 33333 Confreaks
Design Patterns: Single Responsibility Principle Explained Practically in C# (The S in SOLID)
 
35:50
Newsletter signup (with exclusive discounts): https://iamtimcorey.com/general-sign-up (your email will be kept safe and you will not be spammed). Source Code: https://iamtimcorey.com/design-patterns-srp/ When you are writing code, are you doing it right? That is a question that worries a lot of people, and it should probably at least be something every developer thinks through. Design patterns are best practice concepts that we can implement into our code to make it better in some way. Think of them as guardrails that keep our code safe. In this video, we are going to look at the first entry in the famous SOLID principle. The S stands for Single Responsibility Principle. We are going to dive into what it means, how it should change our programming practices, and how far we should take it.
Views: 20914 IAmTimCorey
JUGBD - VM 5.0 :  SOLID Principles of Object Oriented Design
 
43:21
The SOLID principles are fundamental to designing effective, maintainable, object-oriented systems. Whether you've only just started writing software or have been doing so for years, these principles, when used appropriately, can improve the encapsulation and coupling of your application, making it more malleable and testable in the face of changing requirements. Lets talk SOLID. Reference: Clean Code : http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 And video resources : https://cleancoders.com/ For Full Design thinking: http://www.headfirstlabs.com/books/hfooad/
Views: 626 A N M Bazlur Rahman
The S.O.L.I.D. Principles of OO and Agile Design - by Uncle Bob Martin
 
01:12:12
READ FIRST: UB doesn't talk about -all- 5 SOLID principals, only a couple. This video is more valuable that just "another SOLID talk". And it's a meetup, not a course. If you want a more in-depth training on it, UB has that on his CleanCoders.com site. Very good vids there...very in depth on coding techniques and he codes a lot there. If anyone wants to challenge whether UB is right or wrong about OO concepts, or bitch because he doesn't cover all 5 principles in this 1 hour casual meetup talk, I'll immediately delete your comment. He knows his shit and I get tired of this kind of bitching which happens a lot. This talk is still very entertaining and informative so sit back, relax, and enjoy! Sometimes it's good for us to learn and understand the past, so that we do not make the same mistakes that have been made over and over again in this profession. https://www.CleanCoders.com - ton of vids by UB, very in depth technically http://www.WeDoTDD.com/interviews/companies/16 https://twitter.com/unclebobmartin http://blog.cleancoder.com https://blog.8thlight.com/uncle-bob/archive.html Source: This presentation was given by Uncle Bob on Feb 4, 2015 at the Arlington Lakes Golf Club in Arlington Heights, IL. Schaumburg Microsoft .NET Technologies Meetup http://bit.ly/1hAO2ln Be sure to change the video to 1080p when watching it Recorded with my IPhone 6+ 1080p (60fps) Side Note: UB talks little about SR and DI toward the end, but it's more a talk around business and more top level tech talk around around decoupling code and history of coding (where the idea of decoupling stemmed from, how objects came into existence and why, and how programming languages were affected by it ended up providing polymorphism... and a lot of other interesting things around the importance of plug-in software....all indirectly related to the topic of SOLID itself as a whole. The S.O.L.I.D. Principles of OO and Agile Design What happens to software? Why does is rot over time? How does an Agile Development team prevent this rot, and prevent good designs from becoming legacy code? How can we be sure our designs are good in the first place? This talk presents the agile S.O.L.I.D. principles for designing object oriented class structures. These principles govern the structure and inter dependencies between classes in large object oriented systems. The principles include: The Open Closed Principle, The Liskov Substitution Principle, and the Dependency Inversion Principle, among others. About "Uncle Bob" Martin: Robert C. Martin has been a software professional since 1970. In the last 35 years, he has worked in various capacities on literally hundreds of software projects. He has authored "landmark" books on Agile Programming, Extreme Programming, UML, Object-Oriented Programming, and C++ Programming. He has published dozens of articles in various trade journals. Today, He is one of the software industry's leading authorities on Agile software development and is a regular speaker at international conferences and trade shows. He is a former editor of the C++ Report and currently writes a monthly Craftsman column for Software Development magazine. Mr. Martin is the founder, CEO, and president of Object Mentor Incorporated. Object Mentor is a sister company to Object Mentor International. Like OMI, Object Mentor is comprised of highly experienced software professionals who provide process improvement consulting, object-oriented software design consulting , training, and development services to major corporations around the world.
Views: 128680 Dave Schinkel
Solid Principles by Uncle Bob Martin
 
02:33:20
S.O.L.I.D principles by Robert C. Martin, popularly known as Uncle Bob at REV3 in Naperville IL
Views: 78688 Michael Kappel
S.O.L.I.D Principles : Object Oriented Design
 
01:41
In computer programming, the term SOLID is a mnemonic acronym for five design principles intended to make software designs more understandable, flexible and maintainable. The principles are a subset of many principles promoted by Robert C. Martin, [1][2][3]. Though they apply to any object-oriented design, the SOLID principles can also form a core philosophy for methodologies such as agile development or Adaptive Software Development.[3] The SOLID acronym was introduced by Michael Feathers.
Views: 39 PHPGuy
SOLID Principles of Object Oriented Design Presented by Steve Bishop @ MINICON
 
03:20:47
Skip to 10:30 for better audio and the actual start of the talk. Learn what the SOLID Principles are, and how they can help make your code more manageable. SOLID is an acronym for Single Responsibility Principle (SRP), Open Closed Principle (OCP), Liskov Substitution Principle (LSP), Interface Segregation Principle (ISP), and Dependency Inversion Principle (DIP). After watching this video you will know what the SOLID Principles are and how they can help you keep your code decoupled, maintainable, and testable. You will also learn about how making your code SOLID leads to the architecture of your application. Additionally, we will discuss what Dependency Injection is, and you will see a demo project that employs the SOLID Principles. This presentation is being made at the MINICON event hosted at Launchpoint in Mesa Arizona. Click Here For The Work Files: https://github.com/Xipooo/SOLIDPrinciplesDemo Click Here For An Edited Version: https://www.youtube.com/watch?v=bL5mHFFupts Click Here To Contribute To The Channel: http://Patreon.com/ProgrammingMadeEZ Click Here For The Channel Page: http://ProgrammingMadeEZ.com Click Here For My Blog: http://techie-tid-bits.blogspot.com Click Here For My Facebook Page: http://www.facebook.com/ProgrammingMadeEZ
Views: 2487 Programming
Are You a SOLID Developer?
 
58:45
It is pretty common to hear people talk about "SOLID code" in talks, blogs and podcasts these days. For the object-oriented programming novice who hears this term for the first time, the Wikipedia article gives a high-level overview, but advice and information about what ""SOLID"" really means on a practical level can be hard to come across. This talk aims to clarify what the SOLID principles are and how you can apply them in your work, with the aim of producing easier-to-maintain, de-coupled code with fewer smells. I'll show you PHP examples of each of the five SOLID principles, talk about when and how to implement them in your applications and give you a few other hints about ways you can improve your OOP design. EVENT: PHP UK Conference 2017 SPEAKER: Gareth Ellis PERMISSIONS: The original video was published on PHP UK Conference YouTube channel with the Creative Commons Attribution license (reuse allowed). CREDITS: Original video source: https://www.youtube.com/watch?v=86Tt2pW9pv4
Views: 14732 Coding Tech
OOP Design Principles: Dependency Inversion Principle
 
04:26
In this final video in the SOLID Development series we'll walk through the dependency inversion principle that promotes class reuse and abstraction. Show notes: https://www.crondose.com/2016/08/solid-development-dependency-inversion-principle/
Views: 17411 edutechional
SOLID Principles of Object Oriented Design
 
04:10
Introduction to SOLID principles of OOD Single Responsibility Open-Closed Lisckov's substitution Interface segregation Dependency Inversion
Views: 517 Simplified InFive
Дмитрий Кандалов, Agile Object Oriented Design, SOLID Principle
 
29:00
В этом докладе я расскажу о SOLID принципах ООП описанных Робертом Мартином (Robert C. Martin) в книге "Быстрая разработка ПО: принципы, паттерны, практики" (Agile Principles, Patterns, and Practices) и что они означают в реальной жизни. Некоторые из этих принципов широко известны в других формах, некоторые очевидны. Но их интерпретация Робертом Мартином одна из лучших и может быть очень полезна для программистов использующих ОО языки.
Views: 566 ScrumTrek
SOLID principles - part 2
 
18:34
Liskov's Substitution principle - 0:10 (coding example: https://youtu.be/i0qmhk41QVM) Interface segregation principle - 3:17 Dependency inversion principle - 12:34
Views: 33987 BBarters
Front End Center — Single Responsibility Components: Object-Oriented Design in React
 
14:26
The Functional Programming (FP) aspects of React are fairly prominent, but components themselves are an example of Object-Oriented (OO) programming. In this episode, we'll look at how one idea from OO—The Single Responsibility Principle—can help us design and extract more readable, reusable, and maintainable React components. Thanks to Lookahead Search https://www.lookahead.com.au for making this episode available! Front End Center is a premium screencast series on all aspects of front-end web development. Subscribe now to get access to all episodes: https://frontend.center
Views: 8724 Front End Center
SOLID: Single Responsibility (Part 1/5)
 
02:56
Want more? Explore the library at https://www.codecourse.com/lessons Official site https://www.codecourse.com Twitter https://twitter.com/teamcodecourse
Views: 20915 Codecourse
OOP Design Principles: Interface Segregation Principle
 
04:36
This video continues our SOLID Development series and walks through the interface segregation principle, including a practical Ruby example. Show notes: https://www.crondose.com/2016/08/solid-development-interface-segregation-principle/
Views: 4874 edutechional
S.O.L.I.D principles with Angular [Urdu/Hindi]
 
31:12
SOLID is short for: S - Single-responsiblity principle O - Open-closed principle L - Liskov substitution principle I - Interface segregation principle D - Dependency Inversion Principle Its all about object oriented programming, and how do we do this using Angular? Abdul Qadir explains to us the concepts and how can we go about using it when building scalable frontend applications.
Views: 1025 Recurship
Learning SOLID Principles Using C# - Infragistics Webinar
 
50:22
SOLID principles are the five basic principles of object-oriented programming and design. Systems created using these principles are easy to extend and maintain over time, making them a wise choice. But where do you begin to learn about them? In this webinar, we'll explore all of the basic SOLID principles, including the Single responsibility principle; the Open Closed principle; the Liskov substitution principle; and more! Additionally, you'll learn how to create a system by adhering to the SOLID principles we explore, using C# as a language to understand the principles.
Views: 16386 Infragistics
How to write actually object-oriented python - Per Fagrell
 
24:23
The multi-paradigm flexibility of Python can bite developers new to Python or object-orientation, since self-restraint and design know-how is needed to keep code style paradigm-consistent. Learn about OO principles like SOLID and Tell-Don't-Ask and how they apply in Python for more uniform, testable, and working OO code.
Views: 72547 PyGotham 2014
Solid design principles in Java
 
04:20
Check my free #4 Video Java Interview Course: markpapis.com/java-interview-workshop-starter/ Design Principles, What is encapsulation ? What is Polimorphism ? What is Aggregation / Composition ? What is Method Overloading ? Inheritance vs Compositions ? What are SOLID Design Principles ?
Views: 4016 Mark Papis
Object-oriented design: Identifying an inheritance situation | lynda.com tutorial
 
07:05
This object-oriented design tutorial discusses how to identify an inheritance situation and recognize the shared attributes and behaviors of programming objects. Watch more at http://www.lynda.com/Java-tutorials/Foundations-Programming-Object-Oriented-Design/96949-2.html?utm_medium=viral&utm_source=youtube&utm_campaign=videoupload-96949-0601 This specific tutorial is just a single movie from chapter six of the Foundations of Programming: Object-Oriented Design course presented by lynda.com author Simon Allardice. The complete Foundations of Programming: Object-Oriented Design course has a total duration of 3 hours and 1 minute, discusses the concepts of object-oriented design, and explores creating conceptual models of your program with design patterns, class and sequence diagrams, and unified modeling language tools Foundations of Programming: Object-Oriented Design table of contents: Introduction 1. Core Concepts 2. Object-Oriented Analysis and Design 3. Utilizing Use Cases 4. Domain Modeling (Modeling the App) 5. Creating Classes 6. Inheritance and Composition 7. Advanced Concepts 8. Object-Oriented Design Patterns 9. Object-Oriented Design Principles Conclusion
Views: 47929 LinkedIn Learning
Single responsibility principle SOLID
 
08:07
A school course in OOPS.
SOLID. Basic principles of object-oriented design.1
 
09:42
SOLID. Basic principles of object-oriented design. The main idea of the presentation is present detailed meaning of SOLID approach with examples of usage.
Views: 1766 softservesevastopol
SOLID Principles Of Object Oriented Design Presented By Steve Bishop @ MINICON 4-8-17 (edited)
 
57:33
Learn what the SOLID Principles are, and how they can help make your code more manageable. SOLID is an acronym for Single Responsibility Principle (SRP), Open Closed Principle (OCP), Liskov Substitution Principle (LSP), Interface Segregation Principle (ISP), and Dependency Inversion Principle (DIP). After watching this video you will know what the SOLID Principles are and how they can help you keep your code decoupled, maintainable, and testable. You will also learn about how making your code SOLID leads to the architecture of your application. Additionally, we will discuss what Dependency Injection is, and you will see a demo project that employs the SOLID Principles. This presentation is being made at the MINICON event hosted at Launchpoint in Mesa Arizona. Watch the Full SOLID Principles of Object Oriented Design Presentation Live Recording here: https://youtu.be/QqS76DQlwXM?t=10m23s Click Here For The Work Files: https://github.com/Xipooo/SOLIDPrinciplesDemo Click Here To Contribute To The Channel: http://Patreon.com/ProgrammingMadeEZ Click Here For The Channel Page: http://ProgrammingMadeEZ.com Click Here For My Blog: http://techie-tid-bits.blogspot.com Click Here For My Facebook Page: http://www.facebook.com/ProgrammingMadeEZ
Views: 885 Programming
Liskov's Substitution Principle Java Example
 
12:33
In this video, we discuss a coding example of Liskov's substitution design principle using Java. For understanding SOLID principles please watch: https://youtu.be/hCsqBIyT1pI and https://youtu.be/hCMAcnm4z3I
Views: 6499 BBarters
Open Closed Principle
 
10:11
In this video we will learn 1. Open Closed Principle 2. Implementation guidelines of Open closed Principle 3. And will implement this Principle with a simple example In the first video of SOLID Introduction we have understood that O in the SOLID is acronym for “Open/Closed Principle” also known as OCP Definition: In object-oriented programming, the open/closed principle states that "software entities such as classes, modules, functions, etc. should be open for extension, but closed for modification" 1. Which means, any new functionality should be implemented by adding new classes, attributes and methods, instead of changing the current ones or existing ones. 2. Bertrand Meyer is generally credited for having originated the term open/closed principle and This Principle is considered by Bob Martin as “the most important principle of object-oriented design”. Implementation guidelines 1. The simplest way to apply OCP is to implement the new functionality on new derived (sub) classes that inherit the original class implementation. 2. Another way is to allow client to access the original class with an abstract interface, 3. So, at any given point of time when there is a requirement change instead of touching the existing functionality it’s always suggested to create new classes and leave the original implementation untouched. Pit falls of Not following OCP What if I do not follow Open closed principle during a requirement enhancement in the development process. In that case, we end up with the following disadvantages 1. If a class or a function always allows the addition of new logic, as a developer we end up testing the entire functionality along with the requirement. 2. Also, as a developer we need to ensure to communicate the scope of the changes to the Quality Assurance team in advance so that they can gear up for enhanced regression testing along with the feature testing. 3. Step 2 above is a costly process to adapt for any organization 4. Not following the Open Closed Principle breaks the SRP since the class or function might end up doing multiple tasks. 5. Also, if the changes are implemented on the same class, Maintenance of the class becomes difficult since the code of the class increases by thousands of unorganized lines. Hope the above counter facts helps in understanding on why we need to follow the open closed principle. You can find the code used in the demo at the following link http://csharp-video-tutorials.blogspot.com/2018/01/open-closed-principle.html Also, we strongly recommend you to refer to our design pattern tutorial for more details on creational design patterns I believe this session has given you a good idea on how we can implement Open closed principle. In the next session we will focus on Liskov substitution principle. Till then, thank you and have a great day Text version of the video http://csharp-video-tutorials.blogspot.com/2018/01/open-closed-principle.html Slides http://csharp-video-tutorials.blogspot.com/2018/01/open-closed-principle-slides.html SOLID Design Principles Tutorial https://www.youtube.com/watch?v=HLFbeC78YlU&list=PL6n9fhu94yhXjG1w2blMXUzyDrZ_eyOme SOLID Design Principles Text Articles & Slides http://csharp-video-tutorials.blogspot.com/2018/01/solid-design-principles.html All Dot Net and SQL Server Tutorials in English https://www.youtube.com/user/kudvenkat/playlists?view=1&sort=dd All Dot Net and SQL Server Tutorials in Arabic https://www.youtube.com/c/KudvenkatArabic/playlists
Views: 29318 kudvenkat
Lesson 10  -  Single responsibility principle  [ Java for Beginners ]
 
14:09
Lesson 10 - Single responsibility principle [ Java for Beginners ] --------------- Java From Novice to Professional Course ----------------- 1 - Basics of OOP ( Object Oriented Programming ) 2 - Introduction to OOP 3 - Object Interaction and Application runtime 4 - Interfaces & abstraction 5 - Abstract Classes 6 - Object Messages & Dependencies 7 - Association 8 - Association between Objects 9 - Overview of Software Design 10 - Single responsibility principle 11 - Open Close Principle & Strategy Pattern 12 - Dependency Inversion 13 - IOC Container 14 - Template Pattern 15 - LISKOV Substitution Principle 16 - Interface Segregation Principle 17 - Dependency Injection 18 - Observer Pattern 19 - Builder Pattern 20 - Factory Design Pattern 21 - Singleton Design Pattern 22 - Automatically generate UML diagrams from java code JAVA Java Basics Design Pattern Design Pattern in java Programming basics From zero to pro in java Programming in java OOP Object Oriented Programming Java for newbies Java for beginners Programming in java for absolute beginners
Views: 3728 Knowledge Dose
Clean Code: SOLID - Beau teaches JavaScript
 
12:08
Learn the best practices of how to write clean code in JS. This video tutorial is over the S.O.L.I.D. principles of clean code programming: S – Single Responsibility Principle O – Open-Closed Principle L – Liskov Substitution Principle I – Interface Segregation Principle D – Dependency Inversion Principle Learn what these mean and how to implement them in JavaScript! The full Clean Code playlist: https://www.youtube.com/playlist?list=PLWKjhJtqVAbkK24EaPurzMq0-kw5U9pJh Code: http://codepen.io/beaucarnes/pen/gmowZd?editors=0010 Ryan McDermott’s original article: https://github.com/ryanmcdermott/clean-code-javascript Other resource on SOLID: http://thefullstack.xyz/solid-javascript/ Beau Carnes on Twitter: https://twitter.com/carnesbeau ⭐JavaScript Playlists⭐ ▶JavaScript Basics: https://www.youtube.com/playlist?list=PLWKjhJtqVAbk2qRZtWSzCIN38JC_NdhW5 ▶ES6: https://www.youtube.com/playlist?list=PLWKjhJtqVAbljtmmeS0c-CEl2LdE-eR_F ▶Design Patterns: https://www.youtube.com/playlist?list=PLWKjhJtqVAbnZtkAI3BqcYxKnfWn_C704 ▶Data Structures and Algorithms: https://www.youtube.com/playlist?list=PLWKjhJtqVAbkso-IbgiiP48n-O-JQA9PJ - We're busy people who learn to code, then practice by building projects for nonprofits. Learn Full-stack JavaScript, build a portfolio, and get great references with our open source community. Join our community at https://freecodecamp.com Read our Medium publication at https://medium.freecodecamp.com/
Views: 12894 freeCodeCamp.org
Single Responsibility Principle
 
10:24
In this video we will discuss 1. What is Single Responsibility 2. Single Responsibility Example In our previous video we discussed S in the SOLID is acronym for Single Responsibility Principle (SRP) As per the single responsibility principle 1. A class should have only one reason to change 2. Which means, every module or class should have responsibility over a single part of the functionality provided by the software, and that responsibility should be entirely encapsulated by the class. Encapsulation is one of the fundamentals of OOP. At this moment, understanding more about encapsulation is out of scope of this session. However, we strongly recommend you to refer to the C# tutorial playlist for more details on Object oriented principles. Now you might be wondering what do we achieve with the Single Responsibility Principle or rather with the SOLID Design Principles. Let's first understand the motivation behind the usage of SOLID Principles In any enterprise software application development when we design and develop software systems, we need to account the below factors during the development cycle. Maintainability : Maintainable systems are very important to the organisations. Testability : Test driven development (TDD) is required when we design and develop large scale systems Flexibility and Extensibility : Flexibility and extensibility is a very much desirable factor of enterprise applications.Hence we should design the application to make it flexible so that it can be adapt to work in different ways and extensible so that we can add new features easily. Parallel Development : It is one of the key features in the application development as it is not practical to have the entire development team working simultaneously on the same feature or component. Loose Coupling : We can address many of the requirements listed above by ensuring that our design results in an application that loosely couples many parts that makes up the application. SOLID Principles and Design Patterns plays a key role in achieving all of the above points. In Single Responsibility Principle 1. Each class and module should focus on a single task at a time 2. Everything in the class should be related to that single purpose 3. There can be many members in the class as long as they related to the single responsibility 4. With SRP, classes become smaller and cleaner 5. Code is less fragile Hence we can say that Single Responsibility Principle achieves the motivation points that we have just discussed. Below code demonstrates how we can achieve Single Responsibility Principle Code before Single Responsibility Segregation using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace SRPDemo { interface IUser { bool Login(string username, string password); bool Register(string username, string password, string email); void LogError(string error); bool SendEmail(string emailContent); } } Code after Single Responsibility Segregation using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace SRPDemo { interface IUser { bool Login(string username, string password); bool Register(string username, string password, string email); } interface ILogger { void LogError(string error); } interface IEmail { bool SendEmail(string emailContent); } } Now that we have segregated the single responsibility principle in these multiple interfaces the next step is to implement these interfaces with object creation mechanisms. GOF has defined many design patterns on object creations based on the requirements. Hence we strongly recommend you to refer to our design pattern tutorial for more details on creational design patterns. I believe this session has given you a good idea on how we can implement Single responsibility principle. In the next video we will discuss Interface Segregation Principle. Text version of the video http://csharp-video-tutorials.blogspot.com/2017/11/single-responsibility-principle.html Slides http://csharp-video-tutorials.blogspot.com/2017/11/single-responsibility-principle-slides.html SOLID Design Principles Tutorial https://www.youtube.com/watch?v=HLFbeC78YlU&list=PL6n9fhu94yhXjG1w2blMXUzyDrZ_eyOme SOLID Design Principles Text Articles & Slides http://csharp-video-tutorials.blogspot.com/2018/01/solid-design-principles.html All Dot Net and SQL Server Tutorials in English https://www.youtube.com/user/kudvenkat/playlists?view=1&sort=dd All Dot Net and SQL Server Tutorials in Arabic https://www.youtube.com/c/KudvenkatArabic/playlists
Views: 44267 kudvenkat
Core Design Principles for Software Developers by Venkat Subramaniam
 
02:36:10
Subscribe to Devoxx on YouTube @ https://bit.ly/devoxx-youtube Like Devoxx on Facebook @ https://www.facebook.com/devoxxcom Follow Devoxx on Twitter @ https://twitter.com/devoxx Writing code is easy. Writing good quality code is an entirely different story. How can we measure quality of design? How do we know we're doing the right set of things that will leads us to a better design? In this session we will learn about some core software design principles that help programmers everyday. Instead of talking about theory and what we could potentially do, we will take on multiple examples, discuss the solution, pros and cons, and bring out key design principles that have an impact on the outcome.
Views: 176473 Devoxx
Object Oriented Design
 
25:09
Get the Diagrams : http://goo.gl/ACQAd UML Tutorial : http://goo.gl/1oMF43 Design Patterns Tutorial : http://goo.gl/ZzjDWU Support me on Patreon : https://www.patreon.com/derekbanas Welcome to my Object Oriented Design Tutorial! I cover a ton of things in the video below. The goal of this tutorial is to teach you how to create excellent OO designs. In this tutorial, I start off with a programming idea and walk you through the process of creating a Use Case, Object Model, Sequence Diagram and Class Diagram.
Views: 306095 Derek Banas
Liskov Substitution Principle
 
09:53
In this video we will learn 1. Liskov Substitution Principle 2. Implementation guidelines of Liskov Substitution Principle 3. And will implement this Principle with a simple example In the first video of SOLID Introduction we have understood that L in the SOLID is acronym for Liskov Substitution Principle which is also known as LSP. Definition : Substitutability is a principle in object-oriented programming and it states that, in a computer program, if S is a Subtype of T, then objects of type T may be replaced with objects of type S 1. Which means, Derived types must be completely substitutable for their base types 2. More formally, the Liskov substitution principle (LSP) is a particular definition of a subtyping relation, called (strong) behavioral subtyping 3. This Principle is introduced by Barbara Liskov in 1987 during her conference address on Data abstraction and hierarchy 4. This principle is just an extension of the Open Close Principle The examples used in this session are related to the open closed principle. Hence we request you to watch the Open Closed Principle tutorial before proceeding. Implementation guidelines : In the process of development we should ensure that 1. No new exceptions can be thrown by the subtype unless they are part of the existing exception hierarchy. 2. We should also ensure that Clients should not know which specific subtype they are calling, nor should they need to know that. The client should behave the same regardless of the subtype instance that it is given. 3. And last but not the least, New derived classes just extend without replacing the functionality of old classes In the previous session as part of the Open closed Principle implementation we have created different employee classes to calculate bonus of the employee. From the employee perspective we have implemented the Open closed principle. Now if you take a look at the main program, we have created Employee objects which consists of both permanent and contract employee. If you take a closer look at this program the Derived types which are Permanent and TemporaryEmployee have completely substituted the base type employee class. So, based on the Liskov substitution principle we have achieved LSP by ensuring that Derived types are completely substitutable for their base types. Also, notice the main program, without using the subtypes we are calculating the bonus of the employee from the base class type itself. Hence, we are satisfying the Liskov substitution principle. That means along with the Open Closed Principle we have partially implemented the LSP. Also, I can state that this implementation is not adhering to guide lines of Liskov principle To understand why it’s not adhering to the Liskov Principle, Let’s assume that we need to have a Contract Employee as one of the employee category. A point to note here is a contract employee is not eligible for any bonus calculation and post implementing the Employee class we end up throwing exception at the runtime in the caclculatebonus() method. This violates the Liskov Substitution Principle. Hence, Please follow the below code which addresses this issue. Also, we recommend to watch our video tutorials for complete guidance and understanding of the code. The code is available on our blog at the following link. http://csharp-video-tutorials.blogspot.com/2018/01/liskov-substitution-principle.html Text version of the video http://csharp-video-tutorials.blogspot.com/2018/01/liskov-substitution-principle.html Slides http://csharp-video-tutorials.blogspot.com/2018/01/liskov-substitution-principle-slides.html SOLID Design Principles Tutorial https://www.youtube.com/watch?v=HLFbeC78YlU&list=PL6n9fhu94yhXjG1w2blMXUzyDrZ_eyOme SOLID Design Principles Text Articles & Slides http://csharp-video-tutorials.blogspot.com/2018/01/solid-design-principles.html All Dot Net and SQL Server Tutorials in English https://www.youtube.com/user/kudvenkat/playlists?view=1&sort=dd All Dot Net and SQL Server Tutorials in Arabic https://www.youtube.com/c/KudvenkatArabic/playlists
Views: 32938 kudvenkat
{Arabic-عربي} C#.NET Object-Oriented Design:SOLID Part 1:Single Responsibility Principle-سي شارب
 
12:17
C#.NET Object-Oriented Design:SOLID Part 1: Single Responsibility Principle-سي شارب SOLID شرح المبدأ ألاول من مبادئ object ينص هذا المبدأ على أن كل لديه فقط وظيفة ومسؤلية واحدة من أجلها وُجد ومن أجلها يتغير http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29 https://twitter.com/CSharpArabiTuts Enjoy :-)
Object Orientation Abstraction Principle
 
02:30
Abstraction is the necessary process of simplifying our program's. It's a principle that is carried all throughout programming and not just object oriented programming. As programmers we must simplify and the best way to do that is abstraction.
Views: 1570 Avelx
{Arabic-عربي} C#.NET Object-Oriented Design:SOLID Part 4:Dependency Inversion Principle -سي شارب
 
10:47
C#.NET Object-Oriented Design:SOLID Part 4 -سي شارب شرح المبدأ الخامس من مبادئ S.O.L.I.D DIP: Dependency Inversion Principle ال constructor التابع لكل class يجب ان يظهر بوضوح على ماذا تعتمد هذه ال Class. https://twitter.com/CSharpArabiTuts Enjoy :-)
IQ 38: What are the 4 Pillars of OOP?
 
17:39
This video explains the 4 pillars of OOP
Views: 15466 The Coding Interview
Codemanship Presents S.O.L.I.D. - Open-Closed Principle
 
05:59
Jason Gorman explains the Open-Closed design principle using a simple example. For training and coaching in OO design, test-driven development and refactoring, visit http://www.codemanship.com
Views: 4368 Codemanship
What is Object Oriented Programming (OOPS)? Simple Explanation for Beginners
 
07:30
Object-Oriented Programming is a programming style related to concepts of Class, Objects, and various other concepts like Inheritance, Abstraction, Encapsulation, and Polymorphism. In this video, we have explained What is OOP? and What are other concepts related to OOP, using a very basic example of Human Beings. It's best for beginners to understand the core concept of OOP. For more tutorials, visit our Website: https://www.studytonight.com Facebook: https://facebook.com/Studytonight Twitter: https://twitter.com/studytonight Instagram: https://instagram.com/study.tonight If you like this video hit the Subscribe button, to know when our next video comes up.
Views: 93943 Studytonight
Liskov substitution principle SOLID
 
06:38
A school course in OOPS.

Sample cover letter for any vacant position application
Cover letter terminology management
Purpose of a cover letter in a business plan
Example of resume cover letters with salary requirements
Reviews essay writing service