Design concepts MANTRA – Always keep handy
There are several design principles which are around us. All focussing on these key principles.
1. Separation of Concerns: Don’t overlap your functionality and keep the functions in distinct chunks
2. Single Responsibility Principle: Each component should be responsible for handling a single feature.
3. Principle of Least Knowledge (Law of Demeter – LoD): A component should not know about the internal details of other components.
4. Don’t repeat Yourself (DRY): The functionality or logic should not be repeated in any other component.
5. Minimise Upfront Design: Only design for what is necessary and don’t exaggerate the services and over design the concepts. This might lead to complexity and excess cost.
Architectural Styles – A consolidated view
1. Client/Server: Segregates the system into two applications, where the client makes requests to the server.
2. Component-Based Architecture: Decomposes application design into reusable functional or logical components that expose well-defined communication interfaces.
3. Domain Driven: Design An object-oriented architectural style focused on modeling a business domain
and defining business objects based on entities within the business domain.
4. Layered Architecture: Partitions the concerns of the application into stacked groups (layers).
5. Message Bus: An architecture style that prescribes use of a software system that can receive and send messages using one or more communication channels, so that applications can interact without needing to know specific details about each other.
6. N-Tier / 3-Tier: Segregates functionality into separate segments in much the same way as the layered style, but with each segment being a tier located on a physically separate computer.
7. Object-Oriented: A design paradigm based on division of responsibilities for an application or system into individual reusable and self-sufficient objects, each containing the data and the behaviour relevant to the object.
8. Service-Oriented Architecture (SOA): Refers to applications that expose and consume functionality as a service using contracts and messages.
Thanks,
Yuva
Yuva's blog 