Arithmetic operators in Go - Deep Dive

Overview - Arithmetic operators

What is it?

Arithmetic operators are symbols that let you do basic math like adding, subtracting, multiplying, and dividing numbers in a program. They help the computer calculate values just like you do on paper or a calculator. In Go, these operators work with numbers to produce new numbers as results.

Why it matters

Without arithmetic operators, computers couldn't perform even simple calculations, making it impossible to solve everyday problems like totaling prices, measuring distances, or counting items. They are the foundation for all math-related tasks in programming, enabling everything from games to financial software to work correctly.

Where it fits

Before learning arithmetic operators, you should understand basic data types like integers and floats. After mastering them, you can move on to more complex topics like expressions, operator precedence, and functions that use these operators.

Mental Model

Core Idea

Arithmetic operators are the tools that let your program do math by combining or changing numbers to get new results.

Think of it like...

Think of arithmetic operators like kitchen tools: addition is like mixing ingredients, subtraction is like removing some, multiplication is like repeating a recipe several times, and division is like sharing a cake equally among friends.

  Numbers
    │
    ▼
┌───────────────┐
│ Arithmetic    │
│ Operators     │
│ +  -  *  / %  │
└───────────────┘
    │
    ▼
  Result

Build-Up - 7 Steps

1

Foundation

Basic arithmetic operators in Go

Concept: Introduce the main arithmetic operators and their symbols in Go.

Go uses + for addition, - for subtraction, * for multiplication, / for division, and % for remainder (modulus). These operators work with integer and floating-point numbers. For example, 5 + 3 equals 8, and 10 - 4 equals 6.

Result

You can write expressions like 7 * 2 or 9 / 3 to get 14 and 3 respectively.

Knowing these basic symbols lets you perform simple math directly in your Go programs.

2

Foundation

Using arithmetic operators with variables

Concept: Learn how to apply arithmetic operators to variables holding numbers.

You can store numbers in variables and then use arithmetic operators on them. For example: var a int = 10 var b int = 3 var sum = a + b var diff = a - b This calculates sum as 13 and diff as 7.

Result

Variables can hold values that you can add, subtract, multiply, divide, or find the remainder of.

Using variables with operators makes your programs flexible and able to handle changing data.

3

Intermediate

Integer division and remainder operator

🤔Before reading on: Do you think dividing two integers in Go always gives a decimal result or an integer result? Commit to your answer.

Concept: Understand how division works with integers and how the remainder operator (%) gives the leftover part.

In Go, dividing two integers with / gives an integer result by dropping any decimal part. For example, 7 / 3 equals 2, not 2.333. To get the leftover part, use the % operator: 7 % 3 equals 1, which is the remainder.

Result

Integer division truncates decimals, and % gives the remainder after division.

Knowing this prevents bugs when you expect decimal results but get truncated integers instead.

4

Intermediate

Arithmetic with floating-point numbers

🤔Before reading on: Do you think the % operator works with floating-point numbers in Go? Commit to your answer.

Concept: Learn how arithmetic operators behave with decimal numbers (floats) and the limitations of the remainder operator.

Go allows +, -, *, and / with float64 or float32 types, giving decimal results. However, the % operator does NOT work with floats in Go; it only works with integers. For example, 5.5 + 2.3 equals 7.8, but 5.5 % 2.3 is invalid.

Result

You can do decimal math with floats, but you cannot use % with them.

Understanding type rules helps avoid errors and choose the right operator for your data.

5

Advanced

Operator precedence and associativity

🤔Before reading on: In the expression 3 + 4 * 2, do you think addition or multiplication happens first? Commit to your answer.

Concept: Learn the order in which Go evaluates arithmetic operators when combined in one expression.

Go follows standard math rules: multiplication (*) and division (/) have higher precedence than addition (+) and subtraction (-). So, 3 + 4 * 2 is evaluated as 3 + (4 * 2) = 11, not (3 + 4) * 2 = 14. Operators with the same precedence are evaluated left to right (associativity).

Result

Expressions are evaluated predictably, following math rules, unless parentheses change the order.

Knowing precedence avoids unexpected results and helps write clear expressions.

6

Advanced

Compound assignment operators

Concept: Discover shorthand operators that combine arithmetic with assignment.

Go lets you write shorter code using operators like +=, -=, *=, /=, and %=. For example, x += 5 means x = x + 5. This makes code cleaner and easier to read when updating variables.

Result

You can update variables with math in a concise way.

Using compound operators improves code readability and reduces mistakes.

7

Expert

Subtleties of integer overflow and precision

🤔Before reading on: Do you think Go automatically prevents integer overflow or silently wraps around? Commit to your answer.

Concept: Understand what happens when arithmetic results exceed the limits of integer types and how floating-point precision affects calculations.

In Go, integer types have fixed sizes (e.g., int32, int64). If a calculation exceeds the max value, it wraps around silently without error, causing unexpected results. Floating-point numbers have limited precision, so some decimal values can't be represented exactly, leading to small rounding errors.

Result

Arithmetic can produce surprising results if you don't consider type limits and precision.

Knowing these limits helps prevent bugs in critical calculations and guides choosing the right types.

Under the Hood

Go's arithmetic operators are implemented at the machine level using CPU instructions. When you write an expression, the Go compiler translates it into instructions that the processor executes. For integers, operations happen in fixed-size registers, so exceeding their capacity causes wraparound. For floats, Go uses IEEE 754 standard, which stores numbers in binary with limited bits, causing precision limits.

Why designed this way?

Go was designed for simplicity and performance. Using fixed-size integers and IEEE 754 floats matches hardware capabilities, making arithmetic fast and predictable. Silent overflow is a tradeoff to avoid slowing down programs with extra checks, leaving it to programmers to handle carefully.

┌───────────────┐
│ Go source code│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Go compiler   │
│ translates to │
│ machine code  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ CPU executes  │
│ arithmetic    │
│ instructions  │
└───────────────┘
       │
       ▼
┌───────────────┐
│ Registers hold│
│ integer/float │
│ values        │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does 7 / 3 in Go give 2.333 or 2? Commit to your answer.

Common Belief: Dividing two integers always gives a decimal result.

Reality: Dividing two integers in Go truncates the decimal part and returns an integer.

Why it matters: Expecting decimals but getting truncated integers can cause wrong calculations and bugs.

Quick: Can you use % with floating-point numbers in Go? Commit to your answer.

Common Belief: The remainder operator (%) works with all number types, including floats.

Reality: In Go, % only works with integers; using it with floats causes a compile error.

Why it matters: Trying to use % with floats leads to errors and confusion about how to get remainders for decimals.

Quick: Does Go automatically detect and prevent integer overflow? Commit to your answer.

Common Belief: Go checks for integer overflow and throws an error if it happens.

Reality: Go does not check for overflow; integers wrap around silently when exceeding limits.

Why it matters: Silent overflow can cause subtle bugs that are hard to find and fix.

Quick: In 3 + 4 * 2, does addition happen before multiplication? Commit to your answer.

Common Belief: Operators are evaluated strictly left to right, so addition happens first.

Reality: Multiplication has higher precedence, so it happens before addition.

Why it matters: Misunderstanding precedence leads to wrong results and unexpected behavior.

Expert Zone

1

Integer overflow is silent in Go, so critical systems often use bigger types or manual checks to avoid errors.

2

Floating-point arithmetic can introduce tiny errors; experts use specialized libraries or decimal types for precise financial calculations.

3

Compound assignment operators can sometimes change the type of the variable if used with mixed types, which requires careful attention.

When NOT to use

Avoid using basic arithmetic operators for very large numbers or high-precision decimals; instead, use big.Int or big.Float from Go's math/big package. For financial or scientific calculations needing exact decimals, consider decimal libraries to prevent floating-point errors.

Production Patterns

In real-world Go programs, arithmetic operators are combined with error handling for overflow, used in loops for counters, and applied in algorithms like sorting or graphics. Compound assignments are common for concise updates, and understanding operator precedence helps maintain complex expressions.

Connections

Data types

Arithmetic operators depend on the data types they work with.

Knowing how data types affect arithmetic helps prevent errors like overflow or invalid operations.

Computer architecture

Arithmetic operators map directly to CPU instructions.

Understanding hardware execution explains why some operations are fast and why overflow happens silently.

Basic math education

Arithmetic operators follow the same rules as school math.

Familiarity with math precedence and operations makes learning programming arithmetic easier.

Common Pitfalls

#1 Expecting decimal results from integer division.

Wrong approach:

var result int = 7 / 3
fmt.Println(result) // expects 2.333 but gets 2

Correct approach:

var result float64 = 7.0 / 3.0
fmt.Println(result) // prints 2.3333333333333335

Root cause:

Not realizing that dividing two integers truncates the decimal part in Go.

#2 Using % operator with floating-point numbers.

Wrong approach:

var remainder = 5.5 % 2.0 // compile error

Correct approach:

import "math"
var remainder = math.Mod(5.5, 2.0)
fmt.Println(remainder) // prints 1.5

Root cause:

Assuming % works like modulo for floats, but Go requires math.Mod for float remainders.

#3 Ignoring integer overflow in calculations.

Wrong approach:

var x int8 = 127
x = x + 1
fmt.Println(x) // prints -128 silently

Correct approach:

var x int16 = 127
x = x + 1
fmt.Println(x) // prints 128 safely

Root cause:

Not understanding fixed size of integer types and silent wraparound behavior.

Key Takeaways

Arithmetic operators let you perform basic math in Go using symbols like +, -, *, /, and %.

Integer division truncates decimals, so use floats for precise decimal results.

The % operator works only with integers; use math.Mod for floating-point remainders.

Operator precedence follows standard math rules, with multiplication and division before addition and subtraction.

Be aware of integer overflow and floating-point precision limits to avoid subtle bugs.