Skip to main content

Why Functions, Methods, and Procedures Are the Same Thing

In programming, we love making distinctions. Some of them are useful, others—well, let’s just say they feel like baggage from a time when programming paradigms were trying to set up rigid borders between ideas that are functionally identical.

Take the terms function, method, and procedure. Traditionally, these are distinguished as follows:

  • Function: A reusable block of logic that takes arguments and returns a value.
  • Method: A function tied to an object/class.
  • Procedure: A function that doesn’t return a value (or, in database contexts, a stored procedure that executes some logic in the database layer).

But when you strip away the tradition, what do you really have? A reusable piece of logic that may take arguments and may return values. That’s it. Everything else is implementation details and convention.

Methods Are Just Functions With an Extra Label​

One of the most common arguments is that methods are fundamentally different because they belong to objects or classes. But that’s not a real distinction—because in JavaScript, I can take a function and assign it as a property of an object. Now it’s a method:

const obj = {
    value: 42,
    getValue: function() {
        return this.value;
    }
};

That’s a method, right? But at its core, it’s still just a function. The same function could exist outside the object, or be reassigned to another object, and it would still work. The fact that some languages force methods to exist inside classes is a language rule, not a fundamental distinction.

Pure Functions? Sure. But That’s Just a Convention​

Another supposed distinction is that pure functions don’t modify external state, whereas methods often do. But a function can modify external state, just like a method can be pure.

def pure_function(x):
    return x * 2  # Doesn't modify anything

class Example:
    def method(self, x):
        return x * 2  # Also pure

The only difference here is that one is inside a class. That’s not a meaningful distinction—both are just functions that return values.

Procedures Are Just Functions Without a Return Value​

If a procedure is just a function that doesn’t return anything, then it’s still the same core concept. Every function that doesn’t explicitly return a value is effectively a procedure:

void doSomething() {
    printf("Hello");
}

Sure, some people associate procedures with database stored procedures, but those are still just logic blocks that accept parameters and return results. Some might not return data, but they still execute logic like any other function.

The Conclusion: It’s All the Same​

The more you look at it, the clearer it becomes: function, method, and procedure are just different names for the same concept. They all:

  • Encapsulate logic
  • May take arguments/parameters
  • May return values

The differences come down to implementation details imposed by specific languages, not a fundamental divide. So while I can be pedantic about some things, this isn’t one of them—I don’t care what you call it, as long as it works.

Just write the logic and move on.

What About the Compiler?​

From a compiler’s perspective, it’s likely that functions, methods, and procedures are treated similarly when it comes to optimization.

Dead Code Elimination: If a function, method, or procedure isn’t used, it’s removed—regardless of its label.

Function Inlining: A method on a class can be inlined just like a standalone function, provided it meets the compiler’s criteria for optimization.

Static Single Assignment (SSA): This may introduce differences based on scoping rules, particularly in compilers with aggressive optimization.

While the semantics may vary slightly between languages, at the machine level, these distinctions often blur into a general concept of callable logic... that said, I've never actually worked on a compiler, so please enlighten me if I'm missing something here.