Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle. It only takes a minute to sign up.
Sign up to join this community
As far as my understanding goes, compilers are meant for developers compiling their code into executable (machine-code) files. Compilers don't extend to a client's machine or end-user system.
Instead, developers just use the compiler to convert their code into machine code, which is then transported to the other machines for use as applications.
Do compilers have a function outside of this process? If so, when are they used?
Yes and no. Yes, the classical scenario is a developer using a compiler to generate machine code from source code, and the machine code is then distributed to the users.
There are a few exceptions to this though. First, many open source projects are distributed primarily (or even exclusively) in source code form, and expect the end user to install them by typing in a couple of commands like make and then make intall. This will invoke the compiler, linker, etc., to generate the machine code from the source code for that users computer. In these cases, however, the process of building and installing is (at least intended to be) automated to the point that the user rarely needs much knowledge of it beyond the fact that if they've never installed a source code-only package previously, their package manager will typically list some "development" package as a prerequisite for installing the application they really care about (though some still see this as unfriendly to end users).
Another exception (that's been alluded to, but not explained very well in the other answers I've seen) is just-in-time (JIT) compilers. A couple of obvious examples of JIT compilers are the Microsoft Common Language Runtime (CLR) and the Java Virtual Machine (JVM). In these cases, there are normally two entirely separate compilers involved in translating source code into machine code. One is used by the developer. However, rather than generating machine code directly, it generates a machine-independent byte code. The CLR/JVM then includes a second compiler, entirely separate from the first, that converts those byte codes to machine code for the target computer.
I should add that the second compiler isn't strictly necessary. Early versions of the JVM (for one example) just interpreted the byte codes instead of compiling them. This often carries a fairly serious performance penalty though, so most reasonably recent JVMs intended for production use include a JIT compiler.
Yes, compilers are mainly used by developers, with a couple of notable exceptions. End users sometimes use compilers to compile and install the latest open source software, even if they don't make any changes to the code. Also, some programming languages don't have compilers. They use interpreters instead that "compile" on the fly. In that case, end users need to have the interpreter installed on their machines.
Yes
A compiler is defined as a program that translates code from one language into another (see Wikipedia). The most common use of compilers is to translate the source language into machine code, but this does define the word "compiler".
For example, Python generates byte-code when it imports a module, and thus fits within the definition of a compiler (because it converts from the source language, Python, into the target language, Python byte-code).
Another example is the V8 JavaScript engine. It converts JavaScript into x86 machine code, and thus fits into the definition of a compiler as well. Not only does V8 fit the definition of a compiler, but it is included in Chrome and is very widely used on client machines.
One case would be for an application that dynamically generated code at runtime, and then ran the generated code. This code would need to be compiled at runtime.
Edit: There are other exceptions, but they had already been mentioned in other answers.
compilers are meant only for developers for compiling their programming-language code to executable(machin-code) files
I would say "compilers are meant primary for developers ...". But I have seen examples where programs generate new programming-language code on-the-fly and therefore need a compiler to be installed on the end users machine. That does not mean the end-user has to work with the compiler by itself.
Possible reasons for this program design:
performance: think of a rule-driven application where the rules are stored in some kind of end-user data store and you have some mass-data to be processed by those rules. Instead of interpreting the rules again and again, a program generates the processing code first, compiles it and runs it against the data to be processed
think of a program where the end user can add some kind of math formula and the developer of the program does not want to implement his own parser/interpreter for this. Instead, the program takes this formula, makes some additions to transform it into a valid piece of program code, let the compiler compile it and runs it afterwards.
That's right -- compilers compile source code into executable form, which is then linked into an executable binary file by a linker. Source code can also be executed directly by an interpreter such as one of the many command-line shells (C-shell, bash, zsh, etc.), awk, sed, and so on.
It can be hard to draw a clear line between "developer" and "end user" unless you limit your discussion to a specific product. Developers are all "end users" of the tools they use, and "end users" may have development tools such as compilers and interpreters installed on their machines.
Administrators may also have a need for using programming languages in writing scripts to perform various automated tasks. For example, having a script that deletes old log files off a server after 90 days to free up some disk space. The language used to write the script has to be interpreted or compiled so that it can be run on the system.
Some programs are meta-programs: while running, they might generate some other program (or some source code) and compile it then run it somehow. Read also about multi-stage programming.
So to use these kind of programs, a compiler would be needed, even if the user does not know how to program himself (because the computer would generate some code which needs to be compiled).
For an example, see MELT (which generates C++ code to extend GCC) or J.Pitrat's CAIA artificial intelligence system (which generate C code -notably its own code- to solve combinatorial problems).
Also, some languages and some implementations nearly require a compiler to be present everywhere (in every program coded in that language & implementation). First, several web browsers contain a Javascript JIT engine (like V8). Also, most Common Lisp implementations -e.g. SBCL- contain a compiler (even useful to running applications, which might generate and evaluate expressions). Read also about homoiconic languages and Qine programs.
