Iterative design

Last updated

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

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:

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. Marshmallow Challenge.jpg
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

Related Research Articles

The waterfall model is a breakdown of project activities into linear sequential phases, meaning they are passed down onto each other, where each phase depends on the deliverables of the previous one and corresponds to a specialization of tasks. The approach is typical for certain areas of engineering design. In software development, it tends to be among the less iterative and flexible approaches, as progress flows in largely one direction through the phases of conception, initiation, analysis, design, construction, testing, deployment and maintenance. The waterfall model is the earliest SDLC approach that was used in software development.

<span class="mw-page-title-main">Embedded system</span> Computer system with a dedicated function

An embedded system is a computer system—a combination of a computer processor, computer memory, and input/output peripheral devices—that has a dedicated function within a larger mechanical or electronic system. It is embedded as part of a complete device often including electrical or electronic hardware and mechanical parts. Because an embedded system typically controls physical operations of the machine that it is embedded within, it often has real-time computing constraints. Embedded systems control many devices in common use. In 2009, it was estimated that ninety-eight percent of all microprocessors manufactured were used in embedded systems.

<span class="mw-page-title-main">Prototype</span> Early sample or model built to test a concept or process

A prototype is an early sample, model, or release of a product built to test a concept or process. It is a term used in a variety of contexts, including semantics, design, electronics, and software programming. A prototype is generally used to evaluate a new design to enhance precision by system analysts and users. Prototyping serves to provide specifications for a real, working system rather than a theoretical one. In some design workflow models, creating a prototype is the step between the formalization and the evaluation of an idea.

Usability Engineering is a professional discipline that focuses on improving the usability of interactive systems. It draws on theories from computer science and psychology to define problems that occur during the use of such a system. Usability Engineering involves the testing of designs at various stages of the development process, with users or with usability experts. The history of usability engineering in this context dates back to the 1980s. In 1988, authors John Whiteside and John Bennett—of Digital Equipment Corporation and IBM, respectively—published material on the subject, isolating the early setting of goals, iterative evaluation, and prototyping as key activities. The usability expert Jakob Nielsen is a leader in the field of usability engineering. In his 1993 book Usability Engineering, Nielsen describes methods to use throughout a product development process—so designers can ensure they take into account the most important barriers to learnability, efficiency, memorability, error-free use, and subjective satisfaction before implementing the product. Nielsen’s work describes how to perform usability tests and how to use usability heuristics in the usability engineering lifecycle. Ensuring good usability via this process prevents problems in product adoption after release. Rather than focusing on finding solutions for usability problems—which is the focus of a UX or interaction designer—a usability engineer mainly concentrates on the research phase. In this sense, it is not strictly a design role, and many usability engineers have a background in computer science because of this. Despite this point, its connection to the design trade is absolutely crucial, not least as it delivers the framework by which designers can work so as to be sure that their products will connect properly with their target usership.

<span class="mw-page-title-main">Iterative and incremental development</span> Development methodology

Iterative and incremental development is any combination of both iterative design or iterative method and incremental build model for development.

The rational unified process (RUP) is an iterative software development process framework created by the Rational Software Corporation, a division of IBM since 2003. RUP is not a single concrete prescriptive process, but rather an adaptable process framework, intended to be tailored by the development organizations and software project teams that will select the elements of the process that are appropriate for their needs. RUP is a specific implementation of the Unified Process.

Rapid application development (RAD), also called rapid application building (RAB), is both a general term for adaptive software development approaches, and the name for James Martin's method of rapid development. In general, RAD approaches to software development put less emphasis on planning and more emphasis on an adaptive process. Prototypes are often used in addition to or sometimes even instead of design specifications.

<span class="mw-page-title-main">Paper prototyping</span> Software design technique

In human–computer interaction, paper prototyping is a widely used method in the user-centered design process, a process that helps developers to create software that meets the user's expectations and needs – in this case, especially for designing and testing user interfaces. It is throwaway prototyping and involves creating rough, even hand-sketched, drawings of an interface to use as prototypes, or models, of a design. While paper prototyping seems simple, this method of usability testing can provide useful feedback to aid the design of easier-to-use products. This is supported by many usability professionals.

<span class="mw-page-title-main">Usability</span> Capacity of a system for its users to perform tasks

Usability can be described as the capacity of a system to provide a condition for its users to perform the tasks safely, effectively, and efficiently while enjoying the experience. In software engineering, usability is the degree to which a software can be used by specified consumers to achieve quantified objectives with effectiveness, efficiency, and satisfaction in a quantified context of use.

<span class="mw-page-title-main">Systems development life cycle</span> Systems engineering terms

In systems engineering, information systems and software engineering, the systems development life cycle (SDLC), also referred to as the application development life cycle, is a process for planning, creating, testing, and deploying an information system. The SDLC concept applies to a range of hardware and software configurations, as a system can be composed of hardware only, software only, or a combination of both. There are usually six stages in this cycle: requirement analysis, design, development and testing, implementation, documentation, and evaluation.

<span class="mw-page-title-main">Product lifecycle</span> Duration of processing of products from inception, to engineering, design & manufacture

In industry, product lifecycle management (PLM) is the process of managing the entire lifecycle of a product from its inception through the engineering, design and manufacture, as well as the service and disposal of manufactured products. PLM integrates people, data, processes, and business systems and provides a product information backbone for companies and their extended enterprises.

In software project management, software testing, and software engineering, verification and validation (V&V) is the process of checking that a software system meets specifications and requirements so that it fulfills its intended purpose. It may also be referred to as software quality control. It is normally the responsibility of software testers as part of the software development lifecycle. In simple terms, software verification is: "Assuming we should build X, does our software achieve its goals without any bugs or gaps?" On the other hand, software validation is: "Was X what we should have built? Does X meet the high-level requirements?"

Software prototyping is the activity of creating prototypes of software applications, i.e., incomplete versions of the software program being developed. It is an activity that can occur in software development and is comparable to prototyping as known from other fields, such as mechanical engineering or manufacturing.

<span class="mw-page-title-main">User interface design</span> Planned operator–machine interaction

User interface (UI) design or user interface engineering is the design of user interfaces for machines and software, such as computers, home appliances, mobile devices, and other electronic devices, with the focus on maximizing usability and the user experience. In computer or software design, user interface (UI) design primarily focuses on information architecture. It is the process of building interfaces that clearly communicates to the user what's important. UI design refers to graphical user interfaces and other forms of interface design. The goal of user interface design is to make the user's interaction as simple and efficient as possible, in terms of accomplishing user goals.

Object-oriented analysis and design (OOAD) is a technical approach for analyzing and designing an application, system, or business by applying object-oriented programming, as well as using visual modeling throughout the software development process to guide stakeholder communication and product quality.

<span class="mw-page-title-main">Integrated circuit design</span> Engineering process for electronic hardware

Integrated circuit design, or IC design, is a sub-field of electronics engineering, encompassing the particular logic and circuit design techniques required to design integrated circuits, or ICs. ICs consist of miniaturized electronic components built into an electrical network on a monolithic semiconductor substrate by photolithography.

The incremental build model is a method of software development where the product is designed, implemented and tested incrementally until the product is finished. It involves both development and maintenance. The product is defined as finished when it satisfies all of its requirements. This model combines the elements of the waterfall model with the iterative philosophy of prototyping. According to the Project Management Institute, an incremental approach is an "adaptive development approach in which the deliverable is produced successively, adding functionality until the deliverable contains the necessary and sufficient capability to be considered complete."

<span class="mw-page-title-main">Hardware emulation</span> Emulating hardware devices in IC design

In integrated circuit design, hardware emulation is the process of imitating the behavior of one or more pieces of hardware with another piece of hardware, typically a special purpose emulation system. The emulation model is usually based on a hardware description language source code, which is compiled into the format used by emulation system. The goal is normally debugging and functional verification of the system being designed. Often an emulator is fast enough to be plugged into a working target system in place of a yet-to-be-built chip, so the whole system can be debugged with live data. This is a specific case of in-circuit emulation.

Extreme programming (XP) is an agile software development methodology used to implement software projects. This article details the practices used in this methodology. Extreme programming has 12 practices, grouped into four areas, derived from the best practices of software engineering.

In software engineering, a software development process is a process of planning and managing software development. It typically involves dividing software development work into smaller, parallel, or sequential steps or sub-processes to improve design and/or product management. It is also known as a software development life cycle (SDLC). The methodology may include the pre-definition of specific deliverables and artifacts that are created and completed by a project team to develop or maintain an application.

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. S2CID   551413.
  2. ↑ "Summary of Spiral Model" (PDF).
  3. ↑ Nielsen, J. (1993). "Iterative User Interface Design". IEEE Computer. 26 (11): 32–41. doi:10.1109/2.241424. S2CID   17748574.
  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 . S2CID   2031965.
  5. ↑ "The Marshmallow Challenge". The Marshmallow Challenge. Retrieved 2010-08-10.
  6. ↑ "The Marshmallow Challenge". CA: BPWrap. 2010-04-22. Retrieved 2010-08-10.
  7. ↑ Jerz, Dennis G. (2010-05-10). "The Marshmallow Challenge - Jerz's Literacy Weblog". Jerz.setonhill.edu. Retrieved 2010-08-10.
  8. ↑ Cameron, Chris (2010-04-23). "Marshmallows and Spaghetti: How Kindergartners Think Like Lean Startups". Readwriteweb.com. Archived from the original on 2010-08-21. Retrieved 2010-08-10.
  9. ↑ "The Marshmallow Challenge". Engineeringrevision.com. 2010-05-02. Retrieved 2013-08-10.
  10. ↑ "The Marshmallow Challenge". Selfish Programming. Retrieved 2013-08-10.
  11. ↑ "Marshmallow challenge | Faculty of Science | University of Calgary". Ucalgary.ca. 2010-12-13. Retrieved 2013-08-10.
  12. ↑ Original Design Challenge (2014-01-27), Peter Skillman Marshmallow Design Challenge, archived from the original on 2021-12-13, retrieved 2017-09-12
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.