Architectures that come pre-designed, because someone already solved your problem shape.
π Where this lives: when you run npx create-react-app, django-admin startproject, or rails new, you are being handed a reference architecture. Someone decided where the routing lives, where the data access lives, how configuration is loaded, and how tests are organised β and you inherit those decisions for free. That is the entire value proposition: reference architectures let you skip the design decisions that are not your competitive advantage, and spend your judgement on the ones that are. Search "reference architecture versus architectural style domain specific".
Domain-specific architectures
ARCHITECTURAL MODELS SPECIFIC TO A PARTICULAR APPLICATION DOMAIN
may be used when building new systems. Although instances of
these systems differ in detail, the common architectural
structure can be reused.
TWO TYPES OF DOMAIN-SPECIFIC ARCHITECTURAL MODEL:
1. GENERIC MODELS
Abstractions from a number of REAL SYSTEMS. They
encapsulate the principal characteristics of those
systems. Generic models are usually BOTTOM-UP
abstractions β derived by studying what existing systems
actually do.
β they describe what IS.
EXAMPLE: the compiler model below.
2. REFERENCE MODELS
More ABSTRACT, idealised models. They provide information
about that class of system and compare different
architectures. Reference models are usually derived
TOP-DOWN from domain knowledge and standards bodies.
β they describe what OUGHT TO BE, as a standard for
comparison.
EXAMPLE: the OSI seven-layer model.
THE DISTINCTION, stated for the exam:
GENERIC MODEL abstracted from real systems, bottom-up,
a description of practice, directly
reusable as a design
REFERENCE MODEL idealised, top-down, a vocabulary and a
yardstick for COMPARING architectures,
rarely implemented literally
THE OSI MODEL IS THE PERFECT ILLUSTRATION of why reference
models are not designs. No widely deployed protocol stack
implements all seven layers as separate components β TCP/IP
collapses the top three and the bottom two. Yet OSI remains
the language everyone uses to DISCUSS networking, which is
exactly what a reference model is for.
The generic compiler model, in detail
A COMPILER is the standard example of a generic model, because
every compiler ever built has the same components.
THE COMPONENTS
LEXICAL ANALYSER characters β tokens
SYMBOL TABLE names and their attributes, shared
SYNTAX ANALYSER tokens β syntax (parse) tree
SYNTAX TREE the shared intermediate structure
SEMANTIC ANALYSER checks types and scope rules
CODE GENERATOR tree β target code
THE SAME MODEL, THREE DIFFERENT ARCHITECTURES:
(a) AS A DATA-FLOW / PIPELINE ARCHITECTURE
Suitable for BATCH COMPILATION β the classic
command-line compiler.
chars β [lexical] β tokens β [syntax] β tree β
[semantic] β tree β [code gen] β object code
β each phase testable in isolation; phases reusable
β natural for batch use
β hopeless for an interactive environment, because a
single keystroke would restart the whole pipeline
(b) AS A REPOSITORY ARCHITECTURE
All phases read and write a shared SYMBOL TABLE and
SYNTAX TREE.
ββββββββββββ¬βββββββββββ¬βββββββββββ
β lexical β syntax β semantic β
ββββββ¬ββββββ΄βββββ¬ββββββ΄βββββ¬ββββββ
ββββββββ¬ββββ΄βββββββββββ
ββββββββΌββββββββββββββββ
β symbol table + tree β
ββββββββββββββββββββββββ
β this is what real compilers do, because the symbol table
genuinely must be shared β a semantic analyser needs
names the lexer found
β every phase depends on the shared representation
(c) AS PART OF AN INTEGRATED PROGRAMMING ENVIRONMENT
The compiler components plus an editor, a pretty-printer,
a static analyser and a debugger, all sharing the abstract
syntax tree.
β THIS IS WHY THE MODEL MATTERS. Because the tree is
shared, the editor can offer autocomplete (it reads the
symbol table), the analyser can underline errors as you
type, and the debugger can map machine addresses back to
source lines β all from ONE representation.
THE LESSON: the same generic model supports several
architectures, and the choice among them is driven by whether
use is BATCH or INTERACTIVE. That is the reusable insight, and
it generalises far beyond compilers.
Layered reference models and product lines
THE OSI REFERENCE MODEL β the canonical reference model, a
seven-layer model for communication systems:
7 APPLICATION the programs using the network
6 PRESENTATION data representation, encryption
5 SESSION dialogue control between endpoints
4 TRANSPORT end-to-end reliable delivery (TCP)
3 NETWORK routing between networks (IP)
2 DATA LINK frames on one link, error detection
1 PHYSICAL bits on the medium
Its VALUE: it provides a vocabulary and a decomposition that
lets us compare and discuss any real protocol stack, and it
cleanly separates concerns so a change at one layer need not
affect others.
Its LIMIT: as noted, few systems implement it literally.
OTHER WIDELY USED REFERENCE ARCHITECTURES:
THREE-TIER / N-TIER presentation, application, data. The
default for business information systems.
MODELβVIEWβCONTROLLER (MVC)
separates the data (model), its display
(view) and the input handling
(controller). The reference architecture
for interactive applications, and the
reason nearly every web framework has the
same three directories.
ETL PIPELINE extract, transform, load β the reference
architecture for data warehousing.
PUBLISHβSUBSCRIBE the reference architecture for
event-driven integration.
BROKER ARCHITECTURE CORBA's reference model for distributed
objects.
SOFTWARE PRODUCT LINES β reference architectures taken to their
commercial conclusion:
A product line is a set of systems sharing a common,
managed set of features, built from a common set of core
assets. The reference architecture IS the core asset, and each
product is a configuration of it.
EXAMPLES: a bank's retail platform deployed for many
countries; a car manufacturer's engine-control software across
a model range; a medical-device family.
THE ECONOMICS: the first product costs MORE than a bespoke
build (because the architecture must be generalised), and every
product after the second or third costs dramatically less. The
break-even is typically quoted around the third product β
which is why product lines are worth it for a family and
wasteful for a one-off.
WHEN A REFERENCE ARCHITECTURE IS THE WRONG CHOICE:
Β· your problem is genuinely novel and the reference model
forces a shape that does not fit β the classic symptom is
fighting the framework
Β· the reference architecture's non-functional profile does not
match yours (a three-tier CRUD architecture applied to a
hard real-time control problem)
Β· you would use 5% of it and carry the complexity of the other
95%
THE TEST: adopting a reference architecture should REMOVE
decisions you did not want to make. If it is adding decisions
and workarounds, it is the wrong one.
The compiler example is worth more than its exam value. The reason a modern IDE can underline a type error while you type is that the compiler was architected as a repository over a shared syntax tree rather than as a pipeline. One architectural decision, made for internal reasons, enabled an entire category of tooling decades later β which is as good an argument for taking architecture seriously as exists.
π Go further: the modern successors to these ideas are the cloud provider reference architectures β AWS's Well-Architected Framework, Azure's Architecture Center β which publish vetted designs for recurring shapes (serverless web app, batch analytics pipeline, multi-region failover) along with the trade-offs each makes across five pillars: operational excellence, security, reliability, performance efficiency and cost optimisation. They are reference models in exactly Sommerville's sense: idealised, top-down, and used more for comparing your design than for copying literally. Search "AWS Well-Architected Framework five pillars".
π‘ Exam angle: distinguish generic models (bottom-up abstractions from real systems, e.g. the compiler model) from reference models (idealised, top-down, for comparison, e.g. OSI) β that contrast is the core of the topic. Draw the compiler generic model with its components (lexical analyser, symbol table, syntax analyser, syntax tree, semantic analyser, code generator) and show it as both a data-flow and a repository architecture, explaining why an interactive environment needs the repository form. Reproduce the OSI seven layers and state that its value is as a vocabulary rather than an implementation.
Syllabus points
Reference/architecture models
Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.