People often describe programming languages as either compiled or interpreted. \u201cCompiled\u201d means that programs are translated into machine language and then executed by hardware; \u201cinterpreted\u201d means that programs are read and executed by a software interpreter. Usually C is considered a compiled language and Python<\/a> is considered an interpreted language. But the distinction is not always clear-cut.<\/p>\n First, many languages can be either compiled or interpreted. For example, there are C interpreters<\/a> and Python compilers. Second, there are languages like Java that use a hybrid approach, compiling programs into an intermediate language and then running the translated program in an interpreter. Java uses an intermediate language called Java bytecode, which is similar to machine language, but it is executed by a software interpreter, the Java virtual machine (JVM)<\/a>.<\/p>\n So being compiled or interpreted is not an intrinsic characteristic of a language; nevertheless, there are some general differences between compiled and interpreted languages.<\/p>\n Many interpreted languages support dynamic types, but compiled languages are usually limited to static types. In a statically-typed language, you can tell<\/p>\n by looking at the program what type each variable refers to. In a dynamically-typed language, you don\u2019t always know the type of a variable until the program is running. In general, static refers to things that happen at compile time (while a program is being compiled), and dynamic refers to things that happen at run time (while a program is running).<\/p>\n For example, in Python you can write a function like this:<\/p>\n def add(x, y): Looking at this code, you can\u2019t tell what type x and y will refer to at run time. This function might be called several times, each time with values with different types. Any values that support the addition operator will work; any other types will cause an exception or runtime error.<\/p>\n In C you would write the same function like this:<\/p>\n int add(int x, int y) { The first line of the function includes type declarations for the parameters and the return value: x and y are declared to be integers, which means that we can check at compile time whether the addition operator is legal for this type (it is). The return value is also declared to be an integer.<\/p>\n Because of these declarations, when this function is called elsewhere in the program, the compiler can check whether the arguments provided have the right type, and whether the return value is used correctly.<\/p>\n These checks happen before the program starts executing, so errors can be found earlier. More importantly, errors can be found in parts of the program that have never run. Furthermore, these checks don\u2019t have to happen at run time, which is one of the reasons compiled languages generally run faster than interpreted languages.<\/p>\n Declaring types at compile time also saves space. In dynamic languages, variable names are stored in memory while the program runs, and they are of ten accessible by the program. For example, in Python the built-in function<\/a> locals returns a dictionary that contains variable names and their values. Here\u2019s an example in a Python interpreter:<\/p>\n > x = 5 This shows that the name of the variable is stored in memory while the program is running (along with some other values that are part of the default runtime environment).<\/p>\n1.2 Static types<\/h4>\n
\nreturn x + y<\/p>\n
\nreturn x + y;
\n}<\/p>\n
\n>>> print locals()
\n{‘x’: 5, ‘__builtins__’: <module ‘__builtin__’ (built-in)>, ‘__name__’: ‘__main__’, ‘__doc__’: None, ‘__package__’: None}<\/p><\/blockquote>\n