Software prototyping

Summary

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. A prototype typically simulates only a few aspects of, and may be completely different from, the final product. Prototyping has several benefits: the software designer and implementer can get valuable feedback from the users early in the project. The client and the contractor can compare if the software made matches the software specification, according to which the software program is built. It also allows the software engineer some insight into the accuracy of initial project estimates and whether the deadlines and milestones proposed can be successfully met. The degree of completeness and the techniques used in prototyping have been in development and debate since i

Official source

https://en.wikipedia.org/wiki/Software_prototyping

About this result

This page is automatically generated and may contain information that is not correct, complete, up-to-date, or relevant to your search query. The same applies to every other page on this website. Please make sure to verify the information with EPFL's official sources.

Related publications (36)

Related publications

Related people (1)

Related people

Related units (2)

Related units

Related concepts (4)

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

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, o

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

Related concepts

Related courses (17)

Related courses

Related lectures (34)

Related lectures

Improving the Interoperation between Generics Translations

Romain Michel Beguet, Martin Odersky, Milos Stojanovic, Nicolas Alexander Stucki, Vlad Ureche

Generics on the Java platform are compiled using the erasure transformation, which only supports by-reference values. This causes slowdowns when generics operate on primitive types, such as integers, as they have to be transformed into reference-based objects. Project Valhalla is an effort to remedy this problem by specializing classes at load-time so they can efficiently handle primitive values. In its current early prototype, the Valhalla compilation scheme limits the interaction between specialized and erased generics, thus preventing certain useful code patterns from being expressed. Scala has been using compile-time specialization for 6 years and has three generics compilation schemes working side by side. In Scala, programmers are allowed to write code that freely exercises the interaction between the different compilation schemes, at the expense of introducing subtle performance issues. Similar performance issues can affect Valhalla-enabled bytecode, whether the code was written in Java or translated from other JVM languages. In this context we explain how we help programmers avoid these performance regressions in the miniboxing transformation: (1) by issuing actionable performance advisories that steer programmers away from performance regressions and (2) by providing alternatives to the standard library constructs that use the miniboxing encoding, thus avoiding the conversion overhead.

ACM2015

ScalaDyno: Making Name Resolution and Type Checking Fault-tolerant

Cédric Bastin, Martin Odersky, Vlad Ureche

The ScalaDyno compiler plugin allows fast prototyping with the Scala programming language, in a way that combines the benefits of both statically and dynamically typed languages. Static name resolution and type checking prevent partially-correct code from being compiled and executed. Yet, allowing programmers to test critical paths in a program without worrying about the consistency of the entire code base is crucial to fast prototyping and agile development. This is where ScalaDyno comes in: it allows partially-correct programs to be compiled and executed, while shifting compile-time errors to program runtime. The key insight in ScalaDyno is that name and type errors affect limited areas of the code, which can be replaced by instructions to output the respective errors at runtime. This allows byte code generation and execution for partially correct programs, thus allowing Python or JavaScript-like fast prototyping in Scala. This is all done without sacrificing name resolution, full type checking and optimizations for the correct parts of the code -- they are still performed, but without getting in the way of agile development. Finally, for release code or sensitive refactoring, runtime errors can be disabled, thus allowing full static name resolution and type checking typical of the Scala compiler.

ACM2014

, , ,

This paper describes two research projects in the field of interactive architecture, both examples of experience catalysts; Settings which allow new insights in the aesthetic constitution and perception of environments. This term can be thought of as somewhat synonymous with artistic intervention, but is used instead to recognize that the participants might not self-identify as artists. We are working with architectural notions of space and place, but are interested in the experience of place more than its formal structure. We wish to emphasize the dynamic and are interested in transitions not as the pauses between states but as destinations worth exploring. Quadricone by Selena Savic is an actual experience catalyst: a physical manifestation of a digital “material” (in this case network traffic.) The goal is less data visualization and more an attempt to understand what it means to physically experience something normally invisible. Inter-Actor by Andrew Sempere casts architecture as an ongoing event which might benefit from the flexibility of the digital. The idea is to create a combination of software and hardware that allows for “rapid prototyping” of interactive space. Inter-Actor is not an experience catalyst but a toolkit for creating them.

Porto: FAUP Publicações2013