Hi Guys. Now I am starting a new series of tutorials. In these tutorials I will try to give you some good suggestions about how to write a good, decouple code. When, why and where use a Design Pattern. How to save your self from Anti Patterns. How and when divide your code in modules. What is the benefit of modular approach and many more…
In these tutorials, I will try to discuss things as generic, so you can use these concepts in any programming language. There is a possibility you are not agree with me for that you can comment or email me and we will discuss and update our tutorials.
A small introduction about why I choose this topic. Basically I am a student of a computer science and I am working in this field from last few years, I work with Teams where we get user requirements and I break down these into small modules and then assigns to developers and they start work on that features. What I feel as I got tasks in past or I assign tasks to other developers we always try to think only about the task and try to complete that as early as possible but I feel in these days mostly tasks we can complete with the help of internet very early and then we move to next but the issue occur when user change there requirement or after some month he needs to add some new functionality. At that time our code will be start going into bad condition. So for saving our self from these situations we need to always use Good Coding Practices. These are very helpful. According to me development is always write code for future because in present all of us do a good job on our tasks and we always face issues when we start again work on the old projects which are completed quickly without thinking .
- Module wise code
- SOLID (Class design principle)
” In computer programming, SOLID is a mnemonic acronym introduced by Michael Feathers for the “first five principles” named by Robert C. Martin in the early 2000s that stands for five basic principles of object-oriented programming and design. The principles, when applied together, intend to make it more likely that a programmer will create a system that is easy to maintain and extend over time. The principles of SOLID are guidelines that can be applied while working on software to remove code smells by causing the programmer to refactor the software’s source code until it is both legible and extensible. It is part of an overall strategy of agile and adaptive programming.” [Wikipedia]
- S – Single Responsibility Principle
- O – Open Closed Principle (Coming Soon)
- L – Liskov Substitution Principle (Coming Soon)
- I – Interface Segregation Principle (Coming Soon)
- D – Dependency Inversion Principle (Coming Soon)
- Design Patterns
- Anti Patterns (Coming Soon)