When you hear developers talking about “runtime,” they’re not talking about getting in their steps during lunch. Instead, it’s one side of a vital decision that has a huge impact on the kind of software you’re making — and what you’re trying to accomplish with it.

Runtime and compile time are different phases of a program’s execution. And before you can start developing any software project, you have to understand the difference between the two and how they factor into creating high-quality software.

But before you can truly understand why the difference between runtime and compile time matters, you also have to know the difference between statically and dynamically typed programming.

What is compile time?

Let’s start by talking about compile time, which is when the code is transformed into machine code that can be executed by a computer but before the actual execution of the program. During this phase, the code is checked for mistakes.

Compile-time errors occur when the code is compiled, and the compiler checks the code for any syntax or type-related errors. (In programming, “type” refers to a set of values and what you’re allowed to do with them.) These errors must be fixed before the program can run..

For example, if a variable is declared but not initialized, the compiler will throw a compile-time error, preventing the program from running until the error is fixed.

What is runtime?

Runtime comes after the code is turned into machine code, when the program is actually running. At runtime, the program can encounter errors that are not caught at compile time, like incorrect user input or unexpected behavior. These errors can cause the program to crash or behave in unexpected ways. For example, if a program is trying to access a nonexistent array index or attempts to divide by zero, a runtime error will occur, causing the program to crash.

OK, so now that we have compile time and runtime down, let’s talk languages.

What is a statically typed language?

“Variables” is the term for the “containers” where you store values you assign in a computer program. In a statically typed language, the type of a variable is explicitly declared at the time of declaration, and it cannot be changed during execution of the program. The compiler performs type checking at compile time and reports any type mismatches as errors. This is so the mistakes can be caught and fixed before the program is running. 

This way of doing things means developers can catch mistakes early in the development process and can make code easier to maintain and read. For example, if a variable is declared as an integer, it cannot be assigned a string value later in the code. You’d get a compile-time error, preventing the program from running until the error is fixed.

Statically typed languages include Java, C++ and Swift.

What is a dynamically typed language?

On the other hand, a dynamically typed language is where the type of a variable is determined at runtime — critically, it can change during the execution of the program. For example, in Python, a variable can be assigned a string value and then later assigned an integer value. 

Dynamically typed code is more flexible and easier to write, but it’s also more prone to errors. Because the compiler doesn’t perform type checking, type mismatches are only detected at runtime. This can lead to unpredictable behavior or errors in the program. To offset the risk of runtime errors, dynamically typed languages often include features such as type checking and error handling.

Dynamically typed languages include Python, Ruby and JavaScript.

Statically typed vs. dynamically typed languages

So we’ve established that, in a statically typed language, like TypeScript or Java, the compiler performs these checks at compile time and produces an error if there are any issues. In contrast, in a dynamically typed language, like JavaScript, the code is not checked until runtime, when the program is actually executed.

Because of these differences, statically typed languages provide more type safety but are also more inflexible and harder to code. Statically typed languages also require more upfront work in defining types and writing type annotations, which can make it more difficult to get started with a new project or to make changes to the code once it is written.

Dynamically typed languages, on the other hand, are more flexible and easier to use, and are thus often faster to develop and prototype. But the results can be more unpredictable, as bugs you never predicted could pop up with real use.

What’s right for your company depends on your specific needs and what you’re trying to achieve with your project. Many (but not all) companies find that statically typed languages are preferable for large and complex projects with more lead time, while dynamically typed languages are preferable for smaller or more flexible projects that need to be completed more quickly.

Understanding the difference between runtime and compile time along with statically and dynamically typed languages can help both you and your programmers create more reliable and maintainable software for just about anything you need.