Fundamental rules and conventions govern how you write Julia code. Understanding these core syntax elements will help you write clear, correct, and readable programs from the very beginning.
In Julia, a program is a sequence of statements. Each statement is an instruction that tells the computer to perform an action. Typically, you write one statement per line. For example, assigning a value to a variable or printing something to the screen are common statements:
x = 10
println("Hello, Julia!")
Julia determines the end of a statement by a newline character. If you want to write multiple statements on a single line, you can separate them with a semicolon (;).
a = 5; b = 10; c = a + b
println(c) # This will print 15
While using semicolons for multiple statements on one line is possible, it's generally recommended to write one statement per line for better readability, especially when you're starting out.
As your programs grow, you'll want to add notes to explain what your code does, why it does it, or how it works. These notes are called comments. Julia ignores comments when it runs your code, so they are purely for human readers (including your future self!).
Julia has two main ways to write comments:
Single-line comments: Anything after a hash symbol (#) on a line is considered a comment.
# This is a single-line comment.
radius = 5 # Assigning the value 5 to the variable 'radius'
area = 3.14159 * radius^2 # Calculate the area
Multi-line comments: You can write comments that span multiple lines by enclosing them between #= and =#.
#=
This is a multi-line comment.
It can span several lines and is useful
for longer explanations or for temporarily
disabling a block of code.
=#
x = 100 # This line is not part of the multi-line comment above
Good commenting habits make your code much easier to understand and maintain. Try to explain the "why" more than the "what," especially if the code itself is straightforward.
Whitespace refers to spaces, tabs, and newlines. Julia is generally flexible about whitespace between elements of your code, but using it consistently makes your code much more readable. For example, it's common practice to put spaces around operators like +, -, =, etc.:
# Good practice:
result = (value1 + value2) * factor
# Less readable:
result=(value1+value2)*factor
Indentation refers to the spaces at the beginning of a line. While Julia doesn't strictly enforce indentation rules for the code to run (unlike languages like Python where indentation defines code blocks), consistent indentation is extremely important for readability. It helps visually group related lines of code, especially within control structures like loops or conditional statements that you'll learn about later. Most Julia programmers use 4 spaces for each level of indentation.
# Example of good indentation (more on 'if' later)
if x > 10
println("x is greater than 10")
# Further actions here would also be indented
end
Your code editor can often help you with automatic indentation.
Identifiers are the names you give to variables, functions, and other entities in your code. Choosing good, descriptive names is a foundation of writing understandable programs.
Here are the basic rules for identifiers in Julia:
myVariable and myvariable are different names._), and a wide range of Unicode characters (like π or α).if, else, while, function), that have special meaning in Julia and cannot be used as identifiers.Common Julia naming conventions include:
snake_case), for example, user_age, calculate_mean.camelCase (e.g., userAge, calculateMean) is also seen, though snake_case is more prevalent for variables and functions.CamelCase (e.g., MyCustomType, GraphicsModule).# Valid identifiers
count = 0
student_name = "Alice"
_temp_value = 25.5
π_val = 3.14159 # Julia supports Unicode characters
# Invalid identifier (starts with a digit)
# 1st_place = "Gold" # This would cause an error
While Julia's support for Unicode in identifiers is powerful, especially for scientific computing (e.g., using δ or Σ directly in your code), it's good practice to stick to standard ASCII characters (letters, numbers, underscore) if you are collaborating with others who might have different keyboard setups or editor support, or if you are just starting.
Julia has a set of keywords that have predefined meanings and form the basic structure of the language. You cannot use these keywords as names for your variables or functions. Some examples include:
if, else, elseif, while, for, function, struct, module, begin, end, try, catch, finally, return, true, false, const.
You don't need to memorize all of them right now. As you learn more Julia constructs, you'll become familiar with them naturally. If you accidentally try to use a keyword as a variable name, Julia will give you an error message. For instance, if = 10 would be invalid.
end KeywordMany structures in Julia, such as conditional statements (if), loops (for, while), function definitions (function), and module definitions (module), define blocks of code. These blocks are typically terminated by the end keyword. This is a fundamental aspect of Julia's syntax that groups related statements together.
# A simple example you'll understand more deeply later
x = 5
if x < 10 # Start of an 'if' block
println("x is less than 10")
y = x * 2 # This statement is part of the 'if' block
println(y)
end # Marks the end of the 'if' block
println("This line is outside the if block.")
The consistent use of end to close blocks contributes significantly to code clarity.
By keeping these core syntax elements in mind, writing clear statements, using comments effectively, maintaining consistent indentation, choosing sensible names, and understanding how code blocks are structured, you'll be well on your way to writing Julia code that is not only functional but also easy for others (and yourself) to read and understand. As you progress, these rules will become second nature.
Was this section helpful?
© 2026 ApX Machine LearningAI Ethics & Transparency•