Runtime vs. Compile time

Question

What is the difference between run-time and compile-time?

Poetics

Answer 1

The difference between compile time and run time is an example of what pointy-headed theorists call the phase distinction. It is one of the hardest concepts to learn, especially for people without much background in programming languages. To approach this problem, I find it helpful to ask

1. What invariants does the program satisfy?
2. What can go wrong in this phase?
3. If the phase succeeds, what are the postconditions (what do we know)?
4. What are the inputs and outputs, if any?

Compile time

1. The program need not satisfy any invariants. In fact, it needn't be a well-formed program at all. You could feed this HTML to the compiler and watch it barf...
2. What can go wrong at compile time:
   • Syntax errors
   • Typechecking errors
   • (Rarely) compiler crashes
3. If the compiler succeeds, what do we know?
   • The program was well formed---a meaningful program in whatever language.
   • It's possible to start running the program. (The program might fail immediately, but at least we can try.)
4. What are the inputs and outputs?
   • Input was the program being compiled, plus any header files, interfaces, libraries, or other voodoo that it needed to import in order to get compiled.
   • Output is hopefully assembly code or relocatable object code or even an executable program. Or if something goes wrong, output is a bunch of error messages.

Run time

1. We know nothing about the program's invariants---they are whatever the programmer put in. Run-time invariants are rarely enforced by the compiler alone; it needs help from the programmer.

2. What can go wrong are run-time errors:

   • Division by zero
   • Dereferencing a null pointer
   • Running out of memory

   Also there can be errors that are detected by the program itself:

   • Trying to open a file that isn't there
   • Trying find a web page and discovering that an alleged URL is not well formed
3. If run-time succeeds, the program finishes (or keeps going) without crashing.
4. Inputs and outputs are entirely up to the programmer. Files, windows on the screen, network packets, jobs sent to the printer, you name it. If the program launches missiles, that's an output, and it happens only at run time :-)

Lem

Very good answer for what it covers (+1) however you don't even touch on the meta-programing aspects of compile-time vs. run-time and that, IMHO, is the most interesting part. I'll grant, given this answer got accepted, that it may well be outside what the OP was looking for. – Duplex

Nice, if somebody ask me about it during my lectures, I'll use your anwser :-) – Bazan

This is really nice answer. It is pretty clear and comprehensible. It is not easy to find that much clear answers in Google. – Moina

Even if you've programmed a while it's still not easy to get...it's not just newbies man. Good question by the OP. – Roughage

"The program need not satisfy any invariants. In fact, it needn't be a well-formed program at all. You could feed this HTML to the compiler and watch it barf..." I have no idea what you're saying here. Can you explain this in simple terms, not congested with all this technical garbage? – Roughage

"We know nothing about the program's invariants---they are whatever the programmer put in. Run-time invariants are rarely enforced by the compiler alone; it needs help from the programmer." I do not understand invariants even after looking at Wiki – Roughage

@Pithikos it started so good and sounded like he was about to drop an epiphany, and then I hit that part and was like... oh... another stack overflow post where someone answers and esoteric question with an esoteric answer. Great. – Mccormick

I think each compiler should add checks for not launching missiles. To get this error at compile time :-) – Bazar

What do you mean by "voodoo"? First point on fourth question in Compile Time section. – Ecumenicism

Clarify the meaning of "invariants", please. – Ecumenicism

@Ecumenicism an "invariant" can be thought of as a guarantee about the behavior and execution of your code. Suppose you write a program to calculate company expenses which are stored in a bunch of different files. Depending on your system, the most efficient implementation might have an invariant such that "each document is only read once." It's up to you to decide how to write code that does this, and since this is runtime behavior, there's no compiler that will catch you if you make a mistake or lie about the invariants of your program. – Anyway

ha, this is funny, almost 500 guys upvoted this, but no one explained the cryptic "invariant" for 10 years... finally jlau commented on it, but here is a more clear explanation to some of you: Invariant is a kind of "rule" that we developers should follow, but compilers have no idea about it. thanks to: softwareengineering.stackexchange.com/a/364286 – Mounting

Answer 2

I think of it in terms of errors, and when they can be caught.

Compile time:

string my_value = Console.ReadLine();
int i = my_value;

A string value can't be assigned a variable of type int, so the compiler knows for sure at compile time that this code has a problem

Run time:

string my_value = Console.ReadLine();
int i = int.Parse(my_value);

Here the outcome depends on what string was returned by ReadLine(). Some values can be parsed to an int, others can't. This can only be determined at run time

Shipload

Now this is something we can all understand. No general garbage tech words here. Nice. – Roughage

For an iPhone App: Is compile time the first time the code is compiled by the developer into a .app extension? or it happens upon launch by every time user starts app? – Into

@Honey it is compiled first time by developer into a .app – Gerent

This is a great, bottom-line answer that covers the difference between compile and run time conceptually. I appreciate the academic, professorial answer that was chosen as well, but this one is clear and concise. After reading this answer, I can go back and read the chosen answer, and it makes more sense. Thanks – Shields

Simple and clear. Great use of example code to help us understand. – Detrital

Answer 3

Compile-time: the time period in which you, the developer, are compiling your code.

Run-time: the time period which a user is running your piece of software.

Do you need any clearer definition?

Dickson

@BCS: The OP may have had a exceedingly simple introduction to programming using an interpreted or byte-compile-then-run-in-one-step language so that the distinction was never needed. The question in naive, but not dumb. – Decarbonize

@dmckee: I think this answer wouldn't even be of use to your user as it has no more information content than the original question. Anyone who would ask the question that this answer answers has no business programming (and I don't think the OP was asking that). – Duplex

I have a quick question. When someone says that a typical runtime error is dividing by zero but what if you have a variable, lets say int x = 3/0 but you don't do anything with this variable. We dont print it or anything. Will that still be considered a runtime error? – Inaccurate

For an iPhone App: Is compile time the first time the code is compiled by the developer into a .app extension? or it happens upon launch by every time user starts app? If its the compile time for which the developer's code is being compiled, then why would I care about it? I mean this won't affect user experience would it? As it would kill the developers time–only! – Into

@Inaccurate i assume you've got your answer after all this time,but i will answer it for others.yes it would be a runtime error even if you dont use it – Lieutenancy

correct and easy explanation. I love this kind of explanation. – Dobrinsky

This is 10000 times better an answer than the top voted one. – Mccormick

Why would you use the very same words that are confusing the OP. Obviously he doesn’t understand the word ‘compile’ in this context so if you understand it so well you could have used a simpler term – Epps

Answer 4

(edit: the following applies to C# and similar, strongly-typed programming languages. I'm not sure if this helps you).

For example, the following error will be detected by the compiler (at compile time) before you run a program and will result in a compilation error:

int i = "string"; --> error at compile-time

On the other hand, an error like the following can not be detected by the compiler. You will receive an error/exception at run-time (when the program is run).

Hashtable ht = new Hashtable();
ht.Add("key", "string");
// the compiler does not know what is stored in the hashtable
// under the key "key"
int i = (int)ht["key"];  // --> exception at run-time

Sax

Exceptions. Hashtable was one but I found the biggest step was .net 1.1 to .net 2.0, going from untyped to typed datasets (and now linq). Trying to troubleshoot a broken form with a dodgy database used to make me very sad! – Actinism

Answer 5

Translation of source code into stuff-happening-on-the-[screen|disk|network] can occur in (roughly) two ways; call them compiling and interpreting.

In a compiled program (examples are c and fortran):

1. The source code is fed into another program (usually called a compiler--go figure), which produces an executable program (or an error).
2. The executable is run (by double clicking it, or typing it's name on the command line)

Things that happen in the first step are said to happen at "compile time", things that happen in the second step are said to happen at "run time".

In an interpreted program (example MicroSoft basic (on dos) and python (I think)):

1. The source code is fed into another program (usually called an interpreter) which "runs" it directly. Here the interpreter serves as an intermediate layer between your program and the operating system (or the hardware in really simple computers).

In this case the difference between compile time and run time is rather harder to pin down, and much less relevant to the programmer or user.

Java is a sort of hybrid, where the code is compiled to bytecode, which then runs on a virtual machine which is usually an interpreter for the bytecode.

There is also an intermediate case in which the program is compiled to bytecode and run immediately (as in awk or perl).

Decarbonize

Answer 6

Basically if your compiler can work out what you mean or what a value is "at compile time" it can hardcode this into the runtime code. Obviously if your runtime code has to do a calculation every time it will run slower, so if you can determine something at compile time it is much better.

Eg.

Constant folding:

If I write:

int i = 2;
i += MY_CONSTANT;

The compiler can perform this calulation at compile time because it knows what 2 is, and what MY_CONSTANT is. As such it saves itself from performing a calculation every single execution.

Actinism

And it is easier to maintain compile time code than runtime bound code. At compile time you may use the compiler to check some stuff. The same stuff at runtime takes more time to check because involves testing. – Patronizing

Answer 7

Hmm, ok well, runtime is used to describe something that occurs when a program is running.

Compile time is used to describe something that occurs when a program is being built (usually, by a compiler).

Biodynamics

Answer 8

Compile Time:

Things that are done at compile time incur (almost) no cost when the resulting program is run, but might incur a large cost when you build the program.

Run-Time:

More or less the exact opposite. Little cost when you build, more cost when the program is run.

From the other side; If something is done at compile time, it runs only on your machine and if something is run-time, it run on your users machine.

Relevance

An example of where this is important would be a unit carrying type. A compile time version (like Boost.Units or my version in D) ends up being just as fast as solving the problem with native floating point code while a run-time version ends up having to pack around information about the units that a value are in and perform checks in them along side every operation. On the other hand, the compile time versions requiter that the units of the values be known at compile time and can't deal with the case where they come from run-time input.

Duplex

Answer 9

As an add-on to the other answers, here's how I'd explain it to a layman:

Your source code is like the blueprint of a ship. It defines how the ship should be made.

If you hand off your blueprint to the shipyard, and they find a defect while building the ship, they'll stop building and report it to you immediately, before the ship has ever left the drydock or touched water. This is a compile-time error. The ship was never even actually floating or using its engines. The error was found because it prevented the ship even being made.

When your code compiles, it's like the ship being completed. Built and ready to go. When you execute your code, that's like launching the ship on a voyage. The passengers are boarded, the engines are running and the hull is on the water, so this is runtime. If your ship has a fatal flaw that sinks it on its maiden voyage (or maybe some voyage after for extra headaches) then it suffered a runtime error.

Carve

Answer 10

Following from previous similar answer of question What is the difference between run-time error and compiler error?

Compilation/Compile time/Syntax/Semantic errors: Compilation or compile time errors are error occurred due to typing mistake, if we do not follow the proper syntax and semantics of any programming language then compile time errors are thrown by the compiler. They wont let your program to execute a single line until you remove all the syntax errors or until you debug the compile time errors.
Example: Missing a semicolon in C or mistyping int as Int.

Runtime errors: Runtime errors are the errors that are generated when the program is in running state. These types of errors will cause your program to behave unexpectedly or may even kill your program. They are often referred as Exceptions.
Example: Suppose you are reading a file that doesn't exist, will result in a runtime error.

Read more about all programming errors here

Why

Answer 11

Here is a quote from Daniel Liang, author of 'Introduction to JAVA programming', on the subject of compilation:

"A program written in a high-level language is called a source program or source code. Because a computer cannot execute a source program, a source program must be translated into machine code for execution. The translation can be done using another programming tool called an interpreter or a compiler." (Daniel Liang, "Introduction to JAVA programming", p8).

...He Continues...

"A compiler translates the entire source code into a machine-code file, and the machine-code file is then executed"

When we punch in high-level/human-readable code this is, at first, useless! It must be translated into a sequence of 'electronic happenings' in your tiny little CPU! The first step towards this is compilation.

Simply put: a compile-time error happens during this phase, while a run-time error occurs later.

Remember: Just because a program is compiled without error does not mean it will run without error.

A Run-time error will occur in the ready, running or waiting part of a programs life-cycle while a compile-time error will occur prior to the 'New' stage of the life cycle.

Example of a Compile-time error:

A Syntax Error - how can your code be compiled into machine level instructions if they are ambiguous?? Your code needs to conform 100% to the syntactical rules of the language otherwise it cannot be compiled into working machine code.

Example of a run-time error:

Running out of memory - A call to a recursive function for example might lead to stack overflow given a variable of a particular degree! How can this be anticipated by the compiler!? it cannot.

And that is the difference between a compile-time error and a run-time error

Charming

Answer 12

For example: In a strongly typed language, a type could be checked at compile time or at runtime. At compile time it means, that the compiler complains if the types are not compatible. At runtime means, that you can compile your program just fine but at runtime, it throws an exception.

Zeidman

Answer 13

In simply word difference b/w Compile time & Run time.

compile time:Developer writes the program in .java format & converts in to the Bytecode which is a class file,during this compilation any error occurs can be defined as compile time error.

Run time:The generated .class file is use by the application for its additional functionality & the logic turns out be wrong and throws an error which is a run time error

Newkirk

Answer 14

Compile time: Time taken to convert the source code into a machine code so that it becomes an executable is called compile time.

Run time: When an application is running, it is called run time.

Compile time errors are those syntax errors, missing file reference errors. Runtime errors happen after the source code has been compiled into an executable program and while the program is running. Examples are program crashes, unexpected program behavior or features don't work.

Calcicole

Answer 15

Imagine that you are a boss and you have an assistant and a maid, and you give them a list of tasks to do, the assistant (compile time) will grab this list and make a checkup to see if the tasks are understandable and that you didn't write in any awkward language or syntax, so he understands that you want to assign someone for a Job so he assign him for you and he understand that you want some coffee, so his role is over and the maid (run time)starts to run those tasks so she goes to make you some coffee but in sudden she doesn’t find any coffee to make so she stops making it or she acts differently and make you some tea (when the program acts differently because he found an error).

Plumlee

Answer 16

Run time means something happens when you run the program.

Compile time means something happens when you compile the program.

Flicker

Answer 17

Compile Time:

Things that are done at compile time incur (almost) no cost when the resulting program is run, but might incur a large cost when you build the program. Run-Time:

More or less the exact opposite. Little cost when you build, more cost when the program is run.

From the other side; If something is done at compile time, it runs only on your machine and if something is run-time, it run on your users machine.

Ynez

Answer 18

I have always thought of it relative to program processing overhead and how it affects preformance as previously stated. A simple example would be, either defining the absolute memory required for my object in code or not.

A defined boolean takes x memory this is then in the compiled program and cannot be changed. When the program runs it knows exactly how much memory to allocate for x.

On the other hand if I just define a generic object type (i.e. kind of a undefined place holder or maybe a pointer to some giant blob) the actual memory required for my object is not known until the program is run and I assign something to it, thus it then must be evaluated and memory allocation, etc. will be then handled dynamically at run time (more run time overhead).

How it is dynamically handled would then depend on the language, the compiler, the OS, your code, etc.

On that note however it would really depends on the context in which you are using run time vs compile time.

Phagocyte

Answer 19

Here is an extension to the Answer to the question "difference between run-time and compile-time?" -- Differences in overheads associated with run-time and compile-time?

The run-time performance of the product contributes to its quality by delivering results faster. The compile-time performance of the product contributes to its timeliness by shortening the edit-compile-debug cycle. However, both run-time performance and compile-time performance are secondary factors in achieving timely quality. Therefore, one should consider run-time and compile-time performance improvements only when justified by improvements in overall product quality and timeliness.

A great source for further reading here:

Broek

Answer 20

we can classify these under different two broad groups static binding and dynamic binding. It is based on when the binding is done with the corresponding values. If the references are resolved at compile time, then it is static binding and if the references are resolved at runtime then it is dynamic binding. Static binding and dynamic binding also called as early binding and late binding. Sometimes they are also referred as static polymorphism and dynamic polymorphism.

Joseph Kulandai‏.

Ashmore

Answer 21

The major difference between run-time and compile time is:

1. If there are any syntax errors and type checks in your code,then it throws compile time error, where-as run-time:it checks after executing the code. For example:

int a = 1 int b = a/0;

here first line doesn't have a semi-colon at the end---> compile time error after executing the program while performing operation b, result is infinite---> run-time error.

2. Compile time doesn't look for output of functionality provided by your code, whereas run-time does.

Staircase

Answer 22

here's a very simple answer:

Runtime and compile time are programming terms that refer to different stages of software program development. In order to create a program, a developer first writes source code, which defines how the program will function. Small programs may only contain a few hundred lines of source code, while large programs may contain hundreds of thousands of lines of source code. The source code must be compiled into machine code in order to become and executable program. This compilation process is referred to as compile time.(think of a compiler as a translator)

A compiled program can be opened and run by a user. When an application is running, it is called runtime.

The terms "runtime" and "compile time" are often used by programmers to refer to different types of errors. A compile time error is a problem such as a syntax error or missing file reference that prevents the program from successfully compiling. The compiler produces compile time errors and usually indicates what line of the source code is causing the problem.

If a program's source code has already been compiled into an executable program, it may still have bugs that occur while the program is running. Examples include features that don't work, unexpected program behavior, or program crashes. These types of problems are called runtime errors since they occur at runtime.

The reference

Serena

Answer 23

Look into this example:

public class Test {

    public static void main(String[] args) {
        int[] x=new int[-5];//compile time no error
        System.out.println(x.length);
    }}

The above code is compiled successfully, there is no syntax error, it is perfectly valid. But at the run time, it throws following error.

Exception in thread "main" java.lang.NegativeArraySizeException
    at Test.main(Test.java:5)

Like when in compile time certain cases has been checked, after that run time certain cases has been checked once the program satisfies all the condition you will get an output. Otherwise, you will get compile time or run time error.

Lymphangial

Answer 24

public class RuntimeVsCompileTime {

    public static void main(String[] args) {
        
        //test(new D()); COMPILETIME ERROR
        /**
         * Compiler knows that B is not an instance of A
         */
        test(new B());
    }
    
    /**
     * compiler has no hint whether the actual type is A, B or C
     * C c = (C)a; will be checked during runtime
     * @param a
     */
    public static void test(A a) {
        C c = (C)a;//RUNTIME ERROR
    }

}

    class A{
    
}

    class B extends A{
    
}

    class C extends A{
    
}

    class D{
    
}

Aerobe

Answer 25

You can understand the code compile structure from reading the actual code. Run-time structure are not clear unless you understand the pattern that was used.

Rubbish

Answer 26

It's not a good question for S.O. (it's not a specific programming question), but it's not a bad question in general.

If you think it's trivial: what about read-time vs compile-time, and when is this a useful distinction to make? What about languages where the compiler is available at runtime? Guy Steele (no dummy, he) wrote 7 pages in CLTL2 about EVAL-WHEN, which CL programmers can use to control this. 2 sentences are barely enough for a definition, which itself is far short of an explanation.

In general, it's a tough problem that language designers have seemed to try to avoid. They often just say "here's a compiler, it does compile-time things; everything after that is run-time, have fun". C is designed to be simple to implement, not the most flexible environment for computation. When you don't have the compiler available at runtime, or the ability to easily control when an expression is evaluated, you tend to end up with hacks in the language to fake common uses of macros, or users come up with Design Patterns to simulate having more powerful constructs. A simple-to-implement language can definitely be a worthwhile goal, but that doesn't mean it's the end-all-be-all of programming language design. (I don't use EVAL-WHEN much, but I can't imagine life without it.)

And the problemspace around compile-time and run-time is huge and still largely unexplored. That's not to say S.O. is the right place to have the discussion, but I encourage people to explore this territory further, especially those who have no preconceived notions of what it should be. The question is neither simple nor silly, and we could at least point the inquisitor in the right direction.

Unfortunately, I don't know any good references on this. CLTL2 talks about it a bit, but it's not great for learning about it.

Mandamandaean

dude what is not a good programming question to you is all relative. I thought it was an excellent question and something I've wanted to learn more about. Yes I know the general "concept" and what compile time and runtime are but I want to know the intriquicies that happen really at run time vs. compile time. It's those intriquicies that matter when you program and need to be aware of. It's not very concrete so that's why he's asking. I hate it when people sit here and say general questions like this is worthless when they are some of the most important questions to grasp for any dev. – Roughage

If you don't see value in a question, that is your problem. If it's general, there is a reason for it. Just because you don't like general questions doesn't mean that the world revolves around what you think is useful. He has a certain intent on asking this and he want's a range of answers to better understand and define both. Get it? – Roughage