Error Types & Exception Names

Detected by the interpreter/compiler before the code runs. The program never starts.

// Python
print("Hello"
       ↑ SyntaxError: unexpected EOF — missing closing parenthesis

// JavaScript
const x = {name: "Alice" age: 30}
                       ↑ SyntaxError: missing comma

• Missing parenthesis, bracket, or semicolon
• Misspelled keyword (`funtion` instead of `function`)
• Mismatched quotes or brackets
• Invalid indentation in Python

At runtime, when the code tries to do something a value does not support.

// JavaScript
const num = 42;
num();  // TypeError: num is not a function

const user = null;
console.log(user.name);
  // TypeError: Cannot read properties of null

• Calling a non-function as a function
• Accessing properties on `null` or `undefined`
• Expecting a string but receiving an array
• Wrong argument type passed to a function

At runtime, when the JavaScript engine looks up a name and cannot find it in scope.

// JavaScript
console.log(userName);
  // ReferenceError: userName is not defined

function greet() {
  const msg = "Hello";
}
console.log(msg);
  // ReferenceError: msg is not defined (out of scope)

• Using a variable before declaring it (`let`/`const` in the temporal dead zone)
• Typo in a variable name
• Accessing a variable outside its scope
• Forgetting to import a module

At runtime, when a method is called or a field is accessed on a null reference.

// Java
String name = null;
System.out.println(name.length());
  // NullPointerException: Cannot invoke "String.length()" because "name" is null

// The equivalent in JavaScript is a TypeError:
const user = null;
user.getName();  // TypeError: Cannot read properties of null

• A method returns null in an edge case you didn't handle
• Optional value not checked before use
• Object not initialised before use
• Database query returned no result and the null was not handled

At runtime, when accessing `array[i]` where `i` is negative or ≥ the array length.

// Java
List<String> items = List.of("a", "b", "c");
items.get(5);
  // IndexOutOfBoundsException: Index 5 out of bounds for length 3

// Python equivalent
items = ["a", "b", "c"]
items[5]
  // IndexError: list index out of range

• Off-by-one error (`i <= length` instead of `i < length`)
• Accessing `items[items.size()]` instead of `items[items.size() - 1]`
• Loop boundary not matching the collection size
• Empty array not handled before access

At runtime, when the maximum call stack depth is exceeded.

// JavaScript
function countDown(n) {
  return countDown(n - 1);  // no base case!
}
countDown(100000);
  // RangeError: Maximum call stack size exceeded

// Java equivalent in recursive code
// java.lang.StackOverflowError

• Recursive function with no base case (or an incorrect one)
• Mutual recursion: A calls B, B calls A, infinitely
• Extremely deep (but valid) recursion exceeding language limits

At runtime, when allocation fails — typically during intensive data processing or due to a memory leak.

// Java
// java.lang.OutOfMemoryError: Java heap space
List<byte[]> list = new ArrayList<>();
while (true) {
    list.add(new byte[1024 * 1024]);  // allocate 1MB forever
}

// Node.js
// FATAL ERROR: Reached heap limit — Allocation failed

• Memory leak: objects accumulate and are never garbage-collected
• Loading an enormous file or dataset into memory all at once
• Creating too many objects in a tight loop without releasing them
• Cache with no eviction policy growing unboundedly

At runtime. Mostly a Python term — other languages raise more specific exception types.

# Python
import sys
if sys.getrecursionlimit() == 0:
    raise RuntimeError("recursion limit is 0")

# Also raised when a generator is already closed:
def gen():
    yield 1
g = gen()
next(g)
g.close()
next(g)  # RuntimeError: generator already executing

• Logic condition detected as invalid state
• Using a resource after it has been closed
• Version mismatch between packages
• Reaching code that should be unreachable

During network calls, database queries, or any timed operation that takes too long.

// fetch with AbortController timeout
const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), 5000);

fetch('/api/data', { signal: controller.signal })
  .catch(err => {
    if (err.name === 'AbortError') {
      console.error('Request timed out after 5s');
    }
  });

// Python requests
requests.get('https://example.com', timeout=5)
  # requests.exceptions.Timeout

• Slow database query with no index on a large table
• Downstream service is overloaded or unreachable
• Network latency spike (especially cross-region)
• Deadlock in the database waiting for a lock to release

When your application tries to open a TCP connection to a host:port where nothing is running or accepting connections.

# Python
import socket
s = socket.create_connection(('localhost', 5432))
  # ConnectionRefusedError: [Errno 111] Connection refused

# Common Docker scenario:
# Your app container starts before the DB container is ready
# ERROR: connect ECONNREFUSED 127.0.0.1:5432

• The target service has not started yet (common in Docker Compose startup ordering)
• Typo in the host or port in your config
• Firewall blocking the port
• The service crashed and is not running

When trying to read, write, or execute a file/resource that the operating system has restricted.

# Linux / macOS
open('/etc/shadow', 'r')
  # PermissionError: [Errno 13] Permission denied: '/etc/shadow'

# Writing to a read-only file
open('/usr/local/bin/app', 'w')
  # [Errno 13] Permission denied

# Common in Docker: running as root vs. non-root user
# EACCES: permission denied '/app/data/output.json'

• File owned by root, but app runs as an unprivileged user
• Incorrect file permissions (`chmod 600` instead of `chmod 644`)
• Running in a container without the right user/volume permissions
• Missing IAM role or policy (cloud storage, AWS S3 etc.)

At runtime — no exception is thrown. Only caught by tests, incorrect output, or user reports.

// Calculating average — wrong result, no crash
function average(numbers) {
  let sum = 0;
  for (let i = 0; i <= numbers.length; i++) {  // bug: <= instead of <
    sum += numbers[i];
  }
  return sum / numbers.length;
}
// NaN returned because numbers[numbers.length] is undefined

• Off-by-one error in a loop boundary
• Wrong formula (e.g., dividing before multiplying, wrong operator)
• Incorrect conditional (`>=` instead of `>`, `&&` instead of `||`)
• Mutating shared state unexpectedly

At runtime, typically in Python, when a function receives an argument of the correct type but a nonsensical value.

# Python
int("not a number")
  # ValueError: invalid literal for int() with base 10: 'not a number'

list1, list2 = [1, 2, 3]
  # ValueError: too many values to unpack (expected 2)

• Passing an unparsable string to int()/float()
• Unpacking a sequence into the wrong number of variables
• A value falling outside an expected range or set of choices
• Malformed input reaching a function that assumes it is already validated

At runtime, when indexing a dict (or similar mapping) with a key that was never set.

# Python
config = {"host": "localhost"}
config["port"]
  # KeyError: 'port'

# Safer alternative
config.get("port", 8080)  # returns 8080 instead of raising

• Typo in a key name
• Assuming an optional config/JSON field is always present
• Reading a key before it has been set
• API response schema changed and a field was removed

At runtime, when Python looks up a name on an object and cannot find it defined.

# Python
class User:
    def __init__(self, name):
        self.name = name

u = User("Alice")
print(u.email)
  # AttributeError: 'User' object has no attribute 'email'

None.upper()
  # AttributeError: 'NoneType' object has no attribute 'upper'

• Typo in an attribute or method name
• Calling a method on None (a function returned nothing where a value was expected)
• Using an attribute added in a newer version of a library you have an older version of
• Confusing an instance with its class (calling an instance method on the class itself)

At runtime, the instant a division or modulo operation has a zero denominator.

# Python
average = total / count
  # ZeroDivisionError: division by zero  (when count == 0)

// JavaScript does NOT throw — it returns Infinity or NaN
console.log(5 / 0);    // Infinity
console.log(0 / 0);    // NaN

• Computing an average over an empty collection
• A denominator derived from user input or a query result that can legitimately be zero
• Percentage calculations when the total is zero
• Rate calculations (e.g. requests per second) with a zero time delta

At runtime, whenever an assert statement (or a test framework's assertion) is evaluated and fails.

# Python
def process(items):
    assert len(items) > 0, "items must not be empty"
    return items[0]

process([])
  # AssertionError: items must not be empty

// JavaScript (Node assert module)
assert.strictEqual(2 + 2, 5);
  // AssertionError [ERR_ASSERTION]: 2 + 2 !== 5

• A precondition the function assumed was never actually guaranteed by its callers
• A test expectation not matching actual output
• Defensive assertions catching a bug earlier than it would otherwise surface
• Assertions left enabled in production accidentally raising on edge cases

At runtime, in low-level languages (C, C++, Rust unsafe blocks) when memory is accessed incorrectly.

// C
int *ptr = NULL;
*ptr = 42;
  // Segmentation fault (core dumped)

char buf[10];
buf[100] = 'x';  // out-of-bounds write — undefined behaviour, may segfault

• Dereferencing a null or invalid pointer
• Writing past the end of an array/buffer (buffer overflow)
• Using memory after it has been freed (use-after-free)
• Stack corruption from a very deep or runaway recursion

At runtime, under concurrent execution, usually when locks are acquired in inconsistent order across threads.

// Pseudocode: classic deadlock
// Thread A:                    // Thread B:
lock(mutexX);                   lock(mutexY);
lock(mutexY);  // waits for B   lock(mutexX);  // waits for A
// Neither thread can ever acquire its second lock — frozen forever

• Acquiring multiple locks in a different order in different threads
• A thread holding a lock while waiting on I/O or another lock indefinitely
• Circular wait between database transactions holding row/table locks
• Nested locking without a consistent global lock ordering

In browser JavaScript, when a fetch/XHR request targets a different origin (domain, port, or protocol) than the page itself.

// Browser console
fetch('https://api.other-site.com/data')
  .catch(err => console.error(err));
// Access to fetch at 'https://api.other-site.com/data' from origin
// 'https://myapp.com' has been blocked by CORS policy: No
// 'Access-Control-Allow-Origin' header is present on the requested resource.

• The API server does not send Access-Control-Allow-Origin for your origin
• A preflight OPTIONS request is not handled correctly by the server
• Credentials (cookies) sent cross-origin without Access-Control-Allow-Credentials
• Calling an API directly from the browser that was only designed for server-to-server use