Functions: Naming Your Logic

From Bee: If your function appears to do nothing, you forgot return. Print the function call's result and you'll see undefined.

What Is a Function?

A function is a named, reusable block of code. You define it once with a name and a list of parameters; you call it many times, passing in different arguments; it does some work and optionally returns a value.

Functions are the lever that makes complex programs possible. A 1000-line program with 50 well-named functions reads like a story; the same program with no functions is unreadable.

Parameters and Arguments

Parameters are the names listed when a function is defined; arguments are the actual values passed in when you call it. Loose usage often blurs the two — most people use them interchangeably.

Return Values

Most functions return a value. Some don't — they just have a side effect like printing. Forgetting return is one of the most common beginner bugs: the function appears to work, but anything that asked for its result gets undefined / None.

Scope

Variables declared inside a function aren't visible outside it. The function gets its own little world. This is intentional — it's why you can have i inside two different functions without them colliding.

Call-Stack Visualizer

Functions stack up as they're called and pop off as they return. Step through to see how it works — including recursion.

Code Examples in Three Languages

// Definition
function greet(name) {
  return `Hello, ${name}!`;
}

// Call
console.log(greet("Aisha"));   // Hello, Aisha!

// Arrow function (modern)
const add = (a, b) => a + b;

// Default parameter
function multiply(a, b = 2) {
  return a * b;
}
multiply(5);   // 10  (b defaulted to 2)

def greet(name):
    return f"Hello, {name}!"

print(greet("Aisha"))

# Default parameter
def multiply(a, b=2):
    return a * b

multiply(5)        # 10
multiply(5, 3)     # 15

# Keyword arguments
def intro(name, age):
    return f"{name}, {age}"
intro(age=30, name="Aisha")

public static String greet(String name) {
    return "Hello, " + name + "!";
}

System.out.println(greet("Aisha"));

// Java requires types and a class context.
// Methods inside classes work the same way.
public static int add(int a, int b) {
    return a + b;
}

Best Practices

1. Give functions clear, verb-based names: calculateTotal, not doStuff.
2. Keep functions small — under 30 lines is a healthy ceiling.
3. Each function should do one thing.
4. Prefer pure functions: same input → same output, no side effects.

Common Mistakes

• Forgetting return. Function appears to work; callers get nothing.
• Long parameter lists. More than ~3-4 parameters? Pass an object instead.
• Side effects nobody expected. A function called getUser shouldn't modify the database.
• Mixing input and output. Reading from disk inside a calculation function makes it hard to test.

How It Works Under the Hood

When a function is called, the runtime creates a stack frame: a chunk of memory holding the parameters, local variables, and a return address. The frame is pushed onto the call stack. When the function returns, the frame is popped — and the caller resumes at the saved return address.

This is why recursion has a depth limit: each call adds a frame; too many and you overflow the stack. Most environments allow a few thousand frames before crashing. Some languages optimize tail calls to avoid growing the stack; JavaScript engines mostly don't.

JavaScript closures work because each function captures a reference to the variables in its enclosing scope. The closure keeps those variables alive even after the outer function returns. This is the foundation of every callback, every event handler, every "currying" trick.

From Beginner to Pro

The same concept gets deeper as you grow. Here's what mastery looks like at three levels:

Performance & Gotchas

• Forgetting return — silent undefined / None.
• Mutable default arguments in Python — shared across calls.
• Arrow functions and this — arrow doesn't bind its own this.
• Recursion without a base case — stack overflow.

Quick Quiz

Real-World Uses (Production Code, Today)

Frequently Asked Questions

Related Concepts