Software design has several variants that are used to address different aspects and requirements of a

software system. Some of the common variants of software design are:

1. Architectural Design:

This variation focuses on figuring out a software system's general structure and organization. It
involves choices about the high-level elements, how they work together, and who gets what
responsibility. Microservices, layered architecture, and client-server architecture are examples
of popular architectural design patterns.

2. Detailed Design: This variant involves designing the internal components, modules, and classes of a
software system. It includes decisions related to data structures, algorithms, interfaces, and
implementation details. The detailed design phase often follows the architectural design phase.

3. UI/UX Design: This variant focuses on designing the user interface and user experience of a software
application. It includes decisions related to the layout, visual elements, interactive elements, and
usability considerations. UI/UX designers often collaborate with software developers to ensure a
seamless user experience.

4. Database Design: This variant focuses on designing the structure and organization of a database
system. It includes decisions related to table schemas, relationships between tables, indexing strategies,
and query optimization. Good database design is crucial for efficient data storage and retrieval.

5. Network Design: This variant focuses on designing the network infrastructure and communication
protocols for distributed systems. It includes decisions related to network topologies, data transmission
mechanisms, security measures, and fault tolerance. Network design is particularly important for
systems that involve communication between multiple entities.

6. Security Design: This variant focuses on designing security measures and mechanisms to protect
software systems from unauthorized access, data breaches, and malicious attacks. It includes decisions
related to authentication, authorization, encryption, secure protocols, and secure coding practices.
Security design should be an integral part of the overall software design process.

These variants often overlap and complement each other, and effective software design involves
considering multiple aspects in a holistic manner. The specific variants to prioritize may vary depending
on the nature of the project, industry standards, and specific project requirements.
Five commonly used strategies:

1. Modularization:

Separate the system into manageable, stand-alone parts or modules. Every module needs to
have distinct interfaces and a specified role. This makes reusability, testing, and maintenance
simpler.

2. Separation of Concerns:

Make sure that every module or component has a single task that it completes on its own.
Better readability, maintainability, and flexibility of the codebase are made possible by this.

3. Abstraction and Encapsulation:

Hide extraneous information in complex systems through abstraction to make them simpler. By
enclosing data and activity inside objects, encapsulation creates a transparent interface while
limiting direct access to internal implementation details.

4. Loose Coupling:

By creating loose coupling between components, dependence between them can be reduced.
This makes it simpler to test, replace, and modify individual parts without compromising the
functionality of the entire system.

5. High Cohesion:

Make sure every module or component concentrates on carrying out a certain duty or task.
Better code organization, readability, and maintainability result from this.