There is a famous saying that if the base is strong the whole building is strong. The same concept applies to the software too. In my opinion, the architecture of the software is the most important building block. Architecture should be designed before the actual coding begins. The software architect should decide which pattern they should follow to build the software. There are many patterns out there we can adopt to follow in the software construction. But we should be careful that the application is not over-engineered. This can happen that you try to apply some pattern, as soon as you know about it, but that is not suitable for the subject problem. So, you should be very careful while selecting a particular pattern in your software architecture.
You should divide the whole problem into different layers. Each layer should be self contained and should the ability to communicate with other layers in order. That does not mean that the every layer should capable of communicating with non-adjacent layer. For instance, the presentation layer should not directly communicate with the data access layer. It should talk to the database layer via the business layer, in 3-tier architecture.
If the application blocks are tightly coupled, we may face some difficulty while doing unit tests. The loosely coupled classes have a major advantage over tighly coupled when the testing comes into action. The Dependency Injection is a good pattern to decouple the dependent classes. This way, your software will be maintainable and scalable and you will definitely realize after sometime.
You should divide the whole problem into different layers. Each layer should be self contained and should the ability to communicate with other layers in order. That does not mean that the every layer should capable of communicating with non-adjacent layer. For instance, the presentation layer should not directly communicate with the data access layer. It should talk to the database layer via the business layer, in 3-tier architecture.
If the application blocks are tightly coupled, we may face some difficulty while doing unit tests. The loosely coupled classes have a major advantage over tighly coupled when the testing comes into action. The Dependency Injection is a good pattern to decouple the dependent classes. This way, your software will be maintainable and scalable and you will definitely realize after sometime.
I believe this is something that every good Software Engineer knows already :) but there are always some hurdles following them
ReplyDelete1- you are feeling lazy to follow them
2- You manager wants you to develop a 3 months project in 1 week without knowing the results
3- Your company is not motivating or following and Software Architectures
I have seen couple of OVER ENGINEERED apps in my current workplace...in terms of architecture and dynamism .. its not always necessary to PULL everything from database and ultimately making your system damn slow
Ignorance is another player which kills your application. Not every software engineer know about the best patterns and practices and they build the software on poor foundation. There should be a role of software architect who already knows much about the subject and can apply the right pattern on right place.
ReplyDelete