This blog includes the principles that must be followed when designing a software and the way of
approaching and implementing the solution,before going in-depth of the designing languages.
There are 5 object oriented Principles that should be followed when designing a software.
This is know as S.O.L.I.D
I - Single responsibilities.
O - Open-Close.
L - Liskov Substitution.
I - Interface segregation.
D - Dependency inversion.
Approaching the Solution.
Implementing the Solutions.
approaching and implementing the solution,before going in-depth of the designing languages.
"An application is a software library that provides a fundamental structure toS.O.L.I.D
support the development of applications for a specific environment not only for
graphical user interface development but also for areas like web based applications."
There are 5 object oriented Principles that should be followed when designing a software.
This is know as S.O.L.I.D
I - Single responsibilities.
- Designing a class that has only one responsibility
O - Open-Close.
- The application must be closed for modification and open for extension.
L - Liskov Substitution.
- Sub-classes derived from the parent class must be able to substitute the parent class.
I - Interface segregation.
- Clients should not be forced to implement methods they do not use.These unknown methods are known as fat interfaces.
D - Dependency inversion.
- high level modules should not depend on low level modules but abstraction.
Approaching the Solution.
- Think throughout the problem - Make sure to understand the problem and clear the uncleared doubts by questioning before approaching the solution.
- Divide and Conquer - divide the problem into sub parts and make it manageable and understandable and try to approach the solution through the sub solutions.
- KISS - Keep it simple.
- Learn from mistakes - Embrace the changes and learn specially from the mistakes.
- Always remember the reason behind the software existence and that you are not gonna use the software.
Implementing the Solutions.
- YAGNI -You Ain't Gonna Need It.Do not implement methods that you do not need.If you do not need it now it wont be used in future as well.
- DRY - Do Not Repeat Yourself. Keep the code generalized and reusable.
- Embrace abstraction -
- DRITW - Do not Reinvent The Wheel.If someone has resolved the problem make use of it do not waste time.
- Write code that does one thing - do not try to overload the code,Try to implement code that do one thing correctly at one time.
- Debugging is harder than writing - Make the code readable so it can be easily debugged by the testers.
- Kaizen Fix not only the bug but also the code around,hence real problem must be hidden in the designing not in the bug.
Comments
Post a Comment