Program lifecycle phase

Last updated

A program lifecycle phase is a distinct period of time that is relevant to the operation of a computer program as it transitions from development to execution. Any distinct period in a program's life cycle in which the operational state of the program changes can be identified as a time. For example, compile time is when a program is compiled and link time is when a program is linked. Also, phases can often be divided into component phases. For example, build time might be divided into compile and link times, compile time into parse and code-generation times, and run time into initialization and normal-operation times.

Contents

A program tends to transition through phases in sequences, but often not from first to last and sometimes some are skipped. For example, when programming, a developer may repeatedly edit, build, and run a program without distributing or installing it. After programming is complete, then it may be distributed to and installed by a user.

Even though the term program lifecycle phase is less than notable, the times (phases) are well-known, commonly-used and notable. The collective term is used for this article for lack of a better term.

Examples

The operational phases of a program vary by its development technology. For example, a compiled program involves compile and link phases, but an interpreted program has no such phases is distributed as source code. Even for compiled programs, the phases vary. For example, some runtimes (such as for .Net and Java) include a just-in-time compilation phase, yet more traditional runtimes (such as for C) do not.

The phases for a program that is compiled to a host-native executable typically include:

Design time (a.k.a. edit time)
When the program source code is being authored. This includes initial coding as well as bug fixes, new features, and refactoring. [1]
Compile time
When source code is compiled to object code machine code plus information for linking. [2]
Link time
When object code and external libraries are linked combined to form an executable. Functions and data from a library are linked either via static linking (performed at link time) or dynamic linking (performed at load time). [3]
Distribution time
When the program is transferring to a user often downloaded from the Internet or via physical media such as a USB flash drive. [4]
Installation time
When the program is installed. The executable and related files are stored such that the host computer can readily run the program. [5]
Load time
When the program is loaded including copying the machine code into executable memory and resolving dynamic linkages. [6] [7]
Run time
When the program is running. The central processing unit executes the program's machine code instructions. [8] [9]

Use

Describe binding time

Binding time describes whether an association between entities is fixed either before (early) or after (late) the program starts running. The phases described here provide a way to describe when the binding occurs more precisely. For example, an early binding might be made at design, compile or link time.

Parallel computing

One of the key functions of parallel computing development is specializing the code to the host runtime environment. [10] [11] Such specialization cannot be performed before that environment is known. If the desire is for the same code to run on a variety of hardware platforms, then such specialization cannot happen during edit or compile phases. The earliest phase would be the distribution phase, [12] if a system were put in place that gathers hardware information, then chooses an executable that is already specialized to that hardware or substantially similar hardware, or generates a specialized binary on the fly. Likewise, specialization could be performed at load time, [13] by invoking a binary rewriting tool [14] in combination with a tool that uses the control flow structure to generate a specialized form.

References

  1. Franchitti, Jean-Claude (13 November 2024). "4.2 Building C Programs". Introduction to Computer Science. OpenStax. Retrieved 12 November 2025.
  2. Aho, Alfred V.; Lam, Monica S.; Sethi, Ravi; Ullman, Jeffrey D. (2006). Compilers: Principles, Techniques, and Tools (2nd ed.). Addison-Wesley. ISBN   978-0321486813.
  3. Levine, John R. (1999). Linkers and Loaders. Morgan Kaufmann. ISBN   978-1558604964.
  4. "Software Distribution – an overview". ScienceDirect Topics. Elsevier. Retrieved 12 November 2025.
  5. "Overview of Windows Installer". Microsoft Learn. Microsoft. 7 January 2021. Retrieved 12 November 2025.
  6. "ld.so(8) — dynamic linker/loader". man7.org Linux man-pages. Michael Kerrisk. Retrieved 12 November 2025.
  7. "Linking (CS:APP lecture slides) — load-time vs run-time dynamic linking" (PDF). Carnegie Mellon University. 26 October 2023. Retrieved 12 November 2025.
  8. "execve(2) — execute program". man7.org Linux man-pages. Michael Kerrisk. Retrieved 12 November 2025.
  9. "Linking (CS:APP lecture slides) — run-time dynamic linking (dlopen)" (PDF). Carnegie Mellon University. 26 October 2023. Retrieved 12 November 2025.
  10. Midkiff, Samuel P. (2012). Automatic Parallelization: An Overview of Fundamental Compiler Techniques (PDF). Synthesis Lectures on Computer Architecture. Morgan & Claypool. ISBN   978-1608458103 . Retrieved 12 November 2025.
  11. Tournavitis, Georgios; O’Boyle, Michael (2009). Towards a holistic approach to auto-parallelization . ACM. doi:10.1145/1543135.1542496 . Retrieved 12 November 2025.
  12. "Device targeting (beta)". Android Developers. Google. 21 July 2025. Retrieved 12 November 2025.
  13. "LTO (Link Time Optimization)". GCC Internals Manual. Free Software Foundation. Retrieved 12 November 2025.
  14. Panchenko, Maksim; Fedorov, Andrey; Ottoni, Guilherme; Condon, Rodrigo (2019). BOLT: A Practical Binary Optimizer for Data Centers and Beyond . IEEE. pp. 2–14. doi:10.1109/CGO.2019.8661187 . Retrieved 12 November 2025.