Fundamentals of Software Design: Concepts, Principles, and Modeling Languages

Software design is a process that creates specifications for software artifacts, aiming to achieve goals using a set of components under constraints.

It involves problem solving and planning solutions, including low‑level component and algorithm design as well as high‑level architecture.

Overview

Software design envisions and defines solutions for one or more problems. A major part is Software Requirements Analysis (SRA), which lists specifications used in software engineering. Depending on whether the software is user‑centered or fully automated, design may involve UX storyboards or simple flowcharts. Design can be platform‑independent or platform‑specific.

The main difference between analysis and design is that analysis outputs smaller problem statements, while design focuses on capabilities, allowing multiple designs for the same problem. Designs vary by framework or design pattern and can apply to operating systems, web, mobile, or cloud models.

Design is both a process and a model. The process consists of steps that describe various aspects of software. Successful design relies on creativity, experience, understanding of “good” software, and a commitment to quality. The design model can be compared to an architect’s house plan, showing overall structure before detailing components.

Design should not suffer from “tunnel vision”. Consider alternative methods based on problem needs and resources.

Design should be traceable to the analysis model. Elements often satisfy multiple requirements, so traceability is needed.

Do not reinvent the wheel. Reuse existing design patterns whenever possible.

Minimize the “intelligence distance” between software and the problem domain. Structure should mirror the domain.

Design should exhibit consistency and integration. Define style and format rules before work begins.

Design structure should accommodate change.

Design should degrade gracefully under abnormal conditions.

Design is not coding; coding is not design. Design decisions at the code level should only address implementation details.

Quality assessment should occur during design, not after.

Review designs to reduce semantic errors.

Design Concepts

Basic concepts that support more advanced methods include:

Abstraction – reducing information to retain only what is relevant to a purpose.

Refinement – breaking down high‑level statements into detailed programming language statements.

Modularity – dividing architecture into independent components.

Software Architecture – the overall structure that provides conceptual integrity and ROI in performance, quality, schedule, and cost.

Control Hierarchy – organization of program components and their control structures.

Structural Partitioning – horizontal (module hierarchy) and vertical (top‑down control) divisions.

Data Structure – logical relationships among data elements.

Software Process – focuses on handling each module individually.

Information Hiding – design modules so that internal information is inaccessible to other modules that do not need it.

Grady Booch’s object model highlights abstraction, encapsulation, modularity, and hierarchy as core principles, sometimes abbreviated as PHAME (Principles of Hierarchy, Abstraction, Modularity, Encapsulation).

Design Considerations

Key factors to evaluate when designing software include compatibility, scalability, modularity, fault tolerance, maintainability, reliability, reusability, robustness, security, usability, performance, portability, and extensibility.

Modeling Languages

Modeling languages express information, knowledge, or systems according to a set of consistent rules. Examples include:

Architecture Description Language (ADL)

Business Process Modeling Notation (BPMN)

EXPRESS / EXPRESS‑G (ISO 10303‑11)

Extended Enterprise Modeling Language (EEML)

Flowcharts

Fundamental Modeling Concepts (FMC)

IDEF family (IDEF0, IDEF1X, IDEF5)

Jackson Structured Programming (JSP)

LeMP3 – visual OO design description language

Unified Modeling Language (UML)

Alloy – specification language based on first‑order relational logic

Systems Modeling Language (SysML)

Service‑Oriented Modeling Framework (SOMF)

Design Patterns

Design patterns capture reusable solutions to common design problems, accelerating software development.

Technical Notes

Software design can be viewed as “design of design”; the source code itself is a concrete manifestation of the design. Notable observations from Dijkstra and Knuth illustrate the layered nature of programming and the challenges of implementing designs.

Design documentation can be reviewed before coding, allowing multidisciplinary collaboration and adjustments to constraints, specifications, or requirements.