Standard: Concurrent Programming
In this lecture, we begin by getting a context for what Syntax and Semantics are in programming languages to appropriately set ourselves up for learning Rust. We then take a 'sneak peak' at the Rust language as is solves the Change Making Problem.
📅 January 14, 2026
Concurrent Programming
"The study of how words and morphemes combine to form larger units like phrases or sentences."
Syntax is all about structure—the rules that govern how symbols can be arranged. Think of it like the grammar of a language, but stripped of all meaning.
Consider this English sentence:
"The cat likes to eat fish."
We can break this down into grammatical components:
| Fragment | Classification |
|---|---|
| The cat | Noun phrase |
| likes | Verb |
| to eat | Infinitive |
| fish | Noun |
This reveals the grammatical structure of the sentence.
⚠️ WAIT! Before we continue, it's important to note that we are NOT talking about the meaning of the sentence. We are only talking about the structure. Do your best to ignore the meaning of the words!
We can abstract away the meaning entirely:
"The cat likes to eat fish." → "Noun-Phrase Verb Infinitive Noun"
Consider this malformed sentence:
"Bob fan a Lakers is of the"
Is this problematic because of what the words mean? Or because of how they're arranged?
The malformed grammar creates ambiguity when we try to parse it:
We simply can't tell! And that's the point—syntax is about structure, not meaning.
Good news: you're already familiar with programming language syntax! Let's look at Python:
total = previous + current
Thanks to syntax highlighting in your editor, we can identify the tokens:
| Token | Classification |
|---|---|
total | Variable |
= | Assignment operator |
previous | Variable |
+ | Arithmetic operator |
current | Variable |
But we can be more precise! At a higher level:
| Fragment | Classification |
|---|---|
previous + current | Expression |
total = previous + current | Statement |
| Type | Behavior | Analogy |
|---|---|---|
| Expression | Evaluates to a value | Like solving a math equation |
| Statement | Commands an action | Like giving an instruction |
Expressions evaluate to a single value:
1 + 1 # → 2
print("Hello, World!") # → None
len([1, 2, 3]) == 3 # → True
Statements control program flow—they don't "simplify" to anything:
# Conditional: skip code block if condition is false
if x > 10:
print("x is greater than 10")
# Loop: repeat code block while condition holds
while x < 10:
x += 1
# Function definition: bind a name to executable code
def add(a, b):
return a + b
Understanding syntax helps us answer questions like:
We don't need to know what's stored in the variables to understand what's about to happen!
📌 Key Insight: Syntax gives us rules for how to validly organize tokens in a programming language. A token is the smallest unit of meaningful information—a single "piece" of the language.
this is a variable = 23
If your editor's coloring looks wrong, you may have made a syntax error!
"The meaning transported through symbols."
While syntax is about structure, semantics is about meaning—the actual stuff we store in our language's symbols.
We would never say that the characters r, e, d, c, a, r are themselves a red car. Instead, we recognize:
red → stores information about the color redcar → stores information about vehicles with four wheels and a motorWe create syntax rules to define how tokens can be arranged. We then assign meaning to those arrangements, so that when someone else reads our code, they can extract that meaning.
Consider this Python code:
print("Hello, World!")
| Token | Classification |
|---|---|
print | Variable (identifier) |
(...) | Call operator |
"Hello, World!" | String literal |
Here's what actually happens when this code runs:
print"Hello, World!" as an argumentNoneLet's see how Python and Rust express the same algorithm with different syntax. This classic problem counts coins needed for a given amount.
def make_change(amount):
denominations = [25, 10, 5, 1]
change = []
for denomination in denominations:
count = 0
while amount >= denomination:
amount -= denomination
count += 1
change.append(count)
return change
if __name__ == "__main__":
amount = 410
change = make_change(amount)
print(f"Change for {amount} is: {change}")
fn main() {
let amount: i16 = 410;
let change = make_change(amount);
println!("Change for {} is: {:?}", amount, change);
}
fn make_change(mut amount: i16) -> Vec<i16> {
let denominations = vec![25, 10, 5, 1];
let mut change = Vec::new();
for denomination in denominations {
let mut count = 0;
while amount >= denomination {
amount -= denomination;
count += 1;
}
change.push(count);
}
change
}
Notice how Rust's syntax carries more information:
| Feature | Python | Rust |
|---|---|---|
| Type annotations | Implicit | Explicit and Implicit (i16, Vec<i16>) |
| Mutability | Implicit | Explicit (mut) |
| Return type | Implicit | Explicit (-> Vec<i16>) |
| Memory management | Garbage collected | Ownership system |
💡 Observation: Rust's larger syntax vocabulary allows it to store more specific semantic information directly in the code structure!
mut keyword) often carries more semantic information directly in the codeKey Takeaways: