Imperative programming In
imperative programming and
software development, incremental compilation takes only the
changes of a known set of
source files and
updates any corresponding output files (in the compiler's target language, often
bytecode) that may already exist from previous compilations. By effectively
building upon previously compiled output files, an incremental compiler avoids the wasteful recompiling of entire source files, where most of the code remains unchanged. For most incremental compilers, compiling a program with small changes to its source code is usually near instantaneous. It can be said that an incremental compiler reduces the
granularity of a language's traditional compiling units while maintaining the language's
semantics, such that the compiler can append and replace smaller parts. Many
programming tools take advantage of incremental compilers to provide developers with a much more interactive programming environment. It is not unusual that an incremental compiler is invoked for
every change of a source file, such that the developer is almost immediately informed about any
compilation errors that would arise as a result of their changes to the code. This scheme, in contrast with traditional compilation, shortens a programmer's development cycle significantly, because they would no longer have to wait for a long compile process before being informed of errors. One downside to this type of incremental compiler is that it cannot easily
optimize the code that it compiles, due to locality and the limited scope of what is changed. This is usually not a problem, because for optimization is usually only carried out on
release, an incremental compiler would be used throughout development, and a standard batch compiler would be used on release.
Interactive programming In the
interactive programming paradigm, e.g. in
Poplog related literature, and an interactive compiler refers to a compiler that is actually a part of the
runtime system of the source language. The compiler can be invoked at runtime on some source code or data structure managed by the program, which then produces a new compiled program fragment containing
machine code that is then immediately available for use by the runtime system. If the newly compiled fragment replaces a previous compiled procedure the old one will be
garbage collected. This scheme allows for a degree of
self-modifying code and requires
metaprogramming language features. The ability to add, remove and delete code while running is known as
hot swapping. Some interactive programming platforms mix the use of interpreted and compiled code to achieve the illusion that any changes to code are accessible by the program immediately. ==List of incremental compilers==