Prototyping Software: Building to Learn, Explained

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

Prototyping Software: Building to Learn

Software Engineering · Chapter 6: Requirements Engineering and PrototypingSection 6.2 · lesson 39 of 1036 min · free with a free account

← Foundations of Modeling Software RequirementsNext lesson: What Makes Good Requirements? Engineering Essentials →

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

Throwaway and evolutionary prototypes, and when either is worth building.

  • Define a prototype, and how it differs from the finished system
  • Distinguish throwaway from evolutionary prototypes
  • Explain the 2 purposes: clarifying requirements and reducing risk
  • Judge whether a prototype is worth the effort

Transcript

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

Requirements Engineering and Prototyping

Prototyping Software: Building to Learn

What if, instead of guessing what a system should do and building the whole thing on that guess, a team could build just enough of it to find out? That is the idea behind prototyping. This section covers the two kinds of prototype, the two reasons to build one, and how to tell whether it is worth the effort.

The Idea

Build Just Enough to Find Out

Building a whole system on a guess is risky. If the guess is wrong, the whole build is wrong. A prototype offers another way. It is a partial, working version of a system, built not to be the final product, but to learn something before committing to the real thing.

Judged Differently

Measured by What It Teaches

A prototype might only handle one screen, one workflow, or one technical question. It does not need to do everything the finished system will do. And it usually leaves out concerns like performance, security, or polish, which the final system will need. That matters, because a prototype is judged by what it teaches the team, not by how complete it is. The team walks away with an answer it did not have before. About what users actually want, or whether a technical approach will work at all.

Table 1

Throwaway vs. Evolutionary

Prototypes generally follow one of two paths, once they have done their job. A throwaway prototype is discarded, once the learning is captured. It can be built with whatever is fastest, regardless of the technology the final system will use. It is best for answering one specific, narrow question quickly. An evolutionary prototype is refined over time, until it becomes the real system. So it uses the technology and standards of the final system. It suits situations where the prototype's foundation is solid enough to keep building on. Either way, it is worth settling which path a prototype is on before building it.

Throwaway Prototypes

Waste on Purpose

The throwaway path is deliberately wasteful, in one narrow sense. The prototype itself is never meant to survive. But that waste is the point. Because nobody expects the prototype to become real code, the team is free to build it quickly and carelessly. It can cut corners that would be irresponsible in the actual system, purely to get an answer faster.

Purpose 1

Clarifying Requirements

Teams prototype for two main reasons. The first is clarifying requirements. Stakeholders often find it easier to react to something concrete, than to describe what they want in the abstract. A written requirements document can be read and agreed to in a meeting, without anyone noticing a misunderstanding buried inside it. A working prototype tends to surface that same misunderstanding the moment someone actually tries to use it. Used this way, the prototype is a conversation aid. Something to point at, and ask, is this what you meant?

Purpose 2

Reducing Risk

The second reason is technical. Reducing risk. The goal is to confirm, early and cheaply, whether an approach the team is unsure about will actually work. So the team builds a small prototype around the riskiest part of a design. An unfamiliar integration, a performance-sensitive calculation, or an unproven library. That answers the question early, before the team has built the rest of the system on an assumption that might be wrong.

Think About It

Does It Need Production Code?

Here is a question to think about. If a prototype exists only to clarify a misunderstood requirement, does it need to be built with production-quality code? Not necessarily. If the goal is purely to confirm what a stakeholder meant, a quick, imperfect throwaway can answer that just as well. And it will often answer it faster than a carefully engineered one.

Figure 2

Is a Prototype Worth It?

Prototyping takes time, so it is worth asking whether that time will pay off. Start with the requirements. If they are unclear, a prototype can clarify them. If they are clear, ask whether the technical approach is proven. If it is not, a prototype can reduce the risk. And if both are clear, a prototype mostly repeats work the team could do directly. So build directly. In short, prototyping earns its cost under genuine uncertainty, about what to build, or how to build it.

Apply It

A New Payment Library

Let's apply that. A team is confident about what the system needs to do, but has never used the third-party payment library it plans to integrate. Is a prototype worth building? Yes. The requirements are clear, but the technical approach is unproven. And which kind fits better? A throwaway prototype. The goal is narrowly to confirm that the payment library works as expected, not to build toward the final system.

Key Terms

The Vocabulary of This Section

Let's lock in the key terms. A prototype is a partial, working version of a system, built to learn something before committing to the real build. A throwaway prototype is discarded once it has served its purpose. It is never intended to become part of the delivered system. An evolutionary prototype is built with the intention of refining it, until it becomes the delivered system. And risk reduction means confirming early, with a small prototype, whether an uncertain technical approach will actually work.

Key Takeaways

What to Carry Forward

To pull this together. A prototype is a partial, working version, built to learn something, and judged by what it teaches. A throwaway prototype is discarded once it answers its question. An evolutionary prototype is refined until it becomes the delivered system. Prototypes serve two purposes. Clarifying requirements, and reducing technical risk. And they pay off mainly under genuine uncertainty. When both the requirements and the approach are clear, building directly is usually the better use of time.

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 Prototyping Software: Building to Learn

What is a software prototype?
A software prototype is a partial, working version of a system built to learn something before committing to the real build. It might cover only one screen, one workflow, or one technical question, and it usually leaves out performance, security, and polish. A prototype is judged by what it teaches the team, not by how complete it is.
What is the difference between a throwaway prototype and an evolutionary prototype?
A throwaway prototype is discarded once its learning is captured, so it can be built quickly with whatever tools are fastest. An evolutionary prototype is refined over time until it becomes the delivered system, so it must use the final system's technology and standards. Teams should decide which path a prototype is on before building it.
Why do software teams build prototypes?
Teams prototype mainly to clarify requirements and to reduce technical risk. Stakeholders often react more accurately to something concrete than to a written description, so a working prototype surfaces misunderstandings quickly. For risk reduction, a small prototype tests the riskiest part of a design, such as an unfamiliar integration or unproven library, before the rest is built on it.
When is building a prototype not worth the effort?
A prototype is usually not worth building when both the requirements and the technical approach are already clear, because it would mostly repeat work the team could do directly. Prototyping earns its cost under genuine uncertainty, either about what to build, such as unclear requirements, or about how to build it, such as an unproven library.

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 →