Writing and Running Your First Julia Script

The Julia REPL (Read-Eval-Print Loop) serves as an excellent tool for experimenting with code snippets and obtaining immediate feedback. However, for larger programs or reusable utilities, saving your work becomes essential. Julia scripts fulfill this purpose. A Julia script is a plain text file containing Julia code, typically saved with a .jl extension.

Creating Your First Script File

To write a Julia script, you'll need a text editor. In the previous section, "Choosing Your Julia Development Environment," we discussed various options. If you've set up an Integrated Development Environment (IDE) like Visual Studio Code with the Julia extension, or an editor like Atom with Juno, you can use that. For now, even a basic text editor like Notepad (on Windows), TextEdit (on macOS, ensuring it's in plain text mode), or Gedit (on Linux) will suffice.

1. Open your chosen text editor. This will give you a blank canvas to write your code.

2. Type the following line of code:

   println("Hello, Julia!")
   

   This line uses the println() function. The println (short for "print line") function is a fundamental Julia command used to display text or values to the console. Whatever you put inside the parentheses and quotes will be printed, followed by a newline character, which moves the cursor to the next line in the console.

3. Save the file.

   • Go to File > Save As... in your text editor.
   • Choose a location where you can easily find it, for example, your Desktop or a new folder you might create called julia_projects.
   • Name your file hello.jl. It's important to use the .jl extension, as this tells the system (and the Julia interpreter) that it's a Julia file.

You've now written your first Julia script! It's a simple one, but the process is the same for scripts of any complexity.

Running Your Julia Script

With your hello.jl script saved, the next step is to run it. This is typically done using your system's command line interface (CLI), also known as the terminal or command prompt.

1. Open your terminal or command prompt:

   • Windows: Search for "Command Prompt" or "PowerShell".
   • macOS: Open "Terminal" (you can find it in Applications > Utilities, or search via Spotlight).
   • Linux: This varies by distribution, but usually, you can press Ctrl+Alt+T or find "Terminal" in your applications menu.

2. Navigate to the directory where you saved your file. The terminal usually opens in your home directory. You'll need to use the cd (change directory) command to move to the folder containing hello.jl.

   • For example, if you saved it on your Desktop, you might type: cd Desktop
   • If you saved it in a folder named julia_projects inside your Documents folder, you might type (adjust paths as needed): cd Documents/julia_projects (on macOS/Linux) cd Documents\julia_projects (on Windows)

   You can use the ls (on macOS/Linux) or dir (on Windows) command to list the files in the current directory to confirm hello.jl is there.

3. Run the script. Once you are in the correct directory, type the following command and press Enter:

   julia hello.jl
   

   This command tells the Julia interpreter (the julia part) to execute the code contained in the hello.jl file.

You should see the following output printed to your terminal:

Hello, Julia!

Congratulations! You've successfully written and executed your first Julia script.

If you are using an IDE like VS Code with the Julia extension, there's often a "Run" button (usually a triangle icon) or a command in the menu (e.g., "Julia: Execute File") that can run the script directly within the IDE, handling the terminal commands for you. This can be more convenient for development.

A Slightly More Involved Example

Let's expand on our first script to see a bit more. Open your hello.jl file (or create a new one, perhaps myscript.jl) and modify it or type the following:

# This is a comment. Julia ignores lines starting with #.

# Storing a message in a variable
message = "Start Julia scripting!"
println(message)

# Performing a simple calculation
base_value = 15
multiplier = 3
result = base_value * multiplier

println("The result of the calculation is: ", result)
println("We multiplied ", base_value, " by ", multiplier, ".")

Save this file and run it from your terminal using julia <your_filename>.jl. The output will be:

Welcome to Julia scripting!
The result of the calculation is: 45
We multiplied 15 by 3.

In this example:

• Lines starting with # are comments. They are for human readers to understand the code; Julia ignores them.
• We created variables (message, base_value, multiplier, result) to store data (text and numbers). We'll cover variables in detail in the next chapter.
• We performed a simple multiplication (* is the multiplication operator).
• println can print the content of variables and can also print multiple items if you separate them with commas.

The Edit-Save-Run Cycle

The process you've just followed:

1. Edit your code in a text editor.
2. Save the file.
3. Run the script from the terminal (or IDE).
4. Observe the output and repeat if necessary.

This is the fundamental workflow for most programming. As you develop more complex programs, you'll repeat this cycle many times, gradually building and refining your code.

By writing and running these simple scripts, you've taken an important step. You now know how to create standalone Julia programs that can be executed, saved, and shared. In the following sections and chapters, we'll build upon this foundation, exploring Julia's syntax, data types, and features in more detail.