When it comes to programming, the process of turning your source code into a running program typically involves two main steps: compilation and execution. While this might seem like a straightforward concept, it's essential to understand that not all programming languages follow the same workflow. In the world of Rust, a systems programming language known for its emphasis on safety and performance, compiling and running are separate steps. Here we'll delve into the details of these two distinct phases and explore why Rust takes this approach.
Compilation: Turning Source Code into an Executable
Before you can run a Rust program, you must first compile it using the Rust compiler, commonly referred to as `rustc`. This process transforms your source code into a binary executable. To compile your Rust program, you need to open a terminal and use the `rustc` command followed by the name of your source file, like this:
$ rustc main.rs
If you have experience with C or C++, you might find this process familiar, as it's akin to using `gcc` or `clang` for compiling C/C++ programs. Once the compilation is successful, Rust will produce an executable binary file. On Linux, macOS, and PowerShell on Windows, you can view the executable by entering the `ls` command in your shell:
$ ls
main main.rs
Here, you'll see two files: your source code file with the `.rs` extension and the generated executable (named `main` on most platforms, but `main.exe` on Windows).
For Windows users, if you prefer using the Command Prompt (CMD), you can list the files as follows:
> dir /B
main.exe
main.pdb
main.rs
The `/B` option in the `dir` command is used to display only the file names. In this listing, you'll find the source code file, the executable file (named `main.exe`), and, specifically for Windows, a file with debugging information bearing the `.pdb` extension.
Execution: Running the Compiled Program
Once you have successfully compiled your Rust program, you are ready to execute it. To run your program, you use the command line in your terminal. On Linux and macOS, as well as PowerShell on Windows, you run the program like this:
$ ./main
On Windows, you should use the backslash instead of a forward slash:
> .\main.exe
If your `main.rs` is a simple "Hello, world!" program, executing the program as shown above will print "Hello, world!" to your terminal.
Rust's Ahead-of-Time Compilation
If you are more accustomed to dynamic languages like Ruby, Python, or JavaScript, this separate compilation step might seem unusual. Languages like Ruby, Python, and JavaScript are typically interpreted or have one-step execution, meaning you write and run your code in a single command.
Rust, however, is an ahead-of-time compiled language. This means you can compile a program and provide the resulting executable to someone else, even if they don't have Rust installed on their system. In contrast, with languages like Ruby, Python, or JavaScript, you need to ensure the recipient has the corresponding language runtime installed.
This separation of compilation and execution in Rust offers advantages in terms of performance and portability. The compiled executable is optimized for the target architecture, making it more efficient and enabling you to distribute your code to users who may not be developers or have Rust installed on their systems.
