How the Software Design Process Works | Software Engineering

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

How the Software Design Process Works

Software Engineering · Chapter 7: Behavioral Models and Requirements AnalysisSection 7.7 · lesson 53 of 1035 min · free with a free account

← Visualizing Object Interactions with UML Sequence DiagramsNext lesson: Essential Ideas Behind Effective Software Design →

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

From analysis to concrete technical decisions.

  • Place design between analysis and construction
  • Explain what design starts from, and why it matters
  • Distinguish structural, behavioral, and interface decisions
  • Explain what design must hand forward to construction

Transcript

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

Behavioral Models and Requirements Analysis

How the Software Design Process Works

Everything since analysis was first introduced, scenarios, use cases, class diagrams, and requirements by category, has been building toward a single handoff. Design is where that material turns into concrete technical decisions. This section covers where design sits, what it starts from, the three kinds of decisions it makes, and what it hands forward.

The Handoff

Where All That Analysis Was Heading

Analysis produces a structured, checked understanding of a problem. What the system needs to do. Design picks that understanding up, and starts making concrete technical decisions. How will the system actually be organized? How will its pieces coordinate? And what will its boundaries look like? That is software design. Turning analysis into decisions about how the system will actually be built.

Figure 1

Design Between Analysis and Construction

Here is where design sits. On the left, analysis produces use cases, class diagrams, and requirements. Those are design's inputs. Inside design, three kinds of decisions get made. Structural decisions about how pieces are organized, behavioral decisions about how they coordinate, and interface decisions about their boundaries. On the right, construction receives design's outputs, the documents and diagrams that capture those decisions.

Inputs

What Design Starts From

Design cannot start meaningfully from raw, unverified requirements. It depends on analysis having already structured and checked what is needed. Its real starting material is analysis's output. Class diagrams describing the structure, use cases describing the behavior, and requirements describing the conditions to satisfy. Design's decisions are only as sound as this material. It is the same dependency that made analysis rely on well-gathered requirements, one link further down the chain.

Table 1

3 Kinds of Design Decision

Three broad kinds of decisions get made during design, whatever technique or notation a team uses. Structural decisions cover how the system is organized into components. What are the major pieces, and how do they relate? Behavioral decisions cover how components coordinate to produce behavior. Which component handles each step of a use case, and in what order? And interface decisions cover what the boundaries between components look like. What does one component expose to another, or to a user?

Worth Noticing

1 Dependency Chain

It is worth noticing the chain this creates. Requirements have to be properly gathered. Analysis depends on them, and structures and checks them. Design depends on analysis, and turns it into technical decisions. And construction depends on design's artifacts. Weak input at any link produces weak decisions at every link after it.

Outputs

What Design Hands Forward

Design produces its own structured artifacts. Documents and diagrams that capture the structural, behavioral, and interface decisions. These become the direct starting material for construction, the same way analysis's output became design's. And the same failure is possible. A design artifact that is too vague to guide construction has failed. It fails the same way a vague requirement does, earlier in the chain.

Why This Matters

What Comes Next

So what comes next? The material ahead does not introduce new kinds of activity. It goes deeper on these same three. Structural decisions get their own dedicated treatment, as architectural design. And working through structural and behavioral decisions together, using objects, comes next.

Key Terms

The Vocabulary of This Section

Let's lock in the key terms. Software design is the activity of turning analysis's structured understanding, into concrete decisions about how a system will be built. A structural decision is about how a system is organized into components, and how they relate. A behavioral decision is about how components coordinate to produce the behavior a use case describes. And an interface decision is about what a component exposes to another component, or to a user, at their shared boundary.

Key Takeaways

What to Carry Forward

To pull this together. Design sits between analysis and construction. It starts from analysis's structured, verified output, not from raw requirements. It makes three kinds of decisions. Structural, behavioral, and interface. Its artifacts have to be specific enough to actually guide construction. And weak input at any link in the chain weakens every link after it.

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 How the Software Design Process Works

Where does software design fit between analysis and construction?
Software design sits between analysis and construction, turning analysis's structured understanding of what the system must do into concrete decisions about how it will be built. Its inputs are analysis outputs such as use cases, class diagrams, and requirements. Its outputs are documents and diagrams that capture those decisions, which become the direct starting material for construction, just as analysis output became design's starting material.
What are structural, behavioral, and interface design decisions?
They are the three broad kinds of decisions made during software design. Structural decisions cover how the system is organized into components and how those components relate. Behavioral decisions cover how components coordinate to produce the behavior a use case describes, including which component handles each step and in what order. Interface decisions cover what each component exposes to another component, or to a user, at their shared boundary.
Why can't software design start from raw requirements?
Design depends on analysis having already structured and checked what is needed, so its decisions are only as sound as that input. Raw, unverified requirements have not yet been organized into class diagrams, use cases, and checked conditions. The result is a dependency chain: analysis depends on good requirements, design depends on analysis, and construction depends on design, so weak input at any link weakens every decision after it.
What makes a software design artifact fail?
A design artifact fails when it is too vague to guide construction, in the same way a vague requirement fails earlier in the chain. Design documents and diagrams must capture the structural, behavioral, and interface decisions specifically enough that the people building the system can work directly from them. If construction has to guess at how components are organized or what they expose, the design has not done its job.

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 →