D.OOAD
What is OOAD
OOAD is a process of identifying relevant details of system and system and organizing them in such a way that reusable software constrict can be discovered.
OOAD Vs Design Patterns
OOAD is approach to analysis and find solution to real world software implementation problem.
Design patterns are collection of proven software design artifacts each of which best suited to a fundamental type of problem.
Fundamental origin of most of design patterns is some where in the root of OOPS and OOAD.
OOAD Life cycle
Requirements gathering
Customer Statement
Feature List
Talk to customer and all stack holders and collect high level statement of what software is suppose to do.
This process may take several iterations
Use Case Diagram
Use case diagram represent how system will interact with it`s surrounding
It is actually visual representation of what your system is supposed to do.
It also list down the external forces that may affect system behavior
Problem Break Down
Break your application in to smallest possible modules of similar functionality
Then identify most important features
Oder the modules in order to priority
Requirement List
Figure out low level individual requirements of each identified module
Always start with core module
Keep iterating your requirement list through your development cycle and keep fine tuning them
Iteration do not mean that you need develop new features but to keep list up to date for future releases.
Make sure they fits in one big picture.
Analysis
Application Architecture
Finalize Application Patterns
Finalize application technology stack
Domain Analysis
Domain analysis is a an approach to study any such existing system , stories and lesson learned , collection and origination of any meaningful information.
Convert Use cases to classes and objects
Use Textual analysis for identify domain objects.
Thumb Rules
Never try to solve big problem
Split large problem into smallest possible problem
Start working with small problem set one at a time and start design to delivery iteration.
Always prefer to start with the feature (Problem Set) that is architecturally most significant
Always Defer Details (such as cosmetic issues) as long as you can
In early development cycle never pickup the feature does not contribute to reduce risk.
Hold on writing code as long as you can.
Avoid writing custom code as long as you can
Design
Defines classes and Behavior and interrelationship
Object Object Oriented Concepts
Abstraction
Encapsulation
Polymorphism
Inheritance
Defines Objects and interrelation ships
Apply Object Oriented Principles
Open Close Principle (OCP)
Classes should be closed for modification and open for extension.
It recommend to program to interface (or abstract abstract version).
Single Responsibility Principle (SRP)
There should be only one reason to change
Encapsulate what varies.
Prefer High Cohesion (single responsibility) and low coupling
Always do a Commonality Vs Variability analysis while identifying Classes in your system
Don`t Repeat yourself
Never write even single line of duplicate code , make them a shared code
Liskov substitution principle (LSP)
Subclass(derived class) must be behaviorally equal to their base types.
Any overriding violates this principle to avoid overriding as long as you can.
It recommend to prefer Delegation over Inheritance if you do not need to modify the behavior of other class.
It recommend to prefer Composition over Aggregation
Prefer Property Map instead of inheritance
Inheritance should be last option for extension
This is very important principle that if applied correctly then eliminate lot of problems so apply it very carefully.
Apply patterns
Finalize Development Pattern
Use Case driven
Feature Driven Development
Test Driven Development
Programming Pattern
Contractual Programming
It assumes other developer and third parties will obey the contract that may not always true.
Defensive Programming
it never believe in other code and protect it self as much as it can.
However it cause overhead so a right balance need to be find between contractual and defensive programming
Finalize Programming Model
Procedural , APM, CEP, EPM
Note: Most of the time programming patterns are driven by underlying development technology, for example Silverlight only supports APM.
Implementation
Do coding and development
Develop and execute Unit Testing
Initial Delivery and end used feedback
With user feedback go back to requirement phase if you feel so
It is not required to accommodate all the end user feedback immediately but to keep adding analysing them in back log list keep the door open.
Change Analysis
Expose your software/developed features to possible changes
Collate result of impact analysis.
Revisit your design and go back to design phase.
Keep repeating till it looks good.
Final Integration and testing
Final Delivery
Notes