I wrote about resolving ambiguities, based on a situation involving misunderstandings about prototypes. After encountering several discussions about them, as if they were based solely on opinions and everyone had a different one, I started collating a list of how they are referred to.
As I try to write about things that work in my experience, I feel compelled to offer my prototyping methods before the list. I have worked mostly with desktop software that is niche and domain specific. Thus, my preferred way of evaluating a design is to create a crude but presentable version as soon as possible and put it in front of a potential customer when that makes sense.
Beyond user testing, I create feasibility and other “low-fidelity” prototypes to validate value promises of libraries, tools, and ideas. For example, I wrote a bidirectional Unicode parser for a glyph rendering process by first creating a standalone “toy example”. I would gradually evaluate design choices, performance, and compatibility with fonts, writing systems, and different approaches before I felt certain it should work with the company’s framework. I would apply those ideas to create a similar system from scratch for the framework when I was confident about proceeding to that stage.
This approach works because it isolates complex systems and allows focus on one thing at a time. The cons are that you end up duplicating work. It is not that much of a con when you realise that most of the time is not spent typing code, but designing it. And when you have a thorough understanding of the system and design, it becomes heaps more trivial.
That said, now I get to entertain myself by releasing a list of different prototypes. I intend to refer to this list when I next encounter someone who rolls their eyes when I ask them to clarify what they mean by “prototype”.
As I was gathering input about various types of prototypes, several people felt that naming them is beside the point. In the words of a mastodon user: “So, fwiw, instead of 20+ names, it’s probably more useful to have good understanding of what you’re proving in each specific instance, and more generally the consequences/expectations of a prototype.”
I agree. However, it is also useful to note that they are used differently in the literature. Also, engineers and managers sometimes regurgitate the last variation of the word without asking for specifics. Thus, it relates to the areas with ambiguous responsibilities and tasks that I wrote about before. Furthermore, I haven’t seen a list like this compiled online, so I did it for fun anyway. Maybe it helps others realise, “prototype”, “MVP, or “proof-of-concept” means almost nothing without further context.
By the way, these have been researched since the 70s in case someone thought “fail fast” or “rapid prototyping” was a new concept.
Prototype nomenclature
- Pretotype
- Proof of Concept/Value
- Proof-of-Principle prototype
- User Experience prototype
- Working prototype
- Low/Mid/High-Fidelity Prototype
- 1st,2nd,3rd,4th,5th type
- Reference Implementation
- (Goldilocks Quality) Facade
- Concept Car
- Look-a-like Prototype
- Role/Look-and-Feel/Implementation/Integration Prototype
- Low/High-Functional Prototype
- Feasibility Prototype
- Full-System Prototypes
- Instrumented Prototype
- Smoke Test (“Fake Door”) Prototype
- alpha/beta/release candidate version
- Early/Mid/Late Lifecycle Prototype
- Passive/Active Prototype - i.e. non-interactive and interactive
- Vertical/Horizontal Prototype
- Engineering/Design Prototype
- Design-Driven Prototype
- Mock-up (Prototype)
- Quick-and-Dirty Prototype
- Spike Solution
- Throw-away Model/Prototype
- Evolutionary (Incremental) Prototype
- Pilot (System)
- Parallel Prototype
- Dogfood (Build or Prototype)
- Pnambic System
- Sandbox
- Simulation
- Tech Demo
- HCI
- Wizard of Oz Prototype
- Paper prototype
- Role Prototype (duplicate)
- Zork
- MVF - Minimum Viable Feature
- MVP - Minimum Viable Product
Prototyping methodology
- Rapid Prototyping
- Evolutionary Prototyping
- Operational Prototyping
- Continuous Prototyping
- User Interface Prototyping
- Prototrials