Expressions and Operators

students, welcome to the part of programming where computers start doing useful work with your data 🤖💡 In Engineering Computation, expressions and operators are the tools that let a program calculate, compare, and make decisions. If variables are the containers, then expressions are the instructions that tell the computer how to combine those containers and values.

What you will learn

By the end of this lesson, students, you should be able to:

Explain what expressions and operators are in programming.
Identify different kinds of operators and what they do.
Build and evaluate expressions using numbers, variables, and parentheses.
Understand how expressions support later topics like selection and branching.
Use examples from engineering and everyday computing to show why expressions matter.

Think about a phone app that calculates your total food bill 🍔. Or a robot that checks whether a part is too hot. Or a program that decides whether a bridge sensor reading is above a safe limit. All of those tasks depend on expressions and operators.

What is an expression?

An expression is any valid combination of values, variables, and operators that produces a result. In simple terms, it is a piece of code that can be evaluated.

Examples of expressions include $3 + 4$, $x + 2$, and $temperature > 100$.

Each expression has a value:

$3 + 4$ evaluates to $7$.
If $x = 10$, then $x + 2$ evaluates to $12$.
If $temperature = 105$, then $temperature > 100$ evaluates to true.

Expressions are important because programs are not just lists of commands. They also need to calculate values and ask questions. A computer uses expressions to find totals, determine averages, compare measurements, and choose what to do next.

A key idea is that expressions can contain variables. A variable is a named storage location whose value may change. For example, in $speed = 60$, the symbol $speed$ represents a stored value. Then you can use $speed$ inside a larger expression like $speed \times time$.

Operators: the symbols that do the work

Operators are the symbols or words that tell the computer how to combine or compare values. Different operators have different jobs.

Arithmetic operators

Arithmetic operators are used for math operations:

$+$ addition
$-$ subtraction
$\times$ multiplication
$/$ division
$\%$ modulo, which gives the remainder

Examples:

$8 + 5 = 13$
$20 - 7 = 13$
$6 \times 4 = 24$
$12 / 3 = 4$
$17 \% 5 = 2$

The modulo operator is very useful in programming. For example, if a clock shows seconds, $65 \% 60 = 5$, so 65 seconds is 5 seconds past a full minute. It is also used to check whether a number is even or odd. If $n \% 2 = 0$, then $n$ is even.

Relational operators

Relational operators compare two values and return either true or false. They are used to test conditions.

Common relational operators include:

$=$ or $==$ equal to
$\neq$ not equal to
$<$ less than
$>$ greater than
$\leq$ less than or equal to
$\geq$ greater than or equal to

Examples:

$7 < 10$ is true.
$15 \geq 20$ is false.
$pressure \leq 100$ may be true or false depending on the value of $pressure$.

These operators are essential when a program must decide something, such as whether a value is within a safe range.

Logical operators

Logical operators combine true/false expressions.

Common logical operators include:

AND, often written as $\land$
OR, often written as $\lor$
NOT, often written as $\lnot$

Examples:

$(x > 0) \land (x < 10)$ is true only when $x$ is between 0 and 10.
$(temp < 0) \lor (temp > 100)$ is true when the temperature is outside a normal range.
$\lnot(age < 18)$ means “not less than 18,” so it is true when $age \geq 18$.

Logical operators help programs combine multiple conditions, like checking whether a student has both attended class and submitted the assignment.

How expressions are evaluated

To evaluate an expression means to figure out its value. Computers do this by following rules of precedence, which decide which operations happen first.

A common order is:

Parentheses
Exponents
Multiplication, division, and modulo
Addition and subtraction
Comparisons
Logical operators

For example, consider $3 + 4 \times 2$.

Because multiplication happens before addition, the computer calculates $4 \times 2 = 8$ first, then $3 + 8 = 11$.

If we want the addition first, we use parentheses: $(3 + 4) \times 2 = 14$.

Parentheses are a powerful tool because they remove confusion and make the programmer’s intention clear. In engineering work, this matters a lot. A formula for a load, a voltage calculation, or a control condition must be interpreted correctly.

For example, if a sensor calibration formula is $y = a(x - b)$, then the subtraction must happen before multiplication. Without parentheses, the result could be wrong.

Expressions in engineering and real-world programming

Expressions are everywhere in Engineering Computation 🔧

Imagine a program that checks the load on a beam. It may calculate a safety ratio such as

$$\text{safety ratio} = \frac{\text{maximum load}}{\text{allowed load}}$$

If the ratio is greater than $1$, the beam may be overloaded. That comparison uses a relational operator.

Or imagine a temperature control system. A heater might turn on when

$$\text{temperature} < 20$$

and turn off when

$$\text{temperature} \geq 20$$

That simple decision depends on expressions.

Another example is a paycheck calculator. If a worker earns overtime, the program might compute

$$\text{pay} = (40 \times r) + (h - 40) \times 1.5r$$

where $h$ is total hours and $r$ is the hourly rate.

This formula uses multiplication, subtraction, addition, and parentheses. A small mistake in the expression could lead to the wrong payment.

Expressions also help with data processing. A program may calculate averages, convert units, or check limits. For example, converting Celsius to Fahrenheit can be written as

$$F = \frac{9}{5}C + 32$$

This is a classic expression because it combines constants, variables, multiplication, division, and addition.

Connecting expressions to selection and branching

Expressions are closely connected to selection and branching, which are the parts of programming where a program chooses between actions.

A branching statement usually depends on a condition, and that condition is built from an expression. For example:

$$x > 0$$

This expression may be used in an if-statement. If it is true, the program does one thing; if it is false, it does something else.

Example in plain language:

If $score \geq 50$, then the student passes.
Otherwise, the student does not pass.

Here, the comparison $score \geq 50$ is the expression that controls the branch.

This shows why expressions are part of the bigger picture of Programming Foundations. Before a program can make decisions, it needs values to compare. Before it can compare values, it needs variables and operators. Expressions are the bridge between raw data and program behavior.

Common mistakes to avoid

When learning expressions, students, a few mistakes come up often:

Forgetting parentheses when they matter.
Mixing up assignment and comparison.
Using the wrong operator, such as $<$ instead of $\leq$.
Assuming a condition is true without checking the actual values.
Writing expressions that are hard to read because they are too long.

One especially important distinction is between assignment and comparison. In many programming languages, $=$ is used to assign a value to a variable, while $==$ checks whether two values are equal. The exact symbols depend on the language, but the idea is always important: storing a value is not the same as comparing values.

Clear expressions are easier to test and debug. Good programmers write expressions that are simple, readable, and correct.

Conclusion

Expressions and operators are a foundation of programming because they let a computer calculate, compare, and decide. Arithmetic operators handle math, relational operators test conditions, and logical operators combine conditions. By using variables, parentheses, and operator precedence correctly, programmers can build accurate instructions for real-world tasks like billing, control systems, and data analysis.

students, if you understand expressions and operators, you have taken an important step in Engineering Computation. These ideas connect directly to variables, data types, and later to selection and branching. In other words, expressions are not just a small topic. They are one of the main tools that make programs useful.

Study Notes

An expression is a combination of values, variables, and operators that evaluates to a result.
Arithmetic operators such as $+$, $-$, $\times$, $/$, and $\%$ perform math.
Relational operators such as $<$, $>$, $\leq$, and $\geq$ compare values and give true or false.
Logical operators such as $\land$, $\lor$, and $\lnot$ combine or change conditions.
Operator precedence tells the computer which operations to do first.
Parentheses change the order of evaluation and make expressions clearer.
Expressions are used in engineering tasks like safety checks, unit conversion, and control systems.
Branching statements depend on expressions because conditions must be true or false.
Good programming practice means writing expressions that are accurate, readable, and easy to test.