The document provides an overview of object-oriented design (OOD) principles and patterns. It discusses why OOD simplifies system evolution and defines common design vocabulary. It also covers the OOD process, principles like single responsibility and dependency inversion. Specific design patterns are explained like observer, strategy and proxy. Enterprise patterns for domain logic and architecture like MVC, SOA, and onion architecture are also summarized.
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.
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.
A quick-and-dirty introduction to Design Smells, as presented in Robert 'Uncle Bob' Martin book "Agile Software Development". Thought as the first of a series.
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 Principles of Refactoring Presentation - Inland Empire User GroupAdnan Masood
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.
SOLID Design Principles applied in JavaIonut Bilica
Video: https://www.youtube.com/watch?v=0cU-4LrcWI0
SOLID Design Principles applied in Java: rules to develop scalable and easily maintainable code
Speaker: Ionut Bilica - Senior Software Developer @ Luxoft Romania.
During this talk we will discuss about the SOLID Principles described by Robert C. Martin, applying them in the Java programming language. Each principle will be explained in detail, with practical Java examples.
We will asses how these principles make it easy to develop the software for the entire duration of the project, and how some problems can appear if these principles are not applied. We will present common code fragments that do not respect these principles, and we'll see how we can correct them. Taking the SOLID principles into consideration, we will also analyse a real Java project using a Static Code Analyzer tool (e.g. STAN).
Finally, we will discuss the strategies on how to apply these design principles in "greenfield" projects, as well as "legacy" projects, while offering some tips and tricks.
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.
One reasonable definition of good design is testability. It is hard to imagine a software system that is both testable and poorly designed. It is also hard to imagine a software system that is well designed but also untestable.
I'll talk you through how bad design may affect testability. We will learn how to design robust tests which are not just increasing code coverage but are bringing real value to your project.
Finally we will explore the best way to integrate these tests to your continuous integration environment so they will be acting as top class guards against sloppy commits.
Keywords : design principles, unit tests, integration tests, stress tests, java, spring, junit @Rule, junit @Category, @RunWith, @Parameters, surefire, maven, jenkins, quality metrics, selenium , tdd, mocks, stubs, etc...
Almost everything can be done using refactoring tools:
* How to get buy-in for refactoring? (use Technical Debt quantification tools)
* How to identify refactoring candidates? (use smell detection tools)
* How to prioritize / identify what to refactor first? (use reports from design analysis tools)
* How do I identify dependencies and evaluate impact of refactoring? (use visulization tools)
* How to I actually perform refactoring? (Use IDE support for automated refactoring and use them!)
Deriving from a rich experience in using tools for refactoring in real-world projects, this talk takes you through a whirl-wind tour of refactoring tools (of course for Java). What's more, this talk includes quick demos of some of these tools so you can see them in action.
Presented in BoJUG meetup on 19th Jan in Bangalore - https://www.meetup.com/BangaloreOpenJUG/events/257183518/
For my programming course at University of Berne I had to shortly talk about dependencies and how we handle them. I features some Inversion of Control methods and the DI framework Guice from Google.
Let us first start with some basics of C++ programming language and understand briefly what Design Patterns are and why they are so cool.
The slides below explain the C++ features first, followed by an introduction to Design Patterns in software architecture. These are still in outline form. But, considering that the content may be of value to several readers in the software engineering industry, I wanted to get the information out first.
A quick-and-dirty introduction to Design Smells, as presented in Robert 'Uncle Bob' Martin book "Agile Software Development". Thought as the first of a series.
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 Principles of Refactoring Presentation - Inland Empire User GroupAdnan Masood
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.
SOLID Design Principles applied in JavaIonut Bilica
Video: https://www.youtube.com/watch?v=0cU-4LrcWI0
SOLID Design Principles applied in Java: rules to develop scalable and easily maintainable code
Speaker: Ionut Bilica - Senior Software Developer @ Luxoft Romania.
During this talk we will discuss about the SOLID Principles described by Robert C. Martin, applying them in the Java programming language. Each principle will be explained in detail, with practical Java examples.
We will asses how these principles make it easy to develop the software for the entire duration of the project, and how some problems can appear if these principles are not applied. We will present common code fragments that do not respect these principles, and we'll see how we can correct them. Taking the SOLID principles into consideration, we will also analyse a real Java project using a Static Code Analyzer tool (e.g. STAN).
Finally, we will discuss the strategies on how to apply these design principles in "greenfield" projects, as well as "legacy" projects, while offering some tips and tricks.
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.
One reasonable definition of good design is testability. It is hard to imagine a software system that is both testable and poorly designed. It is also hard to imagine a software system that is well designed but also untestable.
I'll talk you through how bad design may affect testability. We will learn how to design robust tests which are not just increasing code coverage but are bringing real value to your project.
Finally we will explore the best way to integrate these tests to your continuous integration environment so they will be acting as top class guards against sloppy commits.
Keywords : design principles, unit tests, integration tests, stress tests, java, spring, junit @Rule, junit @Category, @RunWith, @Parameters, surefire, maven, jenkins, quality metrics, selenium , tdd, mocks, stubs, etc...
Almost everything can be done using refactoring tools:
* How to get buy-in for refactoring? (use Technical Debt quantification tools)
* How to identify refactoring candidates? (use smell detection tools)
* How to prioritize / identify what to refactor first? (use reports from design analysis tools)
* How do I identify dependencies and evaluate impact of refactoring? (use visulization tools)
* How to I actually perform refactoring? (Use IDE support for automated refactoring and use them!)
Deriving from a rich experience in using tools for refactoring in real-world projects, this talk takes you through a whirl-wind tour of refactoring tools (of course for Java). What's more, this talk includes quick demos of some of these tools so you can see them in action.
Presented in BoJUG meetup on 19th Jan in Bangalore - https://www.meetup.com/BangaloreOpenJUG/events/257183518/
For my programming course at University of Berne I had to shortly talk about dependencies and how we handle them. I features some Inversion of Control methods and the DI framework Guice from Google.
Let us first start with some basics of C++ programming language and understand briefly what Design Patterns are and why they are so cool.
The slides below explain the C++ features first, followed by an introduction to Design Patterns in software architecture. These are still in outline form. But, considering that the content may be of value to several readers in the software engineering industry, I wanted to get the information out first.
The presentation contain the Thinking about Thinking and Language.
The process of thinking, types, problem solving, various bias, linguistic theories of thinking are included.
Solving a “Transportation Planning” Problem through the Programming Language “C”Shahadat Hossain Shakil
Solving a “Transportation Planning” problem through the programming language “C”
Presented by
Yousuf Mahid (0615012)
Shahadat Hossain Shakil (0615020)
Khadija Akhter (0615027)
Visualization of Hajime Yoshino’s Logical Jurisprudence. IRIS 2017Vytautas Čyras
Presentation to publication In: E. Schweighofer, F. Kummer, W. Hötzendorfer, C. Sorge (eds.) Trends and Communities of Legal Informatics. Proceedings of the 20th International Legal Informatics Symposium IRIS 2017, 23–25 February 2017, Salzburg, pp. 349–358. OCG, Vienna. ISBN 978-3-903035-15-7. Also in online journal Jusletter IT, Die Zeitschrift für IT und Recht, 23 February 2017, ISSN 1664-848X, Editions Weblaw, http://jusletter-it.weblaw.ch/issues/2017/IRIS.html. (Peer reviewed – Jury LexisNexis Best Paper Award IRIS2017).
ABSTRACT. Hajime Yoshino’s Logical Jurisprudence (LJ) is an important concept in legal infor-matics. Yoshino aims for a logic-based systematization in the legal domain. He focuses on legal reasoning and systematization. Inevitably, embracing law as a whole brings us to Hans Kelsen’s Pure Theory of Law. In sum, three issues are important in LJ: logic, Kelsen and legal informatics. In this paper we aim to visualize the architecture of LJ. We suggest expanding this with legal ontologies and words. The granularity of word-phrase-sentence-text is about different methods which apply to different units.
In Actors system, we can change State or Behaviors during runtime in actors. There are multiple ways for changing behaviors like conditional based and Hotswap but Finite State Machine(FSM) is the cleanest way. If we have finite number of state in our system then FSM is the good practice.
The objective is to explain how a software design may be represented as a set of interacting objects that manage their own state and operations and to introduce various models that describe an object-oriented design.
Finite State Machines are overlooked at best, ignored at worst, and virtually always dismissed. This is tragic since FSMs are not just about Door Locks (the most commonly used example). On the contrary, these FSMs are invaluable in clearly defining communication protocols – ranging from low-level web-services through complex telephony application to reliable interactions between loosely-coupled systems. Properly using them can significantly enhance the stability and reliability of your systems.
Join me as I take you through a crash-course in FSMs, using erlang’s gen_fsm behavior as the background, and hopefully leaving you with a better appreciation of both FSM and erlang in the process.
It is a mathematical modelling of computation that is extensively used for designing both computer programs as well as sequential logic circuits and can be perceived as an intellectual machine in one of a finite number of states. Copy the link given below and paste it in new browser window to get more information on Finite State Machine:- http://www.transtutors.com/homework-help/computer-science/finite-state-machines.aspx
Survive the Chaos - S4H151 - SAP TechED Barcelona 2017 - LectureRainer Winkler
Software can easily become complex and difficult to handle - join this session to learn techniques on how to manage and prevent this. You will see how test seams for ABAP simplify unit tests, even in legacy ABAP code with many dependencies. We will demonstrate an OpenSource tool to automatically generate dependency graphs and use it in projects, and the main technique for working with legacy code - writing a characterization test and using it as safety net while making changes.
This presentation was given at the SAP TechED Barcelona 2017
An introduction to Linked Open Usable Data (LOUD) through the lens of a zooming paradigm, and thoughts on how such a paradigm can help to address some grand challenges of LOUD, including search granularity, trust and reconciliation. Presented to the IDLab / Knowledge at Web Scale department of the University of Ghent in Feb '23
In this presentation, I presented how to build an angular JS Application with SPA in mind and also make sure you use up all the available concepts to create versatile and creative web application with less boilerplate javascript code.
LogiLogicless UI prototyping with Node.js | SuperSpeaker@CodeCamp Iasi, 2014Endava
Prototyping modular UI components without the backend logic and focusing more on presentational logic and user experience.
Presentation of an open source tool released as MIT to bootstrap front-end practices without relying on complicated backend environments.
Sergii Bielskyi "Azure Logic App and building modern cloud native apps"Fwdays
I would like to share my experience of using Azure Logic App as a tool to build cloud native applications as easy and fast as we can. I will explain how we can use SDKs for our needs and how to use the cloud interface to simplify the process. During the demo, I will solve the problem that often happens especially with me when I am not at home.
Well, the story will be about IoT device and how we can user Logic app to notify me when electricity is turned off. Also, I will demonstrate how we can use computer vision into the Logic App.
About us
BISP is an IT Training and Consulting Company. We are Subject Matter Experts for DHW and BI technologies. We provide Live virtual Online global IT support and services like online software training, live virtual online lab services, virtual online job support with highly intellectual professional trainers and skilled resources , predominantly In Oracle BI, Oracle Data Integrator, Hyperion Product stack, Oracle Middleware solution, Oracle SoA, AIA Informatica, IBM Datastage and IBM Cognos .
BISP has footprints virtually across USA, CANADA, UK, SINGAPORE, SAUDI ARABIA, AUSTRALIA and more by providing live virtual support services from India for fresh graduates, opt students, working professionals etc. Being a live virtual online training the support , training and service methodology is just click away considerably reducing your TIME,INFRASTRUCTURE and Cost effective.
"Different software evolutions from Start till Release in PHP product" Oleksa...Fwdays
Ця розповідь розкриє підходи для вирішення багатьох проблем в PHP проєктах через: None-Breaking change development підхід, cross-stack контракти, Trunk Based development, еволюція з Polyrepo до Monorepo з компонентами на різних технологіях, Boilerplat’и компонентів, різні Architecture View, Continuous Testing & Quality, Infrastructure View, Infrastructure as a code як основний інструмент.
PHPFrameworkDay 2020 - Different software evolutions from Start till Release ...Alexandr Savchenko
https://fwdays.com/en/event/php-fwdays-2020
All of us think about many questions when we start a project, when we already have a product and when we release it. Here are some of them: which architecture and infrastructure to choose? what should be the repository structure? how to make the right evolution from one application to 100 microservices with success product release? how to distribute cross-stack commands as a whole? what development practices to use?
This story will expose approaches to solving these and many other problems in PHP projects through: None-Breaking change development approach, Cross-stack contacts, Trunk Based development, evolution from Polyrepo to Monorepo with components on different technologies, Boilerplates for components, different Architecture Views, Continuous Testing & Quality, Infrastructure View, Infrastructure as a code as the main tool.
This topic will appeal to everyone - from Software Developer to Architect, as many Tips & Tricks will be revealed.
22. Process
Why OOP
Ability to Design Big-Ass Systems
Stability
Reusability
23. Process
OOP Principles
Objects Are Independent and Encapsulate State
Functionality is Expressed in Terms of Object Services
Objects Communicate by Message Passing
81. Reference
Books
Bishop J. - C# 3.0 Design Patterns
Design Patterns Elements of Reusable Object-Oriented Software
Mark Priestley - Practical Object-oriented Design with UML
Object-Oriented Analysis and Design Using UML. Sun microsystems
Object Oriented Design Standards. The Corelinux Consortium
Scott Millett - Professional ASP.NET Design Patterns
Elisabeth Freeman, Eric Freeman, Bert Bates, Kathy Sierra, Elisabeth Robson - Head First Design Patterns
Presentations
http://www.slideshare.net/spriebsch/advanced-oop-and-design-patterns
http://www.slideshare.net/sudarsun/object-oriented-design
http://www.slideshare.net/elfuchs/o-o-d
82. Links
Demo Code
https://github.com/yaroshevych/OnionReference
My Github and Slideshare profiles
http://yaroshevy.ch/about
Images
David Gallard http://www.flickr.com/photos/mrguep/4203634376/in/photostream/
Joanjo Aguar Matoses http://www.flickr.com/photos/joanjo_aguar_matoses/4624775173/in/photostream/
Adam Wyles http://www.flickr.com/photos/the-travelling-bum/5262087254/in/photostream/
Don Buciak II http://www.flickr.com/photos/donbuciak/5448599489/in/photostream/
David Gallard http://www.flickr.com/photos/mrguep/4202876501/in/photostream/
Francisco Gonzalez http://www.flickr.com/photos/franciscojgonzalez/8087008004/in/photostream/
David Gallard http://www.flickr.com/photos/mrguep/4203635248/in/photostream/
License
CC BY-NC-ND 2.0 http://creativecommons.org/licenses/by-nc-nd/2.0/