There are 5 objected oriented principles called S.O.L.I.D which we should consider when we designing a software.
* S — Single responsibility (means that a class/method/function etc. should have only one response)
* O — Open-close (means that object or entities should be open for extension, but closed for modification)
* L — Liskov substitution (means that every subclass/derived class should be able to substitute their parent/base class)
* I — Interface segregation (means clients should not be forced to implement methods they do not use)
* D — Dependency inversion (means that higher level modules should not depend on lower level modules, but they should depend on abstractions)
In software engineering field we always try to seek solutions for real world problems to ease the day-to-day life activities. To achieve those solutions,
there are few tasks that we can try.
* Think throughout the problem
* Devide and conquer
* Learn from mistakes
* Remember why software exists
* Remember that you are not the user
Then we have to implement the designed solution and there are few guidlines for the implementation as well.
* YAGNI (You ain’t gonna need it) — means to wite the code that we need only for the moment
* DRY (Don’t repeat yourself) — means to reuse the code which we implemented before without rewrite it
* Embrace abstraction — we should make sure that our system doesn’t know the every component part of implementation details
* DRITW (Don’t reinvent the wheel) — If our solutions have been already solved by someone else, it’s useless
* Write code that does one thing well —
* Debugging is harder than writing code
* Kaizen — We can succeed only we should be able to solve the real problem even upto some level
— — — — —
— — — — —