Software design process
Software design is generally considered a two-step process:
Architectural design
Architectural design describes how software is decomposed and organized into components (the software architecture).
Detailed design
Detailed design describes the specific behavior of these components. The output of this process is a set of models and artifacts that record the major decisions that have been taken.
Enabling techniques
According to the Oxford English Dictionary, a principle is “a basic truth or a general law … that is used as a basis of reasoning or a guide to action”. Software design principles, also called enabling techniques, are key notions considered fundamental to many different software design approaches and concepts.
Abstraction
Abstraction is “the process of forgetting information so that things that are different can be treated as if they were the same”. In the context of software design, two key abstraction mechanisms are parameterization and specification. Abstraction by specification leads to three major kinds of abstraction: procedural abstraction, data abstraction, and control (iteration) abstraction.
Coupling and cohesion
Coupling is defined as the strength of the relationships between modules, whereas cohesion is defined by how the elements making up a module are related.
Decomposition and modularization
Decomposing and modularizing large software into a number of smaller independent ones, usually with the goal of placing different functionalities or responsibilities in different components.
Encapsulation/information hiding
Encapsulation/information hiding means grouping and packaging the elements and internal details of an abstraction and making those details inaccessible.
Separation of interface and implementation
Separating interface and implementation involves defining a component by specifying a public interface, known to the clients, separate from the details of how the component is realized.
Sufficiency, completeness and primitiveness
Achieving sufficiency, completeness, and primitiveness means ensuring that a software component captures all the important characteristics of an abstraction, and nothing more.
Software structure and architecture
In its strict sense, a software architecture is “a description of the subsystems and components of a software system and the relationships between them”. Architecture thus attempts to define the internal structure -according to the Oxford English Dictionary, “the way in which something is constructed or organized” - of the resulting software. During the mid-1990s, however, software architecture started to emerge as a broader discipline involving the study of software structures and architectures in a more generic way. This gave rise to a number of interesting ideas about software design at different levels of abstraction. Some of these concepts can be useful during the architectural design (for example, architectural style) of specific software, as well as during its detailed design (for example, lower-level design patterns). But they can also be useful for designing generic systems, leading to the design of families of programs (also known as product lines). Interestingly, most of these concepts can be seen as attempts to describe, and thus reuse, generic design knowledge.