Components of a Complete Design Model, Explained

UPI Study › Courses › Software Engineering › Free lessons › Lesson 8.2 Free with a free account

Components of a Complete Design Model

Software Engineering · Chapter 8: Object-Oriented Design and ArchitectureSection 8.2 · lesson 56 of 1036 min · free with a free account

← Designing Software the Object-Oriented WayNext lesson: Mapping Deployment with UML Diagrams →

Earn 3 college credits for Software EngineeringRecommended for credit by NCCRS · Computer Science 301 · self-paced · one payment, lifetime access
Enroll in Software Engineering · $250 →Download the syllabus (PDF)

In this lesson

4 complementary elements, from the whole system down to where it runs.

  • Explain why a design model needs several elements
  • Describe architectural and interface design
  • Describe component-level and deployment design
  • Explain why skipping deployment is risky

Transcript

Everything said in the video, section by section (712 words). Read along, or search it.

Object-Oriented Design and Architecture

Components of a Complete Design Model

No single diagram captures a whole system's design. A complete design model is several complementary pieces, each looking at the same system from a different angle, and at a different scope. This section is a map of those four pieces, before each gets its own dedicated treatment.

No Single Diagram

4 Angles on 1 System

The structural, behavioral, and interface decisions covered earlier do not all get captured in one place. A complete design model organizes them into distinct elements. It also adds one further concern those categories do not directly address. Each element looks at the system at a different scope. From its broadest structure, down to the inside of a single piece, plus where all of it actually runs.

The Map

The 4 Elements

Here are the four elements. Architectural design covers the system's major structure. Interface design covers the boundaries between pieces. Component-level design covers the inside of each piece. And deployment design covers where everything actually runs. Each one is covered in its own dedicated material ahead. This is only the map.

Architectural Design

The Big Picture

Architectural design is the broadest, highest-level structural view. It identifies the system's major components or subsystems, and how they relate to each other at the largest scale. It is closer to a building's overall floor plan than to the details of any single room. The goal is the big picture, not yet the specifics of what happens inside any one piece.

Interface Design

What Passes Between the Pieces

Interface design defines what each component exposes to the others. It also defines what the system as a whole exposes to its users, and to other external systems. Architectural design draws the components. Interface design defines exactly what passes between them. The actual boundary each piece presents to everything outside it.

Component-Level Design

Inside a Single Piece

Once a component's boundaries and its place in the architecture are settled, component-level design zooms into that single piece. It works out the data structures, algorithms, and internal logic needed to deliver what the interface promises. This is design at a much finer grain than architecture. It refines a high-level decision into something detailed enough to guide real construction, without yet being code itself.

Deployment Design

Where Everything Runs

Deployment design addresses something the other three do not. Where the system's pieces will physically run once built. It decides which components live on which machines, how they are distributed across a network, and what infrastructure each piece needs. This matters most for distributed or multi-tier systems. Picture two components that need to talk constantly, placed on distant servers with high latency between them. They will struggle, no matter how clean their architecture looked on paper.

Table 1

Scope and a Rough Analogy

Here are the four elements, each with its scope and a rough analogy. Architectural design covers the major components, and how they relate. It is like a building's overall floor plan. Interface design covers what is exposed at component and system boundaries. It is like the doors and windows between rooms. Component-level design covers the internal structure of one component. It is like the wiring and plumbing inside one room. And deployment design covers where components physically run. It is like deciding which building each room actually gets built in.

Why This Matters

Complete Means All 4

It is worth noticing that these four elements are not a new set of ideas. They are where the structural, behavioral, and interface decisions actually get written down, as distinct artifacts. Plus one further concern, which only shows up once you ask where everything runs. And a design that looks complete on paper is not complete until all four are addressed. Skipping deployment is an easy way for a well-architected system to run into trouble, only once it is actually running.

Key Terms

The Vocabulary of This Section

Let's lock in the key terms. The design model is the complete set of design artifacts. Architectural, interface, component-level, and deployment design together. Architectural design is the highest-level structural view. Interface design defines what each component exposes, and what the system exposes outside. Component-level design is the detailed internal design of a single component. And deployment design plans where components physically run, and how they are distributed across infrastructure.

Key Takeaways

What to Carry Forward

To pull this together. A complete design model has four elements, each at a different scope. Architectural design covers the major structure, and interface design covers the boundaries between pieces. Component-level design covers the inside of each piece. And deployment design covers where it all runs. Skip it, and a clean design can still fail in practice.

About Software Engineering at UPI Study

Software Engineering (Computer Science 301) is a self-paced online course of 103 video lessons in 15 chapters, from process models and agile to requirements, design, user interfaces, reliability, security and project management. It carries a NCCRS credit recommendation for 3 semester credits.

Every lesson transcript is free on pages like this one, and the videos are free with a free UPI Study account. Enrolling adds a practice quiz after each lesson, the graded work and final exam that earn the credit, lifetime access, and an official transcript on completion. UPI Study has helped over 130,000 students with college credits. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Enroll now → Course details Download the syllabus All Computer Science courses Every course with PRO →

Compare: Software Engineering vs Systems Analysis

Why take it here

Why students take Software Engineering with UPI Study

How professional software gets builtSoftware Engineering covers how teams turn requirements into working, maintainable software: process models, agile, requirements, design, testing, reliability and project management. It is a core course in computer science and software degrees.
Credit at a fraction of the priceThe same 3 credits can cost $750 or more at a US college. Here it is one payment, self-paced, with lifetime access.
Finish your degree soonerTransfer credits reduce the courses you still owe, so you can graduate earlier or lighten a heavy semester.
Strengthen an applicationA completed college-level course on an official transcript shows admissions and scholarship committees you can do the work.
Study on your own scheduleNo start dates, no deadlines. Watch the lessons, practice, and take the final when you are ready.
130,000+students helped with college creditsACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Where the credit goes

Universities that work with NCCRS

Software Engineering carries a NCCRS credit recommendation. These universities work with NCCRS; some are UPI Study's signed partners. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.

Thomas Edison State UniversityThomas Edison State UniversitySigned partnerUniversity of the PeopleUniversity of the PeopleSigned partnerCharter Oak State CollegeCharter Oak State CollegeSigned partnerStrayer UniversityStrayer UniversitySigned partnerColumbia Southern UniversityColumbia Southern UniversitySigned partnerIndiana TechIndiana TechSigned partnerPenn StatePenn StateWorks with NCCRSSouthern New Hampshire UniversitySouthern New Hampshire UniversityWorks with NCCRSSUNYSUNYWorks with NCCRS +many more cooperating universitiesFind my college →

Find my college → Not listed? Ask Athena in the corner of this page, or book a 15-minute call.

FAQ

Questions students ask us

About Components of a Complete Design Model

What are the four elements of a software design model?
A complete design model has four elements: architectural design, interface design, component-level design, and deployment design. Architectural design covers the system's major structure, interface design covers the boundaries between pieces, component-level design covers the inside of each piece, and deployment design covers where everything physically runs. Each looks at the same system from a different angle and scope, because no single diagram captures a whole system's design.
What is the difference between architectural design and interface design?
Architectural design is the broadest structural view, identifying the major components or subsystems and how they relate at the largest scale, like a building's floor plan. Interface design defines exactly what passes between those components, and what the system exposes to users and external systems, like the doors and windows between rooms. Architecture draws the components; interface design specifies the boundary each one presents to everything outside it.
What is deployment design in software engineering?
Deployment design decides where a system's pieces will physically run once built: which components live on which machines, how they are distributed across a network, and what infrastructure each piece needs. It matters most for distributed or multi-tier systems. It is the one design element that addresses a concern the structural, behavioral, and interface decisions do not directly cover, namely the physical placement of the software.
Why is it risky to skip deployment design?
Skipping deployment design lets a well-architected system run into trouble only once it is actually running. For example, two components that need to talk constantly, placed on distant servers with high latency between them, will struggle no matter how clean their architecture looked on paper. A design model is not complete until architectural, interface, component-level, and deployment design have all been addressed.

About the Software Engineering course

How many college credits is Software Engineering?
Software Engineering (Computer Science 301) carries a NCCRS credit recommendation for 3 semester credits. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities.
How much does Software Engineering cost and what is included?
$250, paid once, with lifetime access: all 103 video lessons, a practice quiz after each, the graded work and final exam, and an official transcript when you finish. Students who want several courses choose UPI Study PRO instead.
Which universities accept UPI Study credits?
UPI Study has signed partner agreements with universities such as Thomas Edison State University, University of the People and Charter Oak State College, and works with universities such as Penn State, SNHU and SUNY. ACE and NCCRS have over 2,100 cooperating colleges that will consider accepting credits; the final decision is with the universities. Use "Find my college" on this page to check yours.
How long does Software Engineering take?
It is self-paced with no deadlines. The 103 lessons total about 11 hours of video; most students add reading and practice time and finish in a few weeks to a few months, on their own schedule.
How are the exams done?
Quizzes and assignments are online in the course. The final exam is taken online with proctoring; a person on the UPI Study team checks assignments, usually within two days.
How do my credits reach my college?
When the course shows 100% complete, request the official transcript from your dashboard. It is sent to the college you name, and you can send it to more than one. Check your college first with "Find my college" on this page, or ask Athena.

Ready for the full course? Earn 3 credits in Software Engineering.

103 video lessons, a quiz after each one, and the graded work that earns the credit. Recommended for credit by NCCRS.

Enroll in Software Engineering →Download the syllabusEvery course with PRO →
Software Engineering
3 credits · NCCRSEnroll →