CodeCamp Iasi 10 march 2012 - Scratching-SOLID
•Download as PPTX, PDF•
0 likes•336 views
The document summarizes the five SOLID principles of object-oriented design: single responsibility principle (SRP), open/closed principle (OCP), Liskov substitution principle (LSP), interface segregation principle (ISP), and dependency inversion principle (DIP). It provides definitions and examples for each principle focusing on concepts like cohesion, coupling, and substitutability. It also attributes the SOLID acronym and principles to Robert C. Martin.
Report
Share
Report
Share
Recommended
SOLID Principles part 1
Of the SOLID principles, made famous by Robert C. Martin, we'll discuss the Single Responsibility Principle and the Open/Closed Principle, two of the presenter's favorite principles. But at the same time the least understood and used principles. That's why this session will explain them thoroughly and give real life examples instead of the regular customer & order examples. You'll walk away knowing what the benefits are and how to use them properly.
Object Oriented Design SOLID Principles
This document discusses object-oriented design principles and patterns. It introduces the SOLID principles: single responsibility, open-closed, Liskov substitution, interface segregation, and dependency inversion. These principles aim to create flexible, reusable, and extensible code. Other principles discussed include composition over inheritance and least knowledge. Common design patterns are inspired by these principles to provide solutions for recurring problems. The document emphasizes that applying object-oriented principles leads to software that can easily adapt to changing requirements.
Python SOLID
This document discusses the SOLID principles of object-oriented design. It introduces each of the SOLID principles - Single Responsibility Principle, Open/Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. It provides examples of how to apply these principles when designing classes and systems using object-oriented programming in Python. Resources for further reading about SOLID and examples of implementing it in code are also included.
Solid principles of oo design
The presentation discusses software design. It discusses the characteristics of a good and bad design. Then it talks about how to achieve a good design. Then finally we discuss the SOLID Principles of Object Oriented Design. These are 5 principles compiled by Rober Cecil Martin aka Uncle Bob. The benefit of these principles is to achieve a good OO design which is high in cohesion and low in coupling thus easily adaptable to change
SOLID Design principles
The document discusses the SOLID principles of object-oriented design. It introduces the five SOLID principles: single responsibility principle, open/closed principle, Liskov substitution principle, interface segregation principle, and dependency inversion principle. Each principle is explained with examples to illustrate how it can make code more maintainable, reusable and less fragile over time. The overall aim of SOLID is to write loosely coupled, highly cohesive code that is easy to reuse and extend without modifying existing code.
Introduction to SOLID Principles
The document introduces the SOLID principles of object-oriented design, which are Single Responsibility Principle, Open-Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. It discusses each principle in detail and provides examples of how to apply them to refactor code and improve design. Design principles help create high-quality software by improving modularity, reusability, and maintainability of code. The SOLID principles in particular help achieve these goals and are fundamental for object-oriented design.
Geecon09: SOLID Design Principles
This document discusses the SOLID principles of object-oriented design. It introduces each principle - Single Responsibility Principle, Open Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. For each principle, it provides a brief definition and example to illustrate how to apply that principle to achieve high cohesion and loose coupling in software design. The overall message is that following SOLID principles can help software designs withstand changes over time by avoiding rigidity, fragility, immobility, and viscosity.
Playgrounds swift introduction
This evening I was given the opportunity to speak at Mobile DC to present on Playgrounds and the Swift programming language. I explained what Swift was and how Playgrounds can be used to help development in it. I provided a live-demo of using a Playground to make a UIView, then we created a fairly simple implementation of XKCD's <a>Geohashing</a>.
Recommended
SOLID Principles part 1
Of the SOLID principles, made famous by Robert C. Martin, we'll discuss the Single Responsibility Principle and the Open/Closed Principle, two of the presenter's favorite principles. But at the same time the least understood and used principles. That's why this session will explain them thoroughly and give real life examples instead of the regular customer & order examples. You'll walk away knowing what the benefits are and how to use them properly.
Object Oriented Design SOLID Principles
This document discusses object-oriented design principles and patterns. It introduces the SOLID principles: single responsibility, open-closed, Liskov substitution, interface segregation, and dependency inversion. These principles aim to create flexible, reusable, and extensible code. Other principles discussed include composition over inheritance and least knowledge. Common design patterns are inspired by these principles to provide solutions for recurring problems. The document emphasizes that applying object-oriented principles leads to software that can easily adapt to changing requirements.
Python SOLID
This document discusses the SOLID principles of object-oriented design. It introduces each of the SOLID principles - Single Responsibility Principle, Open/Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. It provides examples of how to apply these principles when designing classes and systems using object-oriented programming in Python. Resources for further reading about SOLID and examples of implementing it in code are also included.
Solid principles of oo design
The presentation discusses software design. It discusses the characteristics of a good and bad design. Then it talks about how to achieve a good design. Then finally we discuss the SOLID Principles of Object Oriented Design. These are 5 principles compiled by Rober Cecil Martin aka Uncle Bob. The benefit of these principles is to achieve a good OO design which is high in cohesion and low in coupling thus easily adaptable to change
SOLID Design principles
The document discusses the SOLID principles of object-oriented design. It introduces the five SOLID principles: single responsibility principle, open/closed principle, Liskov substitution principle, interface segregation principle, and dependency inversion principle. Each principle is explained with examples to illustrate how it can make code more maintainable, reusable and less fragile over time. The overall aim of SOLID is to write loosely coupled, highly cohesive code that is easy to reuse and extend without modifying existing code.
Introduction to SOLID Principles
The document introduces the SOLID principles of object-oriented design, which are Single Responsibility Principle, Open-Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. It discusses each principle in detail and provides examples of how to apply them to refactor code and improve design. Design principles help create high-quality software by improving modularity, reusability, and maintainability of code. The SOLID principles in particular help achieve these goals and are fundamental for object-oriented design.
Geecon09: SOLID Design Principles
This document discusses the SOLID principles of object-oriented design. It introduces each principle - Single Responsibility Principle, Open Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. For each principle, it provides a brief definition and example to illustrate how to apply that principle to achieve high cohesion and loose coupling in software design. The overall message is that following SOLID principles can help software designs withstand changes over time by avoiding rigidity, fragility, immobility, and viscosity.
Playgrounds swift introduction
This evening I was given the opportunity to speak at Mobile DC to present on Playgrounds and the Swift programming language. I explained what Swift was and how Playgrounds can be used to help development in it. I provided a live-demo of using a Playground to make a UIView, then we created a fairly simple implementation of XKCD's <a>Geohashing</a>.
The OO Design Principles
The document discusses several object-oriented (OO) design principles including the single responsibility principle (SRP), open-closed principle (OCP), Liskov substitution principle (LSP), interface segregation principle (ISP), and dependency inversion principle (DIP). It also discusses design patterns, refactoring, and design by contract (DBC) as ways to prevent software decay over time and improve design quality. The key OO principles guide developers to create flexible, maintainable and reusable software designs.
Playgrounds: A Swift Introduction
A brief overview of the Swift Programming Language and Playgrounds. Explains the basic features of the language and how to use playgrounds.
Solid principles
This document discusses the SOLID principles of object-oriented design:
- The Single Responsibility Principle states that a class should have one, and only one, reason to change.
- The Open/Closed Principle specifies that software entities should be open for extension but closed for modification.
- The Liskov Substitution Principle dictates that subclasses should behave in the same way as their parent classes.
- The Interface Segregation Principle indicates that client classes should not depend on interfaces they do not use.
- The Dependency Inversion Principle asserts that high-level modules should not depend on low-level modules, but both should depend on abstractions.
The presentation provides examples of
ISS Art. How to do IT. Kotlin Multiplatform
As soon as Kotlin-Multiplatform technology appeared, we saw in it the opportunity to optimize and accelerate the development of mobile applications.
What were the results? Nikolai Baklanov, our senior iOS Developer will tell you in his presentation “Experience in the use of Kotlin-Multiplatform technology, attempts to reduce everything to one language.”
Principle of OOD
Principle of OOD:
Basic OOP Concept
Single Responsibility Principly
Open Close Principle
Liskov Subtitution Principle
Dependency Inversion Principle
Interface Segregation Principle
SOLID Principles of Refactoring Presentation - Inland Empire User Group
Abstract: SOLID is a mnemonic acronym coined by Robert C. Martin (aka Uncle Bob) referring to a collection of design principles of object-oriented programming and design. By using these principles, developers are much more likely to create a system that more maintainable and extensible. SOLID can be used to remove code smells by refactoring. In this session, you will learn about the following SOLID principles with code examples demonstrating the corresponding refactoring.
S – Single Responsibility Principle – An Object should have only one reason to change.
O – Open/Closed Principle – A software entity(module, library, routine) should be closed to any modification but be open to extension
L – Liskov Substitution Principle – Derived classes should be substitutable for the base classes
I – Interface Segregation Principle – Having more fine grained interfaces over fat interfaces
D – Dependency Inversion Principle – Depending on abstractions, not concrete implementations.
The modern view on implementation of classic design patterns in Java
Almost every developer heard about design patterns. They was introduced long time ago to solve particular set of repeating problems in systems of different complexity level and size. But there is an opinion that many design patters just filled holes in the OOP languages of that time. Java as one of them has transformed and improved significantly in the last 10 years. So may be we could review design patterns implementation in modern Java world? Some of them are now may be easily replaced with language idioms, some others may be covered with existing libraries and frameworks. I'm sure you know some design patterns that are dead now or became anti-patterns in their initial implementation. Lets make this fun and useful review together!
Wcf for the web developer
This document summarizes a presentation about Windows Communication Foundation (WCF) services for web developers. It discusses WCF programming models including SOAP and RESTful services. It provides an overview of SOAP and REST architectures and common bindings. Examples are given of calling SOAP and REST services. The document also discusses OData and WCF Data Services for exposing data via REST.
Andrei cotorobai bpmn
This document discusses business process modeling notation (BPMN) and business process execution language (BPEL). It defines BPMN as a graphical way to specify business processes and BPEL as an XML language for connecting web services. The document outlines the main components of BPMN including activities, gateways, and events. It also provides a brief overview of major BPMN vendors and the features of the Activiti BPMN engine including IDE support, integration with other frameworks, and real-time deployment capabilities.
Oana Feidi - Debugging - Root cause analysis - CodeCamp-10-may-2014
1) The document discusses root cause analysis techniques like the 5 Whys approach to identify underlying causes of problems that are not obvious from symptoms. It provides an example of using 5 Whys to determine why a customer was unhappy.
2) Lessons learned processes are described, including organizing workshops at the end of projects to identify positive and negative technical and management lessons to derive solutions and prevent repeat mistakes.
3) Applying lessons learned from previous similar projects is advised by selecting applicable lessons upfront and defining specific actions to address them over the course of new projects.
Iasi code camp 12 october 2013 personal organization - gabi csergo
This document discusses the importance of personal organization. It begins with examples of an unorganized day at home and at work where multiple distractions prevented tasks from being completed. It then explains that in today's world of multitasking and constant connectivity, organization is key to avoiding stress and forgetting important tasks. The document recommends implementing a Getting Things Done (GTD) workflow to effectively manage tasks, projects and reviews using tools like notebooks, calendars and checklists. Interruptions are discussed along with tips for protecting focused work time.
Florin Cardasim - What may sell you better in the todays it space - Angajator...
The document discusses what skills are in demand for IT professionals in 2013-2014. It emphasizes domain knowledge, being adaptable to change, delivering work continuously, learning to work with legacy code, and prioritizing quality. Additional skills mentioned include understanding how media like television influences society, maintaining a work-life balance, and aiming high in one's career.
Iasi code camp 12 october 2013 epidemiology of motivation - andrei postolache...
The document discusses the benefits of exercise for mental health. Regular physical activity can help reduce anxiety and depression and improve mood and cognitive function. Exercise causes chemical changes in the brain that may help protect against mental illness and improve symptoms.
Software quality with Code Contracts and PEX - CodeCamp16oct2010
This document discusses software quality tools including code contracts, PEX, and static verification. It introduces design by contract principles and how Microsoft's Code Contracts library implements contracts for .NET programs. Contracts specify preconditions, postconditions, and invariants to define requirements. The document demonstrates how to write contracts and shows how PEX can generate test cases based on contracts. It also discusses how static verification tools like Clousot can check contracts without running code.
Codecamp iasi-26 nov 2011-intro
This document contains the schedule for the CodeCamp de toamnă event held in Iasi, Romania on November 26, 2011. The schedule includes presentations on topics such as HTML5 Web Sockets, Gorilla behavior, new features in JPA 2.0, the value of business process management in real world applications, unit testing, agile planning, callbacks, and applying Entity Framework code first in jobs. There are also coffee breaks scheduled throughout the day as well as a lunch break, and the document mentions there will be prizes.
Learning solid principles using c#
Learning solid principles using c#
S Single Responsibility Principle
O Open Closed Principle
L Liskovs Substitution Principle
I Interface Segregation Principle
D Dependency Inversion principle
Solid design principles
SOLID is a popular set of five design principles for object-oriented software development. The principles are: Single Responsibility Principle, which states that a class should have one responsibility; Open/Closed Principle, which states that code should be open for extension but closed for modification; Liskov Substitution Principle, which states that subclasses should not break the functionality of parent classes; Interface Segregation Principle, which states that clients should not depend on interfaces they do not use; and Dependency Inversion Principle, which states that high-level modules should not depend on low-level modules and abstractions should not depend on details.
OO Design Principles
object oriented design principles,
COUPLING & COHESION,
Open-Closed (open for extension; closed for modification) Principle
Liskov Substitution Principle (LSP)
Dependency Inversion Principle (DIP)
Single Responsibility Principle (SRP)
Interface Segregation Principle (ISP)
RSpec & Rails, an introduction
This document discusses test-driven development (TDD) using Rails, RSpec, and other tools. It notes benefits of TDD like creating solid, change-resilient code, self-testing software, and fewer bugs for customers. Principles like SOLID, dependency injection, and interface segregation are covered. Configuration files and commands for setting up RSpec for testing Rails applications are also listed.
S.O.L.I.D: Principles of OOP and Agile design
This document discusses the SOLID principles of object-oriented programming and agile design. It defines each principle: single responsibility, open/closed, Liskov substitution, interface segregation, and dependency inversion. For each principle, it provides an example of how to apply the principle to code through refactoring existing code. It also discusses object-oriented concepts like polymorphism that relate to the SOLID principles.
Solid and ioc principles
The document summarizes the SOLID principles of object-oriented design, including the Single Responsibility Principle, Open/Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. It also discusses Inversion of Control and Dependency Injection, explaining how following these principles helps make software more reusable, extensible, replaceable, loosely coupled, cohesive, and testable. The document provides definitions and examples for each principle and design pattern.
Solid principle
The document discusses refactoring code to follow the SOLID principles of object-oriented design. It provides an overview of the Single Responsibility Principle (SRP), gives an example of how to refactor code to follow SRP, and summarizes that following SRP leads to lower coupling and higher cohesion. It also discusses the Open/Closed Principle (OCP) and the Liskov Substitution Principle (LSP), providing examples of how to apply each principle when refactoring code.
More Related Content
What's hot
The OO Design Principles
The document discusses several object-oriented (OO) design principles including the single responsibility principle (SRP), open-closed principle (OCP), Liskov substitution principle (LSP), interface segregation principle (ISP), and dependency inversion principle (DIP). It also discusses design patterns, refactoring, and design by contract (DBC) as ways to prevent software decay over time and improve design quality. The key OO principles guide developers to create flexible, maintainable and reusable software designs.
Playgrounds: A Swift Introduction
A brief overview of the Swift Programming Language and Playgrounds. Explains the basic features of the language and how to use playgrounds.
Solid principles
This document discusses the SOLID principles of object-oriented design:
- The Single Responsibility Principle states that a class should have one, and only one, reason to change.
- The Open/Closed Principle specifies that software entities should be open for extension but closed for modification.
- The Liskov Substitution Principle dictates that subclasses should behave in the same way as their parent classes.
- The Interface Segregation Principle indicates that client classes should not depend on interfaces they do not use.
- The Dependency Inversion Principle asserts that high-level modules should not depend on low-level modules, but both should depend on abstractions.
The presentation provides examples of
ISS Art. How to do IT. Kotlin Multiplatform
As soon as Kotlin-Multiplatform technology appeared, we saw in it the opportunity to optimize and accelerate the development of mobile applications.
What were the results? Nikolai Baklanov, our senior iOS Developer will tell you in his presentation “Experience in the use of Kotlin-Multiplatform technology, attempts to reduce everything to one language.”
Principle of OOD
Principle of OOD:
Basic OOP Concept
Single Responsibility Principly
Open Close Principle
Liskov Subtitution Principle
Dependency Inversion Principle
Interface Segregation Principle
SOLID Principles of Refactoring Presentation - Inland Empire User Group
Abstract: SOLID is a mnemonic acronym coined by Robert C. Martin (aka Uncle Bob) referring to a collection of design principles of object-oriented programming and design. By using these principles, developers are much more likely to create a system that more maintainable and extensible. SOLID can be used to remove code smells by refactoring. In this session, you will learn about the following SOLID principles with code examples demonstrating the corresponding refactoring.
S – Single Responsibility Principle – An Object should have only one reason to change.
O – Open/Closed Principle – A software entity(module, library, routine) should be closed to any modification but be open to extension
L – Liskov Substitution Principle – Derived classes should be substitutable for the base classes
I – Interface Segregation Principle – Having more fine grained interfaces over fat interfaces
D – Dependency Inversion Principle – Depending on abstractions, not concrete implementations.
The modern view on implementation of classic design patterns in Java
Almost every developer heard about design patterns. They was introduced long time ago to solve particular set of repeating problems in systems of different complexity level and size. But there is an opinion that many design patters just filled holes in the OOP languages of that time. Java as one of them has transformed and improved significantly in the last 10 years. So may be we could review design patterns implementation in modern Java world? Some of them are now may be easily replaced with language idioms, some others may be covered with existing libraries and frameworks. I'm sure you know some design patterns that are dead now or became anti-patterns in their initial implementation. Lets make this fun and useful review together!
What's hot (7)
SOLID Principles of Refactoring Presentation - Inland Empire User Group
SOLID Principles of Refactoring Presentation - Inland Empire User Group
The modern view on implementation of classic design patterns in Java
The modern view on implementation of classic design patterns in Java
Viewers also liked
Wcf for the web developer
This document summarizes a presentation about Windows Communication Foundation (WCF) services for web developers. It discusses WCF programming models including SOAP and RESTful services. It provides an overview of SOAP and REST architectures and common bindings. Examples are given of calling SOAP and REST services. The document also discusses OData and WCF Data Services for exposing data via REST.
Andrei cotorobai bpmn
This document discusses business process modeling notation (BPMN) and business process execution language (BPEL). It defines BPMN as a graphical way to specify business processes and BPEL as an XML language for connecting web services. The document outlines the main components of BPMN including activities, gateways, and events. It also provides a brief overview of major BPMN vendors and the features of the Activiti BPMN engine including IDE support, integration with other frameworks, and real-time deployment capabilities.
Oana Feidi - Debugging - Root cause analysis - CodeCamp-10-may-2014
1) The document discusses root cause analysis techniques like the 5 Whys approach to identify underlying causes of problems that are not obvious from symptoms. It provides an example of using 5 Whys to determine why a customer was unhappy.
2) Lessons learned processes are described, including organizing workshops at the end of projects to identify positive and negative technical and management lessons to derive solutions and prevent repeat mistakes.
3) Applying lessons learned from previous similar projects is advised by selecting applicable lessons upfront and defining specific actions to address them over the course of new projects.
Iasi code camp 12 october 2013 personal organization - gabi csergo
This document discusses the importance of personal organization. It begins with examples of an unorganized day at home and at work where multiple distractions prevented tasks from being completed. It then explains that in today's world of multitasking and constant connectivity, organization is key to avoiding stress and forgetting important tasks. The document recommends implementing a Getting Things Done (GTD) workflow to effectively manage tasks, projects and reviews using tools like notebooks, calendars and checklists. Interruptions are discussed along with tips for protecting focused work time.
Florin Cardasim - What may sell you better in the todays it space - Angajator...
The document discusses what skills are in demand for IT professionals in 2013-2014. It emphasizes domain knowledge, being adaptable to change, delivering work continuously, learning to work with legacy code, and prioritizing quality. Additional skills mentioned include understanding how media like television influences society, maintaining a work-life balance, and aiming high in one's career.
Iasi code camp 12 october 2013 epidemiology of motivation - andrei postolache...
The document discusses the benefits of exercise for mental health. Regular physical activity can help reduce anxiety and depression and improve mood and cognitive function. Exercise causes chemical changes in the brain that may help protect against mental illness and improve symptoms.
Software quality with Code Contracts and PEX - CodeCamp16oct2010
This document discusses software quality tools including code contracts, PEX, and static verification. It introduces design by contract principles and how Microsoft's Code Contracts library implements contracts for .NET programs. Contracts specify preconditions, postconditions, and invariants to define requirements. The document demonstrates how to write contracts and shows how PEX can generate test cases based on contracts. It also discusses how static verification tools like Clousot can check contracts without running code.
Codecamp iasi-26 nov 2011-intro
This document contains the schedule for the CodeCamp de toamnă event held in Iasi, Romania on November 26, 2011. The schedule includes presentations on topics such as HTML5 Web Sockets, Gorilla behavior, new features in JPA 2.0, the value of business process management in real world applications, unit testing, agile planning, callbacks, and applying Entity Framework code first in jobs. There are also coffee breaks scheduled throughout the day as well as a lunch break, and the document mentions there will be prizes.
Viewers also liked (8)
Oana Feidi - Debugging - Root cause analysis - CodeCamp-10-may-2014
Oana Feidi - Debugging - Root cause analysis - CodeCamp-10-may-2014
Iasi code camp 12 october 2013 personal organization - gabi csergo
Iasi code camp 12 october 2013 personal organization - gabi csergo
Florin Cardasim - What may sell you better in the todays it space - Angajator...
Florin Cardasim - What may sell you better in the todays it space - Angajator...
Iasi code camp 12 october 2013 epidemiology of motivation - andrei postolache...
Iasi code camp 12 october 2013 epidemiology of motivation - andrei postolache...
Software quality with Code Contracts and PEX - CodeCamp16oct2010
Software quality with Code Contracts and PEX - CodeCamp16oct2010
Similar to CodeCamp Iasi 10 march 2012 - Scratching-SOLID
Learning solid principles using c#
Learning solid principles using c#
S Single Responsibility Principle
O Open Closed Principle
L Liskovs Substitution Principle
I Interface Segregation Principle
D Dependency Inversion principle
Solid design principles
SOLID is a popular set of five design principles for object-oriented software development. The principles are: Single Responsibility Principle, which states that a class should have one responsibility; Open/Closed Principle, which states that code should be open for extension but closed for modification; Liskov Substitution Principle, which states that subclasses should not break the functionality of parent classes; Interface Segregation Principle, which states that clients should not depend on interfaces they do not use; and Dependency Inversion Principle, which states that high-level modules should not depend on low-level modules and abstractions should not depend on details.
OO Design Principles
object oriented design principles,
COUPLING & COHESION,
Open-Closed (open for extension; closed for modification) Principle
Liskov Substitution Principle (LSP)
Dependency Inversion Principle (DIP)
Single Responsibility Principle (SRP)
Interface Segregation Principle (ISP)
RSpec & Rails, an introduction
This document discusses test-driven development (TDD) using Rails, RSpec, and other tools. It notes benefits of TDD like creating solid, change-resilient code, self-testing software, and fewer bugs for customers. Principles like SOLID, dependency injection, and interface segregation are covered. Configuration files and commands for setting up RSpec for testing Rails applications are also listed.
S.O.L.I.D: Principles of OOP and Agile design
This document discusses the SOLID principles of object-oriented programming and agile design. It defines each principle: single responsibility, open/closed, Liskov substitution, interface segregation, and dependency inversion. For each principle, it provides an example of how to apply the principle to code through refactoring existing code. It also discusses object-oriented concepts like polymorphism that relate to the SOLID principles.
Solid and ioc principles
The document summarizes the SOLID principles of object-oriented design, including the Single Responsibility Principle, Open/Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. It also discusses Inversion of Control and Dependency Injection, explaining how following these principles helps make software more reusable, extensible, replaceable, loosely coupled, cohesive, and testable. The document provides definitions and examples for each principle and design pattern.
Solid principle
The document discusses refactoring code to follow the SOLID principles of object-oriented design. It provides an overview of the Single Responsibility Principle (SRP), gives an example of how to refactor code to follow SRP, and summarizes that following SRP leads to lower coupling and higher cohesion. It also discusses the Open/Closed Principle (OCP) and the Liskov Substitution Principle (LSP), providing examples of how to apply each principle when refactoring code.
SOLID principles-Present
This document outlines the SOLID principles of object-oriented design, including Single Responsibility Principle, Open-Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. It defines each principle, provides examples, and discusses the benefits, such as increasing reusability, making code more extensible and flexible, and reducing coupling between modules. Applying these principles helps create software that is well-designed and able to easily handle changes, improving developer and customer satisfaction.
Android architecture
The document discusses SOLID principles and architecture patterns in Android development. It describes the five SOLID principles - single responsibility, open/closed, Liskov substitution, interface segregation, and dependency inversion. It then explains popular architecture patterns like MVC, MVP, and MVVM and compares their advantages and disadvantages. The goal of SOLID and these patterns is to make code more reusable, maintainable, flexible and suitable for team development.
Software Design Principles
The document discusses software design principles for managing complexity and change, including the Open-Closed Principle (OCP), Liskov Substitution Principle (LSP), Dependency Inversion Principle (DIP), and Interface Segregation Principle (ISP). These principles aim to create modules that are open for extension but closed for modification, with subclasses substitutable for their base classes. Dependencies should be on abstractions rather than concretions, and interfaces should be client-specific rather than general. Managing complexity means managing dependencies through high abstraction, single-responsibility classes, and other principles that promote designs that are clean, simple, and elegant.
Software Design Principles (SOLID)
SOLID Principles
- Single Responsibility Principle (SRP)
- Open/Closed Principle (OCP)
- Liskov Substitution Principle (LSP)
- Interface Segregation Principle (ISP)
- Dependency Inversion Principle (DIP)
Brief Definition of Other Design Principles
Principios solid con c#
This document discusses the SOLID principles of object-oriented design in C#, including Single Responsibility Principle, Open-Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. It provides a brief definition of each principle and indicates there will be coding examples to demonstrate each one. The author thanks the reader at the end.
Inversion of Control
This paper briefly talks about SOLID design principles. It aims to discuss the implementation of IoC to invert dependencies. The paper explains Dependency Injection, its types and building IoC Containers in detail.
Solid principes
This is a small recap of different SOLID principles.
The slides do not have much comments but if you follow the link, you will get all the examples and they are self explanatory.
Design poo my_jug_en_ppt
The document discusses object-oriented design principles and patterns. It covers topics like encapsulation, inheritance, polymorphism, the open-closed principle (OCP), dependency inversion, and architectural patterns like layered architectures and domain-driven design. Examples are provided to illustrate concepts like dependency injection and inversion of control. The conclusion emphasizes applying principles pragmatically based on user needs while aiming for maintainable code.
Solid principles, Design Patterns, and Domain Driven Design
This document discusses SOLID principles and design patterns. It begins by explaining SOLID, which stands for five principles of object-oriented design: single responsibility, open/closed, Liskov substitution, interface segregation, and dependency inversion. It then defines and provides examples of several classic design patterns like singleton, strategy, decorator, factory method, and observer. The document emphasizes that SOLID principles and design patterns help create flexible and reusable code that is easy to modify without breaking existing functionality. It also discusses domain-driven design and techniques like dependency injection that can be used to apply SOLID and design patterns.
Solid principles
SOLID is a mnemonic device for 5 design principles of object-oriented
programs (OOP) that result in readable, adaptable, and scalable code.
S - Single Responsibility Principle.
O - Open Closed Principle.
L - Liskov Substitution Principle.
I - Interface Segregation Principle.
D - Dependency Inversion Principle.
Solid OO & Clean Coding is essential to successful Agile development
some principles I have learned from people far cleverer than I, that will help design software that will remain maintainable in an agile environment
Solid
The document discusses the SOLID principles of object-oriented design, which are a set of five design principles intended to make software designs more understandable, flexible and maintainable. It defines each principle: single responsibility, open/closed, Liskov substitution, interface segregation, and dependency inversion. Following these principles helps produce code that is less complex, more readable, extensible, maintainable and reusable with looser coupling between modules and better testability compared to code not following these principles.
Object Oriented Concepts and Principles
This document discusses object-oriented design principles including encapsulation, abstraction, inheritance, polymorphism, and decoupling. It then introduces the SOLID principles of object-oriented design: single responsibility principle, open/closed principle, Liskov substitution principle, interface segregation principle, and dependency inversion principle. Code examples are provided to demonstrate how to apply these principles and improve code maintainability, reusability, and testability.
Similar to CodeCamp Iasi 10 march 2012 - Scratching-SOLID (20)
Solid principles, Design Patterns, and Domain Driven Design
Solid principles, Design Patterns, and Domain Driven Design
Solid OO & Clean Coding is essential to successful Agile development
Solid OO & Clean Coding is essential to successful Agile development
More from Codecamp Romania
Cezar chitac the edge of experience
This document discusses experience and decision making through three case studies. In Case I, decisions were made hastily under time constraints, resulting in fragile code. Case II involved choosing a database, where Cassandra proved better than the initial choice of MySQL. Case III showed benefits of thorough understanding and high test coverage leading to better outcomes. The conclusion advocates questioning assumptions, respecting experience stages, and using diverse teams to gain different perspectives for improved decision making at the "edge of experience."
Cloud powered search
This document discusses cloud powered search using Azure Search. It begins with an introduction to search engines and how they work using indexing and relevance scoring. Lucene is presented as an example open source search library. The document then covers how Azure Search works as a managed search service, including indexing data from sources like SQL databases, performing CRUD operations, querying, filtering, faceting and highlighting results. Scaling and storage capabilities of Azure Search are also discussed. Examples of using Azure Search for online retail/ecommerce and user generated content are provided.
Ccp
This document discusses important leadership concepts for junior developers to understand early in their careers, including:
- Leadership is not defined by formal authority but by influence through trust, communication, and belonging.
- As a junior, constantly contributing to the team and product, communicating when extra support is needed, and understanding the bigger picture can help you develop leadership skills.
- Small actions can have ripple effects, so it's important to consider how your work may impact others.
Business analysis techniques exercise your 6-pack
Cristian Leon presents six techniques that business analysts can use to better perform their role: (1) Planning, such as using a requirements management plan and RACI matrix; (2) Listening actively to stakeholders; (3) Mind mapping and brainstorming to map concepts; (4) Analyzing requirements using techniques like MoSCoW prioritization; (5) Creating artifacts like user stories with details like acceptance criteria; and (6) Keeping requirements visible and understood by stakeholders through ongoing communication. The presentation aims to help business analysts and those wanting to be analysts exercise their "6-pack" of analysis skills.
Bpm company code camp - configuration or coding with pega
This document discusses configuration vs coding in Pega and provides an overview of the Pega platform. It introduces the presenters and describes what is needed to run Pega including an operating system, application server, and database. The Pega environment is modeled and executes flows using a business rules engine and rules are assembled into Java at runtime. Situational processes are built in frameworks and specialized in frameworks and implementations. Directly capturing objectives can model processes, close the gap between business and IT, and automatically transform objectives into executable Java to automate work.
Andrei prisacaru takingtheunitteststothedatabase
This document outlines an agenda for a presentation with 5 chapters covering contact information, tools for database development and testing, usage of those tools, providing proof of their effectiveness, and closing with a question and answer session. Chapter 1 discusses issues with database development. Chapter 2 introduces tools to help solve problems. Chapter 3 demonstrates creating database and unit test projects, adding tests, and testing transactional behavior. Chapter 4 discusses proving the value of these tools. Chapter 5 allows for questions.
Agility and life
The document discusses agility in life and relationships on micro and middle levels. It argues that an agile approach to life involves experimentation, trust, giving freedom and space to others, focusing on solutions rather than blame, and prioritizing value to "customers" like family and friends through continuous effort. Key aspects of agility include diversity, shared goals, responsibility, courage to change, and appreciating different perspectives. Applying agile principles like experimentation, trust and encouragement can help people and teams grow.
2015 dan ardelean develop for windows 10
This document provides an overview and agenda for developing Windows 10 apps, covering topics like the new Windows Core, universal app platform, app-to-app communications enhancements, and the Action Center for managing notifications. It demonstrates new controls like the RelativePanel and MonthCalendar, and how to use the SplitView control. It also shows how to check for capabilities, target platform versions, and use platform extensions.
The bigrewrite
The document discusses the challenges of deciding whether to rewrite an existing codebase from scratch or work with the legacy code. It outlines reasons for not working with the existing code, such as missing documentation or tools. It also notes potential issues with rewriting from scratch, such as the impact on other teams and office politics. The document recommends starting by automating infrastructure and tests, learning the essential business concepts, and trying to introduce incremental changes to the legacy code before deciding to fully rewrite it.
The case for continuous delivery
The document discusses the benefits of adopting continuous delivery (CD) principles for software development. It outlines how CD can (1) create a repeatable, reliable release process that automates tasks, (2) empower teams through shared responsibility and increased collaboration, and (3) provide business value through faster feedback, consistent processes, and lower costs. While initial costs may increase for training and new tools, CD can ultimately shift costs from releases to other activities and deliver software faster. The document provides a sample deployment pipeline and maturity model, and discusses managing expectations for change when adopting CD practices.
Stefan stolniceanu spritekit, 2 d or not 2d
SpriteKit is a framework for building 2D games and graphics-intensive apps. It provides nodes for sprites, shapes, particles, video and more. SpriteKit handles animation, physics simulation and the game loop. Key features include sprite nodes, emitter nodes, actions for animation, a physics engine, and scenes to display content in the game world.
Sizing epics tales from an agile kingdom
The knights in the Agile Kingdom faced challenges sizing epics due to their variable size, complexity, and uncertainty. They developed two recipes - the Blue Recipe which involved planning poker and multiplication, and the Green Recipe which broke down an epic into user stories first. However, neither scale worked well for very large epics. They adapted by using a recently sized existing epic as a benchmark and rescaling. This allowed them to estimate the sizes of three sample epics as 5, 8, and 20 epic points, providing high-level sizing while addressing the issues of comparing variable epics.
Scale net apps in aws
This document discusses how to auto scale .NET applications in Amazon Web Services. It covers key concepts like scalability versus auto scaling, using a load balancer and solving session issues for web applications, and monitoring applications to enable auto scaling. The document provides an example of scaling an application from 2 web servers and 3 application servers in 2012 to 3 SQL servers and more elastic resources like SQS and ElastiCache by 2015. It also discusses best practices for auto scaling like using out-of-process sessions, log collection, and setting CloudWatch alarms to trigger auto scaling rules.
Raluca butnaru corina cilibiu the unknown universe of a product and the cer...
The document discusses different types of unknowns that can exist for a product including the unknown universe of the product, the certainty nebula, and the unknown unknowns. It also mentions requirements, coding, design, testing, end users, and arrogance. The bottom of the document provides some additional short phrases and includes a link to a Forbes article about what factors can impact companies.
Parallel & async processing using tpl dataflow
This document discusses parallel and asynchronous processing using the Task Parallel Library (TPL) Dataflow. It introduces dataflow as an actor-based programming model for creating data processing pipelines with in-process message passing. TPL Dataflow provides blocks like SourceBlock, TargetBlock, and PropagatorBlock that can be composed into pipelines. It offers benefits like effortless use of multithreading and performance boosts. Examples of where dataflow is useful include robotics, manufacturing, imaging, biology, oil and gas, and finance.
Material design screen transitions in android
This document discusses different techniques for animating screen transitions between Android activities. It covers 8 stages: 1) the default animation, 2) measuring views, 3) removing defaults, 4) setting initial positions, 5) animating to the final position, 6) reversing the animations, 7) using Lollipop screen transitions, and 8) setting custom content entrance and exit transitions. Code examples are provided for each stage and the full code is available on GitHub.
Kickstart your own freelancing career
The document provides tips for starting a freelancing career with no clients or experience. It recommends experimenting daily until finding a client ("getting the fish"), using sites like HackHands and UserTesting to find and attract clients, treating each project like driving a taxi where the goal is to start moving and find a solution, putting the client's needs first with fast responses and over-delivering on promises, genuinely caring about client success, and maintaining high standards while also enjoying financial prosperity.
Ionut grecu the soft stuff is the hard stuff. the agile soft skills toolkit
Ionut grecu the soft stuff is the hard stuff. the agile soft skills toolkit
Ecma6 in the wild
The document discusses ECMAScript 6 (ES6), the next version of JavaScript. It summarizes the new features in ES6 like classes, block scope, arrow functions, and spread/rest operators. It describes the speaker's experience using ES6 in a project since December 2014 by transpiling ES6 code to ES5 using Babel. Key challenges discussed are the learning curve to adopt new syntax and convincing teammates. Features currently used in the project are listed as arrow functions, let, template strings, and default parameters. The document concludes by noting the need to keep adapting to new standards released annually and resources for learning more about ES6 and ES7.
Diana antohi me against myself or how to fail and move forward
This document discusses mindset and how beliefs about intelligence and ability can impact learning and growth. It describes the differences between a fixed mindset, where intelligence is seen as static, and a growth mindset, where intelligence is viewed as malleable. A growth mindset believes that effort and practice can improve abilities over time. The document encourages adopting a growth mindset to overcome challenges through learning from mistakes and setting learning goals rather than performance goals. It advocates failing productively by remaining hopeful and keeping efforts focused on improvement.
More from Codecamp Romania (20)
Bpm company code camp - configuration or coding with pega
Bpm company code camp - configuration or coding with pega
Raluca butnaru corina cilibiu the unknown universe of a product and the cer...
Raluca butnaru corina cilibiu the unknown universe of a product and the cer...
Ionut grecu the soft stuff is the hard stuff. the agile soft skills toolkit
Ionut grecu the soft stuff is the hard stuff. the agile soft skills toolkit
Diana antohi me against myself or how to fail and move forward
Diana antohi me against myself or how to fail and move forward
Recently uploaded
GraphSummit Singapore | Neo4j Product Vision & Roadmap - Q2 2024
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
Pushing the limits of ePRTC: 100ns holdover for 100 days
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
Communications Mining Series - Zero to Hero - Session 1
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
UiPath Test Automation using UiPath Test Suite series, part 5
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
20 Comprehensive Checklist of Designing and Developing a Website
Dive into the world of Website Designing and Developing with Pixlogix! Looking to create a stunning online presence? Look no further! Our comprehensive checklist covers everything you need to know to craft a website that stands out. From user-friendly design to seamless functionality, we've got you covered. Don't miss out on this invaluable resource! Check out our checklist now at Pixlogix and start your journey towards a captivating online presence today.
Climate Impact of Software Testing at Nordic Testing Days
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?
ABSTRACT: A prima vista, un mattoncino Lego e la backdoor XZ potrebbero avere in comune il fatto di essere entrambi blocchi di costruzione, o dipendenze di progetti creativi e software. La realtà è che un mattoncino Lego e il caso della backdoor XZ hanno molto di più di tutto ciò in comune.
Partecipate alla presentazione per immergervi in una storia di interoperabilità, standard e formati aperti, per poi discutere del ruolo importante che i contributori hanno in una comunità open source sostenibile.
BIO: Sostenitrice del software libero e dei formati standard e aperti. È stata un membro attivo dei progetti Fedora e openSUSE e ha co-fondato l'Associazione LibreItalia dove è stata coinvolta in diversi eventi, migrazioni e formazione relativi a LibreOffice. In precedenza ha lavorato a migrazioni e corsi di formazione su LibreOffice per diverse amministrazioni pubbliche e privati. Da gennaio 2020 lavora in SUSE come Software Release Engineer per Uyuni e SUSE Manager e quando non segue la sua passione per i computer e per Geeko coltiva la sua curiosità per l'astronomia (da cui deriva il suo nickname deneb_alpha).
GraphSummit Singapore | Graphing Success: Revolutionising Organisational Stru...
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
UiPath Test Automation using UiPath Test Suite series, part 6
Welcome to UiPath Test Automation using UiPath Test Suite series part 6. In this session, we will cover Test Automation with generative AI and Open AI.
UiPath Test Automation with generative AI and Open AI webinar offers an in-depth exploration of leveraging cutting-edge technologies for test automation within the UiPath platform. Attendees will delve into the integration of generative AI, a test automation solution, with Open AI advanced natural language processing capabilities.
Throughout the session, participants will discover how this synergy empowers testers to automate repetitive tasks, enhance testing accuracy, and expedite the software testing life cycle. Topics covered include the seamless integration process, practical use cases, and the benefits of harnessing AI-driven automation for UiPath testing initiatives. By attending this webinar, testers, and automation professionals can gain valuable insights into harnessing the power of AI to optimize their test automation workflows within the UiPath ecosystem, ultimately driving efficiency and quality in software development processes.
What will you get from this session?
1. Insights into integrating generative AI.
2. Understanding how this integration enhances test automation within the UiPath platform
3. Practical demonstrations
4. Exploration of real-world use cases illustrating the benefits of AI-driven test automation for UiPath
Topics covered:
What is generative AI
Test Automation with generative AI and Open AI.
UiPath integration with generative AI
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
“I’m still / I’m still / Chaining from the Block”
“An Outlook of the Ongoing and Future Relationship between Blockchain Technologies and Process-aware Information Systems.” Invited talk at the joint workshop on Blockchain for Information Systems (BC4IS) and Blockchain for Trusted Data Sharing (B4TDS), co-located with with the 36th International Conference on Advanced Information Systems Engineering (CAiSE), 3 June 2024, Limassol, Cyprus.
Alt. GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using ...
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slack
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdf
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
20240605 QFM017 Machine Intelligence Reading List May 2024
Everything I found interesting about machines behaving intelligently during May 2024
Securing your Kubernetes cluster_ a step-by-step guide to success !
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
GraphSummit Singapore | Enhancing Changi Airport Group's Passenger Experience...
Dr. Sean Tan, Head of Data Science, Changi Airport Group
Discover how Changi Airport Group (CAG) leverages graph technologies and generative AI to revolutionize their search capabilities. This session delves into the unique search needs of CAG’s diverse passengers and customers, showcasing how graph data structures enhance the accuracy and relevance of AI-generated search results, mitigating the risk of “hallucinations” and improving the overall customer journey.
20240607 QFM018 Elixir Reading List May 2024
Everything I found interesting about the Elixir programming ecosystem in May 2024
Recently uploaded (20)
GraphSummit Singapore | Neo4j Product Vision & Roadmap - Q2 2024
GraphSummit Singapore | Neo4j Product Vision & Roadmap - Q2 2024
Pushing the limits of ePRTC: 100ns holdover for 100 days
Pushing the limits of ePRTC: 100ns holdover for 100 days
Communications Mining Series - Zero to Hero - Session 1
Communications Mining Series - Zero to Hero - Session 1
UiPath Test Automation using UiPath Test Suite series, part 5
UiPath Test Automation using UiPath Test Suite series, part 5
20 Comprehensive Checklist of Designing and Developing a Website
20 Comprehensive Checklist of Designing and Developing a Website
Climate Impact of Software Testing at Nordic Testing Days
Climate Impact of Software Testing at Nordic Testing Days
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?
GraphSummit Singapore | Graphing Success: Revolutionising Organisational Stru...
GraphSummit Singapore | Graphing Success: Revolutionising Organisational Stru...
UiPath Test Automation using UiPath Test Suite series, part 6
UiPath Test Automation using UiPath Test Suite series, part 6
Alt. GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using ...
Alt. GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using ...
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slack
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slack
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdf
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdf
20240605 QFM017 Machine Intelligence Reading List May 2024
20240605 QFM017 Machine Intelligence Reading List May 2024
Securing your Kubernetes cluster_ a step-by-step guide to success !
Securing your Kubernetes cluster_ a step-by-step guide to success !
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024
GraphSummit Singapore | Enhancing Changi Airport Group's Passenger Experience...
GraphSummit Singapore | Enhancing Changi Airport Group's Passenger Experience...
CodeCamp Iasi 10 march 2012 - Scratching-SOLID
- 1. Scratching SOLID IULIAN TANASESCU-VLAD 10 / 03 / 2012
- 2. So … what is SOLID? Five basic principles of object-oriented programming and design. Single responsibility principle Open/closed principle Liskov substitution principle Interface segregation principle Dependency inversion principle
- 3. Who put them together? What do you know … it's Uncle Bob! Robert C. Martin http://objectmentor.com/omTeam/martin_r.html
- 4. SRP
- 5. SRP Every object should have a single responsibility and that responsibility should be entirely encapsulated by the class. Wikipedia Responsibility!? … not again Ah … a reason to change
- 6. SRP “a measure of how strongly-related or focused the responsibilities of a single module are” COHESION!
- 7. OCP
- 8. OCP Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification. Wikipedia Open and closed … another paradox!? New functionality can be added as new requirements are generated. Never modify the code except to correct bugs.
- 9. OCP
- 10. LSP
- 11. LSP If S is a subtype of T, then objects of type T may be replaced with objects of type S without altering any of the desirable properties of that program (correctness, task performed, etc.) Wikipedia That sounds so ... formal! Code that uses a base class must be able to substitute it with a subclass without knowing it.
- 12. ISP
- 13. ISP Once an interface has become too 'fat' it needs to be split into smaller and more specific interfaces. Wikipedia Why!? COHESION! No client should be forced to depend on methods it does not use.
- 14. DIP
- 15. DIP A. High-level modules should not depend on low-level modules. Both should depend on abstractions. B. Abstractions should not depend upon details. Details should depend upon abstractions. Wikipedia
- 16. DIP “a degree to which each program module relies on each one of the other modules” COUPLING!
- 17. Please fill in the evaluation forms Thank you!