Page 57 - DCAP507_SYSTEM_SOFTWARE

Unit 3: Machine Structure and Assembler Basic Functions

Other architectures such as the Zachman Framework, DODAF, and TOGAF relate to the field of Notes
Enterprise architecture.

The Distinction from Functional Design

The IEEE Std 610.12-1990 Standard Glossary of Software Engineering Terminology defines the
following distinctions:
 Architectural Design: The process of defining a collection of hardware and software
components and their interfaces to establish the framework for the development of a
computer system.
 Detailed Design: The process of refining and expanding the preliminary design of a system
or component to the extent that the design is sufficiently complete to begin implementation.
 Functional Design: The process of defining the working relationships among the
components of a system.

 Preliminary Design: The process of analyzing design alternatives and defining the
architecture, components, interfaces, and timing/sizing estimates for a system or
components.
Software architecture, also explained as strategic design, is an activity concerned with global
requirements governing how a solution is implemented such as programming paradigms,
architectural styles, component-based software engineering standards, architectural patterns,
security, scale, integration, and law-governed regularities. Functional design, also described as
tactical design, is an activity concerned with local requirements governing what a solution does
such as algorithms, design patterns, programming idioms, refactorings, and low-level
implementation.
According to the Intension/Locality Hypothesis, the distinction between architectural and
detailed design is defined by the Locality Criterion, according to which a statement about
software design is non-local (architectural) if and only if a program that satisfies it can be
expanded into a program which does not.

Example: The client-server style is architectural (strategic) because a program that is
built on this principle can be expanded into a program which is not client-server; for example,
by adding peer-to-peer nodes.

Architecture is design but not all design is architectural In practice, the architect is the one who
draws the line between software architecture (architectural design) and detailed design (non-
architectural design). There aren't rules or guidelines that fit all cases. Examples of rules or
heuristics that architects (or organizations) can establish when they want to distinguish between
architecture and detailed design include:
 Architecture is driven by non-functional requirements, while functional design is driven
by functional requirements.

 Pseudo-code belongs in the detailed design document.
 UML component, deployment, and package diagrams generally appear in software
architecture documents; UML class, object, and behavior diagrams appear in detailed
functional design documents.

LOVELY PROFESSIONAL UNIVERSITY 51