Introduction for Application Frameworks.

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.

"An application is a software library that provides a fundamental structure to
support the development of applications for a specific environment not only for
graphical user interface development but also for areas like web based applications."

S.O.L.I.D

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.