Iterative design

Short description: Design methodology based on a cyclic process of prototyping, testing, analyzing, & refining

Iterative design is a design methodology based on a cyclic process of prototyping, testing, analyzing, and refining a product or process. Based on the results of testing the most recent iteration of a design, changes and refinements are made. This process is intended to ultimately improve the quality and functionality of a design. In iterative design, interaction with the designed system is used as a form of research for informing and evolving a project, as successive versions, or iterations of a design are implemented.

## Contents

* 1 History
* 1.1 Object-Oriented Programming
* 2 Iterative design process
* 2.1 Application: Human computer interfaces
* 3 Iterative design use
* 4 Fast prototyping tools
* 5 Benefits
* 6 Marshmallow Challenge
* 7 See also
* 8 References
* 9 External links

## History

Iterative design has long been used in engineering fields. One example is the plan–do–check–act cycle implemented in the 1960s. Most New product development or existing product improvement programs have a checking loop which is used for iterative purposes. DMAIC uses the Six Sigma framework and has such a checking function.

### Object-Oriented Programming

Iterative design is connected with the practice of object-oriented programming, and the phrase appeared in computer science literature as early as 1990.[1] The idea has its roots in spiral development, conceived of by Barry Boehm.[2]

## Iterative design process

The iterative design process may be applied throughout the new product development process. However, changes are easiest and less expensive to implement in the earliest stages of development. The first step in the iterative design process is to develop a prototype. The prototype should be evaluated by a focus group or a group not associated with the product in order to deliver non-biased opinions. Information from the focus group should be synthesized and incorporated into the next iteration of the design. The process should be repeated until user issues have been reduced to an acceptable level.

### Application: Human computer interfaces

Iterative design is commonly used in the development of human computer interfaces. This allows designers to identify any usability issues that may arise in the user interface before it is put into wide use. Even the best usability experts cannot design perfect user interfaces in a single attempt, so a usability engineering lifecycle should be built around the concept of iteration.[3]

The typical steps of iterative design in user interfaces are as follows:

1. Complete an initial interface design
2. Present the design to several test users
3. Note any problems had by the test user
4. Refine interface to account for/fix the problems
5. Repeat steps 2-4 until user interface problems are resolved

Iterative design in user interfaces can be implemented in many ways. One common method of using iterative design in computer software is software testing. While this includes testing the product for functionality outside of the user interface, important feedback on the interface can be gained from subject testing early versions of a program. This allows software companies to release a better quality product to the public, and prevents the need of product modification following its release.

Iterative design in online (website) interfaces is a more continual process, as website modification, after it has been released to the user, is far more viable than in software design. Often websites use their users as test subjects for interface design, making modifications based on recommendations from visitors to their sites.

## Iterative design use

Iterative design is a way of confronting the reality of unpredictable user needs and behaviors that can lead to sweeping and fundamental changes in a design. User testing will often show that even carefully evaluated ideas will be inadequate when confronted with a user test. Thus, it is important that the flexibility of the iterative design's implementation approach extends as far into the system as possible. Designers must further recognize that user testing results may suggest radical change that requires the designers to be prepared to completely abandon old ideas in favor of new ideas that are more equipped to suit user needs. Iterative design applies in many fields, from making knives to rockets. As an example consider the design of an electronic circuit that must perform a certain task, and must ultimately fit in a small space on a circuit board. It is useful to split these independent tasks into two smaller and simpler tasks, the functionality task, and the space and weight task. A breadboard is a useful way of implementing the electronic circuit on an interim basis, without having to worry about space and weight.

Once the circuit works, improvements or incremental changes may be applied to the breadboard to increase or improve functionality over the original design. When the design is finalized, one can set about designing a proper circuit board meeting the space and weight criteria. Compacting the circuit on the circuit board requires that the wires and components be juggled around without changing their electrical characteristics. This juggling follows simpler rules than the design of the circuit itself, and is often automated. As far as possible off the shelf components are used, but where necessary for space or performance reasons, custom made components may be developed.

Several instances of iterative design are as follows:

* Wiki: A wiki is a natural repository for iterative design. The 'Page History' facility allows tracking back to prior versions. Modifications are mostly incremental, and leave substantial parts of the text unchanged.
* Common law: The principle of legal precedent builds on past experience. This makes law a form of iterative design where there should be a clear audit trail of the development of legal thought.
* Evolution: There is a parallel between iterative and the theory of natural Selection. Both involve a trial and error process in which the most suitable design advances to the next generation, while less suitable designs perish by the wayside. Subsequent versions of a product should also get progressively better as its producers learn what works and what doesn't in a process of refinement and continual improvement.

## Fast prototyping tools

One approach to iterative design is to use the highest level of abstraction for developing an early generation product. The principle here is that rapid development may not produce efficient code, but obtaining feedback is more important than technology optimization. Examples of this approach include use of non-functional code, object databases, or low code platforms - these allow quick testing of designs before issues of optimization are addressed.

## Benefits

When properly applied, iterative design will ensure a product or process is the best solution possible. When applied early in the development stage, significant cost savings are possible.[4]

Other benefits to iterative design include:

1. Serious misunderstandings are made evident early in the lifecycle, when it's possible to react to them.
2. It enables and encourages user feedback, so as to elicit the system's real requirements.
3. Where the work is contracted, Iterative Design provides an incremental method for more effectively involving the client in the complexities that often surround the design process.
4. The development team is forced to focus on those issues that are most critical to the project, and team members are shielded from those issues that distract and divert them from the project's real risks.
5. Continual testing enables an objective assessment of the project's status.
6. Inconsistencies among requirements, designs, and implementations are detected early.
7. The workload of the team, especially the testing team, is spread out more evenly throughout the lifecycle.
8. This approach enables the team to leverage lessons learned, and therefore to continually improve the process.
9. Stakeholders in the project can be given concrete evidence of the project's status throughout the lifecycle.

## Marshmallow Challenge

Marshmallow challenge winning work.

The Marshmallow Challenge is an instructive design challenge. It involves the task of constructing the highest possible free-standing structure with a marshmallow on top. The structure must be completed within 18 minutes using only 20 sticks of spaghetti, one yard of tape, and one yard of string.[5][6]

Observation and studies of participants show that kindergartners are regularly able to build higher structures, in comparison to groups of business school graduates. This is explained by the tendency for children to at once stick the marshmallow on top of a simple structure, test the prototype, and continue to improve upon it. Whereas, business school students tend to spend time vying for power, planning, and finally producing a structure to which the marshmallow is added.[7] The challenge helps to build and develop prototyping, teamwork, leadership and innovation skills and is a popular STEM activity. The challenge was invented by Peter Skillman of Palm, Inc. and popularized by Tom Wujec of Autodesk.[8][9][10][11][12]

## See also

* Disruptive innovation
* Extreme programming
* Spiral model
* Top-down and bottom-up design
* Paper prototyping
* Scrum (software development)

## References

1. ↑ Gossain, Sanjiv; Anderson, Bruce (1990). "An iterative-design model for reusable object-oriented software". Proceedings of the European conference on object-oriented programming on Object-oriented programming systems, languages, and applications - OOPSLA/ECOOP '90. pp. 12–27. doi:10.1145/97945.97949. ISBN 0-89791-411-2.
2. ↑ "Summary of Spiral Model". https://dataprivacylab.org/dataprivacy/projects/dialectics/designmethods/SpiralModel-mnovakou.pdf.
3. ↑ Nielsen, J. (1993). "Iterative User Interface Design". IEEE Computer 26 (11): 32–41. doi:10.1109/2.241424.
4. ↑ Mantei, Marilyn M.; Teorey, Toby J. (1988). "Cost/Benefit analysis for incorporating human factors in the software lifecycle". Communications of the ACM 31 (4): 428–439. doi:10.1145/42404.42408.
5. ↑ "The Marshmallow Challenge". The Marshmallow Challenge. http://www.marshmallowchallenge.com/Welcome.html.
6. ↑ "The Marshmallow Challenge". CA: BPWrap. 2010-04-22. http://www.bpwrap.com/2010/04/the-marshmallow-challenge/.
7. ↑ Jerz, Dennis G. (2010-05-10). "The Marshmallow Challenge - Jerz's Literacy Weblog". Jerz.setonhill.edu. http://jerz.setonhill.edu/weblog/2010/05/the_marshmallow_challenge/.
8. ↑ Cameron, Chris (2010-04-23). "Marshmallows and Spaghetti: How Kindergartners Think Like Lean Startups". Readwriteweb.com. http://www.readwriteweb.com/start/2010/04/marshmallows-and-spaghetti-how-kindergartners-think-like-lean-startups.php.
9. ↑ "The Marshmallow Challenge". Engineeringrevision.com. 2010-05-02. http://engineeringrevision.com/302/the-marshmallow-challenge/.
10. ↑ "The Marshmallow Challenge". Selfish Programming. http://www.selfishprogramming.com/2010/04/28/the-marshmallow-challenge/.
11. ↑ "Marshmallow challenge | Faculty of Science | University of Calgary". Ucalgary.ca. 2010-12-13. https://www.ucalgary.ca/science/node/1578.
12. ↑ Original Design Challenge (2014-01-27), Peter Skillman Marshmallow Design Challenge, https://www.youtube.com/watch?v=1p5sBzMtB3Q, retrieved 2017-09-12

* Boehm, Barry W. (May 1988) "A Spiral Model of Software Development and Enhancement," Computer, IEEE, pp. 61–72.
* Gould, J.D. and Lewis, C. (1985). Designing for Usability: Key Principles and What Designers Think, Communications of the ACM, March, 28(3), 300–311.
* Kruchten, Philippe. The Rational Unified Process—An Introduction,
* Kruchten, P. (2000). "From Waterfall to Iterative Development – A Challenging Transition for Project Managers". Rational Software Corporation. https://sceweb.uhcl.edu/helm/RationalUnifiedProcess/papers/pdf/tp173a.pdf.

## External links

* Iterative User Interface Design at useit.com
* Association for Computing Machinery
* Marshmallow Challenge official website
* TED video on Marshmallow Challenge
* Classroom images of Marshmallow Challenge

* v
* t
* e

Design

* Outline
* Designer

Disciplines

| Communication
design|

* Advertising
* Book design
* Corporate design
* Exhibit design
* Film title design
* Graphic design
* Motion
* Postage stamp design
* Print design
* Illustration
* Information design
* Instructional design
* News design
* Photography
* Retail design
* Signage / Traffic sign design
* Typography / Type design
* Video design
* Visual merchandising

|

Environmental
design|

* Architecture
* Architectural lighting design
* Building design
* Passive solar
* Ecological design
* Environmental impact design
* Garden design
* Computer-aided
* Healthy community design
* Hotel design
* Interior architecture
* Interior design
* EID
* Keyline design
* Landscape architecture
* Sustainable
* Landscape design
* Spatial design
* Urban design

Industrial
design|

* Automotive design
* Automotive suspension design
* CMF design
* Corrugated box design
* Electric guitar design
* Furniture design
* Sustainable
* Hardware interface design
* Motorcycle design
* Packaging and labeling
* Photographic lens design
* Product design
* Production design
* Sensory design
* Service design

Interaction
design|

* Experience design
* EED
* Game design
* Level design
* Video game design
* Hardware interface design
* Icon design
* Immersive design
* Information design
* Sonic interaction design
* User experience design
* User interface design
* Web design

Other
applied arts|

* Public art design
* Ceramic / glass design
* Fashion design
* Costume design
* Jewelry design
* Floral design
* Game art design
* Property design
* Scenic design
* Sound design
* Stage/set lighting design
* Textile design

Other
design
& engineering|

* Algorithm design
* Behavioural design
* Boiler design
* Database design
* Drug design
* Electrical system design
* Experimental design
* Filter design
* Geometric design
* Job design
* Integrated circuit design
* Circuit design
* Physical design
* Power network design
* Mechanism design
* Nuclear weapon design
* Nucleic acid design
* Organization design
* Process design
* Processor design
* Protein design
* Research design
* Social design
* Software design
* Spacecraft design
* Strategic design
* Systems design

Approaches

* Activity-centered
* Adaptive web
* Affective
* Brainstorming
* By committee
* By contract
* C-K theory
* Closure
* Co-design
* Concept-oriented
* Configuration
* Contextual
* Continuous
* Cradle-to-cradle
* Creative problem-solving
* Creativity techniques
* Critical
* Design fiction
* Defensive
* Design–bid–build
* Design–build
* architect-led
* Domain-driven
* Ecodesign
* Energy neutral
* Engineering design process
* Probabilistic design
* Error-tolerant
* Fault-tolerant
* Framework-oriented
* For assembly
* For behaviour change
* For manufacturability
* For Six Sigma
* For testing
* For X
* Functional
* Generative
* Geodesign
* HCD
* High-level
* Inclusive
* Integrated
* Integrated topside
* Intelligence-based
* Iterative
* KISS principle
* Low-level
* Metadesign
* Mind mapping
* Modular
* New Wave
* Object-oriented
* Open
* Parametric
* Participatory
* Platform-based
* Policy-based
* Process-centered
* Public interest
* Rational
* Regenerative
* Reliability engineering
* Research-based
* Responsibility-driven
* RWD
* Safe-life
* Sustainable
* Systemic
* SOD
* Tableless web
* Theory of constraints
* Top-down and bottom-up
* Transformation
* Transgenerational
* TRIZ
* Universal
* Design for All
* Usage-centered
* Use-centered
* User-centered
* Empathic
* User innovation
* Value-driven
* Value sensitive
* Privacy by

* Design choice
* computing
* controls
* flow
* leadership
* management
* marker
* methods
* pattern
* research
* science
* sprint
* strategy
* theory
* thinking

* Tools
* Intellectual property
* Organizations
* Awards

| Tools|

* AAD
* Architectural model
* Blueprint
* Comprehensive layout
* CAD
* CAID
* Virtual home design software
* CAutoD
* Design quality indicator
* Electronic design automation
* Flowchart
* Mockup
* Product design specification
* Prototype
* Sketch
* Storyboard
* Technical drawing
* Web design program
* Website wireframe

|

Intellectual
property|

* Community design
* Design around
* Design patent
* Fashion design copyright
* Geschmacksmuster
* Industrial design rights
* European Union

Organizations|

* AIGA
* Chartered Society of Designers
* Design and Industries Association
* Design Council
* International Forum Design
* The Design Society
* Design Research Society

Awards|

* European Design Award
* German Design Award
* Good Design Award (Museum of Modern Art)
* Good Design Award (Chicago Athenaeum)
* Good Design Award (Japan)
* Graphex
* IF product design award
* James Dyson Award
* Prince Philip Designers Prize
* Prix Versailles

Related topics

* Aesthetics
* Agile
* Concept art
* Conceptual design
* Creative industries
* Cultural icon
* .design
* Enterprise architecture
* Futures studies
* Indie design
* Innovation Management
* Intelligent design
* Lean Startup
* New product development
* OODA Loop
* Philosophy of design
* Process simulation
* Slow design
* STEAM fields
* Unintelligent design
* Visualization
* Wicked problem

* Design brief
* change
* classic
* competition
* architectural
* student
* director
* education
* elements and principles
* engineer
* firm
* history
* knowledge
* language
* life
* load
* museum
* paradigm
* rationale
* review
* specification
* studio
* technology

* Commons
* Wikibooks
* Wikinews
* Wikiquote
* Wikisource
* Wiktionary

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Iterative design. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Engineering:Iterative_design&oldid=476520"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template