Software design is the process of transforming software requirements into a structured solution that describes how the system will be organized and implemented.
A good software design divides a complex system into manageable parts and defines how those parts interact. Important software design concepts include abstraction, modularity, information hiding, refinement, functional independence, cohesion, and coupling.
These concepts are frequently used in Software Engineering examinations because they help explain why one software design is easier to understand, maintain, test, and modify than another.
What Is Software Design? #
Software design converts the requirements of a system into a blueprint for implementation.
During software design, developers determine:
- What components the system should contain
- What responsibilities each component should have
- How components communicate
- How data is organized
- How users interact with the system
- How the system can be modified and maintained
For example, an online banking system may be divided into modules such as authentication, account management, transaction processing, notifications, and reporting.
Major Software Design Concepts #
1. Abstraction #
Abstraction means focusing on the important characteristics of an entity while ignoring unnecessary implementation details.
It allows developers to manage complexity by considering a system at different levels of detail.
Real-Life Example #
When using an ATM, a user sees options such as:
- Withdraw money
- Deposit money
- Check balance
- Transfer money
The user does not need to know how the bank’s database queries, authentication mechanisms, network communication, or transaction processing work internally.
The ATM interface provides an abstraction of the underlying banking system.
Types of Abstraction #
In software engineering, abstraction can be considered at different levels.
Data Abstraction #
Data abstraction hides the internal representation of data and exposes only the operations required to use it.
For example, a stack can provide operations such as push() and pop() without exposing how the stack is internally implemented.
Procedural Abstraction #
Procedural abstraction allows a complex operation to be represented by a meaningful procedure or function.
For example, a function called calculateSalary() may hide the detailed calculations performed internally.
2. Modularity #
Modularity means dividing a software system into smaller, manageable units called modules.
Each module should have a well-defined responsibility.
For example, an e-commerce application can be divided into:
- User Management
- Product Management
- Shopping Cart
- Order Management
- Payment
- Notification
Instead of dealing with one huge program, developers can work with smaller modules.
Advantages of Modularity #
- Makes the system easier to understand.
- Allows different developers to work on different modules.
- Makes testing easier.
- Improves maintainability.
- Supports software reuse.
- Helps isolate changes.
3. Information Hiding #
Information hiding is a design principle in which the internal implementation details of a module are hidden from other modules.
Other modules interact with the module through a defined interface rather than directly accessing its internal implementation.
Real-Life Example #
Consider a payment module.
Other parts of an application may call:
processPayment(amount)
They do not need to know whether the payment module internally uses a particular API, database operation, encryption method, or transaction mechanism.
If the internal implementation changes while the public interface remains compatible, other modules may not need to change.
Information Hiding vs Abstraction #
| Abstraction | Information Hiding |
|---|---|
| Focuses on what is important | Focuses on hiding implementation details |
| Reduces unnecessary complexity | Protects design decisions from external modules |
| Provides a simplified view | Controls what other modules can know or access |
| Example: ATM interface | Example: hiding payment-processing implementation |
4. Refinement #
Refinement is a step-by-step process of moving from a high-level description of a system toward a more detailed design.
The high-level requirement is gradually decomposed into smaller and more specific operations.
Example #
Consider the high-level requirement:
Process an online order.
This can be refined into:
- Validate customer
- Validate products
- Calculate total price
- Calculate delivery charges
- Process payment
- Create order
- Send confirmation
Each step can then be refined further if necessary.
5. Functional Independence #
Functional independence means designing modules so that each module performs a well-defined responsibility and has minimal dependence on other modules.
Functional independence is strongly associated with two important concepts:
- High Cohesion
- Low Coupling
A good software design generally aims for high cohesion and low coupling.
6. Cohesion #
Cohesion describes how closely related the responsibilities within a module are.
A module with high cohesion performs closely related tasks.
A module with low cohesion performs unrelated or loosely related tasks.
Example of High Cohesion #
Consider a module called Payment Processing.
It handles:
- Payment validation
- Payment processing
- Payment status
- Payment confirmation
These responsibilities are closely related, so the module has relatively high cohesion.
Example of Low Cohesion #
Suppose one module handles:
- Payment processing
- Student registration
- Generating reports
- Sending emails
These activities are unrelated, so the module has low cohesion.
7. Coupling #
Coupling represents the degree of dependency between software modules.
When one module depends heavily on the internal details of another module, the coupling is high.
When modules communicate through simple and well-defined interfaces with minimal dependency, coupling is low.
Example of Low Coupling #
Suppose an application uses a payment interface:
processPayment(amount)
The order module only needs to request payment processing. It does not need to know the internal implementation of the payment service.
This reduces dependency between the modules.
Cohesion and Coupling #
| Concept | Meaning | Preferred Design |
|---|---|---|
| Cohesion | Relationship among responsibilities inside a module | High cohesion |
| Coupling | Dependency between modules | Low coupling |
Exam rule: Good software design generally aims for high cohesion and low coupling.
Why High Cohesion Is Preferred #
A highly cohesive module focuses on a specific and closely related set of responsibilities.
This can make the module:
- Easier to understand
- Easier to test
- Easier to maintain
- Easier to reuse
- Easier to modify
Why Low Coupling Is Preferred #
Low coupling reduces dependencies between modules.
If one module changes, fewer other modules may need to be modified.
This can improve:
- Maintainability
- Testability
- Reusability
- Flexibility
- Changeability
Real-Life Example: College Management System #
Consider a college management system containing modules for students, examinations, fees, attendance, and notifications.
A good design could separate these responsibilities:
- Student Module – manages student information.
- Examination Module – manages examinations and results.
- Fee Module – manages fee transactions.
- Attendance Module – manages attendance records.
- Notification Module – manages notifications.
Each module has a focused responsibility, giving the system better modularity and cohesion.
Important Software Design Principles #
Separation of Concerns #
Different concerns of a system should be separated so that each part has a clear responsibility.
Modularity #
The system should be divided into manageable modules.
Abstraction #
Unnecessary implementation details should be hidden behind simpler interfaces.
Information Hiding #
Internal design decisions should be protected from unnecessary dependencies.
Functional Independence #
Modules should perform focused responsibilities and minimize dependencies on other modules.
Exam-Oriented Comparison #
| Concept | Key Idea |
|---|---|
| Abstraction | Show essential information and hide unnecessary complexity |
| Modularity | Divide the system into modules |
| Information Hiding | Hide internal implementation details |
| Refinement | Move from high-level design to detailed design |
| Cohesion | Measure how closely related responsibilities within a module are |
| Coupling | Measure dependency between modules |
| Functional Independence | Achieved through high cohesion and low coupling |
Important Points for UGC NET, DRDO, ISRO and Other Exams #
- Good design generally aims for high cohesion.
- Good design generally aims for low coupling.
- Cohesion is concerned with relationships within a module.
- Coupling is concerned with relationships between modules.
- Abstraction focuses on essential characteristics while ignoring unnecessary details.
- Information hiding hides internal implementation details from other modules.
- Modularity divides a system into manageable modules.
- Refinement moves from a high-level description toward greater implementation detail.
- Functional independence is supported by high cohesion and low coupling.
- Good modular design generally improves maintainability and understandability.
Common Exam Confusions #
Cohesion vs Coupling #
Cohesion = within a module.
Coupling = between modules.
Abstraction vs Information Hiding #
Abstraction focuses on what an entity does or what is essential, while information hiding focuses on preventing other modules from depending on internal implementation details.
High Cohesion vs Low Cohesion #
High cohesion means the responsibilities of a module are strongly related. Low cohesion means the module contains unrelated or weakly related responsibilities.
High Coupling vs Low Coupling #
High coupling means modules are strongly dependent on each other. Low coupling means dependencies are minimized.
Frequently Asked Questions #
What is the main objective of software design? #
The objective is to transform requirements into a structured solution that defines the system’s components, responsibilities, data, interfaces, and interactions.
What is cohesion in software engineering? #
Cohesion measures how closely related the responsibilities within a module are.
What is coupling in software engineering? #
Coupling measures the degree of dependency between software modules.
What is the ideal combination of cohesion and coupling? #
A commonly preferred design is high cohesion and low coupling.
What is information hiding? #
Information hiding is a design principle in which internal implementation details are hidden from other modules and access is provided through appropriate interfaces.
Quick Revision #
Software Design → Abstraction + Modularity + Information Hiding + Refinement + Functional Independence
Functional Independence → High Cohesion + Low Coupling
Cohesion → Within a module
Coupling → Between modules
Conclusion #
Software design concepts provide the foundation for creating software that is easier to understand, test, modify, and maintain. Abstraction, modularity, information hiding, refinement, cohesion, and coupling are especially important because they help control software complexity.
For competitive examinations, the most important relationship to remember is:
High Cohesion + Low Coupling = Better Functional Independence.
