Home
Search results “Solid oop principles”
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: 35786 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: 35068 Christopher Okhravi
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: 127171 kudvenkat
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: 42034 IAmTimCorey
Becoming a better developer by using the SOLID design principles by Katerina Trajchevska
 
41:40
Join Europe's leading Laravel conference in 2019. 23th May in Madrid & 28th–30th Aug in Amsterdam. Get Tickets http://laracon.eu/2019
Views: 6786 Laracon EU
SOLID принципы [GeekBrains]
 
01:35:10
Начни карьеру с бесплатного курса "Основы программирования" https://goo.gl/jTP4nP Вы внесли в проект простое на первый взгляд изменение, а оно потребовало многочасового переписывания кода? Вы смотрите свой старый проект и понимаете, что его можно сделать более гибким, легко расширяемым, простым в сопровождении, но не знаете, как это сделать с минимальными усилиями? Вам помогут SOLID-принципы! SOLID-принципы - это пять шаблонов проектирования, образующие мощный инструментарий по написанию красивого и понятного кода без боли и страданий. На мастер-классе вы узнаете: - как пользоваться этими шаблонами, -в каких ситуациях они будут вам полезны, - какие подводные камни могут вас подстерегать. Вебинар рассчитан на разработчиков с опытом от полугода. Язык программирования не имеет значения. Все примеры приведены на псевдокоде, по синтаксису напоминающему С, Java, PHP. Подписывайся на наш канал и смотри новые видео первым: https://www.youtube.com/progliveru Проходи бесплатные курсы: https://goo.gl/4gG8TL Выбери профессию: https://goo.gl/WSdYSE Смотри вебинары: https://goo.gl/bBVKcb Читай статьи: https://goo.gl/XfJNqc Проверяй знания: https://goo.gl/gqKSsw ВКонтакте https://vk.com/geekbrainsru Facebook https://www.facebook.com/geekbrains.ru Одноклассники https://ok.ru/geekbrains Telegram https://t.me/geekbrains_ru Instagram https://www.instagram.com/geekbrains.ru/ #solid #geekbrains #программирование #курсыпрограммирования
Дмитрий Кандалов, Agile Object Oriented Design, SOLID Principle
 
29:00
В этом докладе я расскажу о SOLID принципах ООП описанных Робертом Мартином (Robert C. Martin) в книге "Быстрая разработка ПО: принципы, паттерны, практики" (Agile Principles, Patterns, and Practices) и что они означают в реальной жизни. Некоторые из этих принципов широко известны в других формах, некоторые очевидны. Но их интерпретация Робертом Мартином одна из лучших и может быть очень полезна для программистов использующих ОО языки.
Views: 604 ScrumTrek
SOLID принципы
 
12:16
Принципы проектирование объектно ориентированного программирования. Что такое SOLID принцы в объектно ориентированном программировании рассказываю в этом видео с примерами. Принцип единой ответственности (Single Responsibility) Принцы открытости закрытости (Open/Closed) Принцип подстановки Барбары Лисков (Liskov Substitution) Принцип разделения интерфейсок (Interface Segregation) Принцип инверсии зависимостей (Dependency Inversion) https://habr.com/post/208442/ - отсюда брались примеры
Views: 1950 Live Coding School
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: 106740 BBarters
Software Design - Introduction to SOLID Principles in 8 Minutes
 
08:17
Software Design - Introduction to SOLID Principles in 8 Minutes ► SUBSCRIBE --> https://www.youtube.com/user/rithustutorials?sub_confirmation=1 ► RECOMMENDED COURSE - Your First Steps from Programmer to Software Architect --> https://www.udemy.com/software-architect-course-first-steps/?couponCode=YOUTUBE-2019 ► DOWNLOAD Presentation and Notes --> https://courses.in28minutes.com/p/in28minutes-course-guide -------------------------------------------------- MOST WATCHED TUTORIALS -------------------------------------------------- ► How to become an expert on Spring Boot, REST and Microservices? --> https://www.youtube.com/watch?v=jf6doctfxWQ ► WATCH 30+ Videos on SPRING BOOT --> https://www.youtube.com/playlist?list=PLBBog2r6uMCRcybG1UBB6yAqFZbwjAKHi ► CHECK OUT Our Most Watched Videos --> https://www.youtube.com/playlist?list=PLBBog2r6uMCQhZaQ9vUT5zJWXzz-f49k1 ► All Spring Boot Articles - http://www.springboottutorial.com/spring-boot-projects-with-code-examples ---------------------------------------------- RECOMMENDED COURSES ---------------------------------------------- ► Your First Steps from Programmer to Software Architect --> https://www.udemy.com/software-architect-course-first-steps/?couponCode=YOUTUBE-2019 ► Spring Framework Interview Guide - 200+ Questions & Answers --> https://www.udemy.com/spring-interview-questions-and-answers/?couponCode=YOUTUBE-2019 ► Java Interview Guide : 200+ Interview Questions and Answers --> https://www.udemy.com/java-interview-questions-and-answers/?couponCode=YOUTUBE-2019 -------------------------------------------------------------------------------------------- BEST SELLING COURSES - 30 DAY MONEY BACK GUARANTEE -------------------------------------------------------------------------------------------- ► Python For Beginners - Java to Python in 100 Steps --> https://www.udemy.com/learn-python-programming-for-java-programmers?couponCode=YOUTUBE-2019 ► Master Microservices with Spring Boot and Spring Cloud --> https://www.udemy.com/microservices-with-spring-boot-and-spring-cloud/?couponCode=YOUTUBE-2019 ► Spring Master Class - Beginner to Expert --> https://www.udemy.com/spring-tutorial-for-beginners/?couponCode=YOUTUBE-2019 ► Your First Steps from Programmer to Software Architect --> https://www.udemy.com/software-architect-course-first-steps/?couponCode=YOUTUBE-2019 ► Master Hibernate and JPA with Spring Boot in 100 Steps --> https://www.udemy.com/hibernate-jpa-tutorial-for-beginners-in-100-steps/?couponCode=YOUTUBE-2019 ► Spring Framework Interview Guide - 200+ Questions & Answers --> https://www.udemy.com/spring-interview-questions-and-answers/?couponCode=YOUTUBE-2019 ► Master Java Web Services and REST API with Spring Boot --> https://www.udemy.com/spring-web-services-tutorial/?couponCode=YOUTUBE-2019 ► Learn Spring Boot in 100 Steps - Beginner to Expert --> https://www.udemy.com/spring-boot-tutorial-for-beginners/?couponCode=YOUTUBE-2019 ► Java Interview Guide : 200+ Interview Questions and Answers --> https://www.udemy.com/java-interview-questions-and-answers/?couponCode=YOUTUBE-2019 ► Mockito Tutorial : Learn mocking with 25 Junit Examples --> https://www.udemy.com/mockito-tutorial-with-junit-examples/?couponCode=YOUTUBE-2019 ► Spring MVC For Beginners : Build Java Web App in 25 Steps --> https://www.udemy.com/spring-mvc-tutorial-for-beginners-step-by-step/?couponCode=YOUTUBE-2019 --------------------------------------------------- Follow us on Social Media --------------------------------------------------- ► TWITTER --> https://twitter.com/in28minutes ► FACEBOOK --> https://www.facebook.com/in28Minutes ► INSTAGRAM --> https://www.instagram.com/in28minutes/ ► LINKEDIN --> https://in.linkedin.com/in/rangakaranam
Views: 4396 in28minutes
Урок Java 304: Solid 1: Что такое SOLID
 
10:21
Поддержать развитие канала - http://donatepay.ru/d/133523
Views: 7731 Уроки Java
Understanding the Single Responsibility Principle
 
04:31
In this section of understanding the SOLID development pattern we will walk through the single responsibility principle, including a practical example. Show notes: https://www.crondose.com/2016/08/solid-development-single-responsibility-principle/
Views: 12251 edutechional
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: 136728 TDD TV
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: 116716 Microsoft Visual Studio
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: 2857 Programming
Принципы SOLID. Общие сведения
 
10:39
Текстовая версия урока (с исходным кодом проекта): http://alekseev74.ru/lessons/show/csharp/solid-principles В течение следующих нескольких видеоуроков мы поговорим о таком понятии, как принципы объектно-ориентированного программирования и проектирования в целом. В этом уроке мы разберем в общем, что же это за принципы и для чего они нужны, в чем их польза, а в нескольких следующих уроках мы разберем каждый из этих принципов более подробно. Видеокурсы по программированию: http://alekseev74.ru/courses
S.O.L.I.D-ый JavaScript
 
45:37
MoscowJS в Badoo (http://moscowjs.ru/) «S.O.L.I.D-ый JavaScript», Алексей Охрименко (IPONWEB) S.O.L.I.D — что значит сочетание этих магических 5 букв? Как автор MVC проектирует свои приложения? Как научиться проектировать свое приложение и не отрастить бороду? Где брать всю эту информацию и что учить? Об этом и многом другом вы узнаете из этого доклада. http://www.slideshare.net/BadooDev/solid-javascript
Views: 16847 Badoo Tech
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: 16460 freeCodeCamp.org
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: 34730 d80
SOLID Programming Principles in C# (with Guitars)
 
22:04
We go through the SOLID object-oriented programming acronym while using a guitar amp as our sample. Twitter: https://twitter.com/KevinGiszewski Blog: https://kevin.giszewski.com GitHub: https://github.com/kgiszewski
Views: 4416 Kevin Giszewski
Design Patterns: Dependency Inversion Principle Explained Practically in C# (The D in SOLID)
 
41:43
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-dip/ 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 fourth entry in the famous SOLID principle. The I stands for Interface Segregation 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: 28168 IAmTimCorey
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: 17481 Coding Tech
GORUCO 2009 - SOLID Object-Oriented Design by Sandi Metz
 
47:12
Help us caption & translate this video! http://amara.org/v/GUQO/
Views: 37591 Confreaks
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: 549 Simplified InFive
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: 22527 Codecourse
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: 47 Tech
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: 42553 BBarters
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: 83341 Michael Kappel
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: 21771 edutechional
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: 6162 edutechional
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: 18254 Infragistics
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: 1578 Recurship
Single responsibility principle SOLID
 
08:07
A school course in OOPS.
OOP S O L I D DESIGN PRINCIPLES
 
09:32
ARABIC EXPLANATION OF THE SOLID object oriented design principles شرح بالعربي لبعض القواعد المهمة في البرمجة الكائنية المنحى SOLID : - Single Responsibility Principle - Open Closed Principle - Liskov Substitution Principle - Interface Segregation Principle - Dependency Inverison Principle 1. Single Responsibility Principle وحداوية الهمهة "There should never be more than one reason for a class to change." 2.Open Closed Principle أن يكون الكائن قابل للإضافة وليس قابلا للتعديل "Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification."
Views: 78 everything IT
S.O.L.I.D. Lesson #5 Dependency Inversion Principle | Software Architecture | Android/Java
 
26:15
Welcome to part 5 of my ramblings on SOLID Object Oriented Software Design Principles. I tried to really focus on the practical nature of what's going on here versus the jargon and technical terms; mostly because I don't think the words are very important. This Video is cut from my weekly Livestream on Sundays at 9:00am (GMT -7). For episodes 13-18, I'll be starting each episode with a lesson on S.O.L.I.D. Principles, and how I understand/apply them to my own code. Note that as I'm an Android Developer, my examples and Code will be written in Java, and reference Android OS. Livestream link: http://www.youtube.com/c/wiseAss/live Github: https://github.com/BracketCove Facebook: https://www.facebook.com/wiseassblog/ G+: https://plus.google.com/+wiseass Twitter: https://twitter.com/wiseass301 Patreon: https://www.patreon.com/bePatron?u=5114325 Blog: http://wiseassblog.com/
Views: 4832 wiseAss
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: 1062 Programming
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: 66865 kudvenkat
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: 46279 kudvenkat
SOLID Principles: Understanding and Using
 
01:41:17
2:37 О появлении SOLID 14:19 Симптомы плохого проектирования 23:34 Dependency Inversion 44:37 Open\Closed Principle 1:00:27 ООП объединяет данные с операциями над ними. Плохо ли это? 1:17:27 Liskov Substitution 1:26:24 Single Responsibility 1:33:54 Interface Segregation Слайды: https://www.slideshare.net/korotenkoartem/solid-principles-136793489 Ссылки: 1) Оригинальная статья Р. Мартина Design Principles And Patterns http://www.cvc.uab.es/shared/teach/a21291/temes/object_oriented_design/materials_adicionals/principles_and_patterns.pdf 2) Книга Agile Practices and Principles in C# (пиратить не призываю, но при желании гуглится) https://www.amazon.com.br/Agile-Principles-Patterns-Practices-C/dp/0131857258 3) Иллюстрированные примеры https://medium.com/@trekhleb/solid-principles-around-you-6db2f0e12139 4) Барбаре Лисков - автор абстрактных типов https://medium.com/a-computer-of-ones-own/barbara-liskov-inventor-of-abstract-data-types-9f8908fdcf86
Views: 828 Artem Korotenko
SOLID Principles | Code Like a Pro | How to Write Code Professionally
 
14:48
SOLID Principles | Code Like a Pro | How to Write Code Professionally Thank you to our sponsor: https://www.DevMountain.com ► MY COURSES My Courses with huge discounts: » 100 Algorithms Challenge: How to Ace Your Next JavaScript Interview https://www.udemy.com/100-algorithms-challenge/?couponCode=CODINGGOD » JavaScript 360: part 1 https://www.udemy.com/javascript-360/?couponCode=CODINGGOD » Angular 360: Part 1 Personal Portfolio https://www.udemy.com/learn-angular-by-projects-part-1/?couponCode=CODINGGOD » Angular 360: Part 2 Top 100 Cryptos https://www.udemy.com/angular-2-360-part-2/?couponCode=CODINGGOD ► MY MERCH My Coding Merch - Shirts, Mugs etc. » "Bro, do you even code?" https://teespring.com/stores/coding-tutorials-360 ► BOOK RECOMMENDATIONS » The Complete Software Developer's Career Guide: http://amzn.to/2BNciX2 » The Total Money Makeover https://amzn.to/2sBHIKs » Clean Code https://amzn.to/2JIjOrz » The Clean Coder https://amzn.to/2NPhvRX » Clean Architecture https://amzn.to/2N0dzNb » Code Complete https://amzn.to/2L6mcE0 » Cracking the Coding Interview https://amzn.to/2MlI3wW ► AFFILIATE LINKS FOR PRODUCTS I LOVE: » Check out items I love on Amazon https://www.amazon.com/shop/codingtutorials360 » Humble Bundle (Low price games, books, courses etc.) https://www.humblebundle.com/?partner=coding360 » Robinhood - Trade Stocks App (Sign up and get 1 share of stock valued between 5 and 200 dollars) http://share.robinhood.com/dylani10 » Acorns - Easy Investment Portfolio (Sign up with my link and get $5 when you deposit) https://acorns.com/invite/52psvn ► DONATE & SUPPORT » Paypal https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=GYQ3PXFZM5554 ► MENTORING » Tutoring, Mentoring and Course Walkthroughs available: http://www.codingtutorials360.com/tutor.html ► SOCIAL MEDIA » Patreon https://www.patreon.com/CodingTutorials360 » Code, Tech and Caffeine Facebook Group https://www.facebook.com/groups/190277791450732/ » Twitter https://www.twitter.com/PizzaPokerGuy » Website http://www.codingtutorials360.com » Instagram https://www.instagram.com/dylansphotos87
Views: 2332 Dylan Israel
Interface Segregation Principle (SOLID) | Code Walks 023
 
05:18
The Interface Segregation Principle (ISP) is the I in the SOLID principles. It states that it's better to have many small interfaces rather than a few larger ones. GEAR USED ► CAMERA: Canon 70D http://amzn.to/29wR8wG ► LENS: Canon 18-55mm http://amzn.to/29vwIYV ► TRIPOD: JOBY Gorillapod Zoom http://amzn.to/29AdkHT
Views: 11802 Christopher Okhravi
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: 77005 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: 5655 Mark Papis
PHP UK Conference 2017 - Gareth Ellis - Introduction to SOLID
 
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.
Views: 7498 PHP UK Conference
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: 196833 Devoxx
Understanding the Liskov Substitution Principle
 
05:58
In this series on SOLID Development we will walk through the Liskov substitution principle, including a practical example in the Ruby language. Show notes: https://www.crondose.com/2016/08/solid-development-liskov-substitution-principle/
Views: 19848 edutechional
Design Patterns: Open Closed Principle Explained Practically in C# (The O in SOLID)
 
52:32
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-ocp/ 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 second entry in the famous SOLID principle. The O stands for Open Closed 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: 26755 IAmTimCorey
150 Einstieg in die SOLID Principles of Object-Oriented Design
 
09:33
In diesem Video gebe ich Ihnen einen Einstieg in die SOLID Principles of Object-Oriented Design, einen Satz von fünf fundamentalen Prinzipien, die jeder objektorientierte Programmierer kennen sollte.
Views: 1271 Kenny Pflug

Kivio windows 7
Windows vista boot bin
Ie 10 for windows vista free download
Can windows 7 expiry
Top competitors of microsoft