In computer science, the qualifier run time, run-time, runtime, or execution time refers to the period while a computer program is actually executed ("run") in a computer, from beginning to termination. It may also mean the program's running time, the duration of that period.

The term is often used in contrast to other phases of program development and use, such as compile-time, link time, load time, etc.. Thus, for example, a "run-time error" is detected only during the execution of the program, whereas a "compile-time error" is detected by the compiler before the program is started. Type checking, storage allocation, and even code generation and code optimization may be done at compile-time or at run-time, depending on the language and compiler.

The term runtime as a noun can also refer to a program's run-time environment, the collection of software service that are available to it during its execution. These services may be provided by the operating system, or by a run-time system, such as a virtual machine or a collection of program libraries.

Contents 1 Implementation details 2 Application errors — exceptions 3 See also 4 References

[edit] Implementation details

In most cases, the execution of a program begins after a loader performed the necessary memory setup and linked the program with any dynamically linked libraries it needs. In some cases a language or implementation will have these tasks done by the language runtime instead, though this is unusual in mainstream languages on common consumer operating systems.

Some program debugging can only be performed (or are more efficient or accurate) when performed at runtime. Logical errors and array bounds checking are examples. For this reason, some programming bugs are not discovered until the program is tested in a "live" environment with real data, despite sophisticated compile-time checking and pre-release testing. In this case, the end user may encounter a runtime error message.

[edit] Application errors — exceptions

Exception handling is one language feature designed to handle runtime errors, providing a structured way to catch completely unexpected situations as well as predictable errors or unusual results without the amount of inline error checking required of languages without it. More recent advancements in runtime engines enable Automated Exception Handling which provides 'root-cause' debug information for every exception of interest and is implemented independent of the source code, by attaching a special software product to the runtime engine.

A common runtime error reads Division by zero.

[edit] See also

• Binding (computer science)
• Compile time and compiling
• Interpreter (computing)
• Runtime Type Information

[edit] References

This article includes a list of references, related reading or external links, but its sources remain unclear because it lacks inline citations. Please improve this article by introducing more precise citations where appropriate. (May 2008)