Why the human brain prefers Procedural and Functional Paradigms

The whole point of a programming language is to do something.

I’m a big critic of Object-oriented programming paradigm, despite thinking in Java well due to extended exposure in college. But this shouldn’t be an excuse to push an unintuitive way of converting thoughts into software. I learned Java, C++, and JavaScript back when they were exclusively taught in OO fashion or lacked Functional paradigm features, and only learned Python later. Python has accomplished its integration of Functional programming in a fairly reasonable way, but it did this most ostensibly through the addition and aggressive promotion of List-comprehensions, which are not human-readable, which contradicts Python design tenets. C++ has added first-class functions, but I have not used them. JavaScript redesigned its language and added Functional programming in a reasonable way, however it is still noisy and generates visual collisions with object-oriented syntax, like using the . operator in the .then() method. As far as language syntaxes go, the most systematic one is still Lisp with its many parentheses. Lisp was always dunked on by other people when I was in college, calling it “Lost In Stupid Parentheses”, but what many people failed to realize is that the parentheses are a help, not a hindrance. They help with mentally modeling the execution branches in a program. This allows you to trace bugs more easily than with other languages. Lisp also tucks away alot of the noise and repetitive obvious things that a computer needs to do; for example, returning data from a function in Lisp is implied:

(defun add-one (n)
  (format t "Adding...~%")
  (+ n 1)
)

(defun add-one (n)
  (format t "Adding...~%")
  (+ n 1)
)

The code above defines a function in Common Lisp named add-one that accepts a number n, prints “Adding…” + a newline character (denoted by ~%) to standard output (t), and then adds n + 1 in Polish Notation (+ n 1) and returns the result of that function.

(add-one 5) ;; returns 6

(add-one 5) ;; returns 6

The implied return helps your brain focus on what matters most: data and execution flow, rather than on explicitly telling the computer what it needs to do to accomplish the task. If I had to guess, I’d say most programmers started programming because they wanted to offload some level of repetitive task to the computer, only to have that annoyance replaced with the annoyance of repetitively and obsessively checking whether they told the computer to do the logical thing it should know to do.

Similarly with Procedural Paradigm, users are more in tune with the computer, because, with automatic memory management, you at least don’t have to worry about keeping track of what memory addresses you allocated memory to, how much memory, and when to get rid of it. You can focus on a step-by-step set of math-like instructions. A simple system of variables and function calls, but not as powerful as being able to refer to functions as though they themselves were variables (first-class functions).

OO is simple on the surface, but it’s also extremely explicit, like hooking up wires in a giant telephone operator room, obscuring the inner function of the connected objects, and making it difficult to debug, if one object isn’t playing nicely.

Java also tends to confuse people with its class model, which separates the act of defining a Class from the act of using that Class. Classically, programmers use the language to make something, then modify that something. The idea of immutable Type is typically relegated to primitive types like Int, Float, String. An object, however, like in real life, is something you want to modify and customize as you’re using it, which is why JavaScript comes across as more intuitive to beginners. Interestingly, the evolution of JavaScript to include and promote the Functional paradigm made it less relatable to beginners.

With that said, what might be the issue with OO, from a cognitive point of view? I had AI generate a more complete argument based on some intuition I had back in 2020 when I was watching a lot of Dr. Jordan B. Peterson psychology college lectures. Dr. Peterson mentioned the prefrontal cortex evolved out of the motor cortex. His argument was that

“Thought is abstracted action.”

Jordan Peterson ~ Your Brain Is More Complex Than What You Think

The evolutionary progression he describes is:

1. Initial development of the motor strip (or motor cortex), which enables voluntary movements and sequences of activity.
2. As this area grew, the prefrontal cortex emerged from the motor cortex, effectively divorcing potential actions from the body and allowing for their abstract representation.
3. This abstraction capability allows humans to simulate potential motor movements and their consequences in an abstract space before implementing them in actual behavior.

This simulation function is key to higher cognitive abilities such as planning, complex social behavior, and problem-solving, enabling humans to test hypothetical actions without real-world consequences.

The prefrontal cortex allows for top-down control over lower-order drives and impulses, which originates from subcortical structures like the hypothalamus. This control is necessary for aligning behavior with long-term objectives and a cohesive personality structure, rather than being stimulus-bound.

As Dr. Joe Armstrong put it,

Objects bind functions and data structures together in indivisible units. I think this is a fundamental error since functions and data structures belong in totally different worlds. Why is this?

*Functions do things. They have inputs and outputs. The inputs and outputs are data structures, which get changed by the functions. In most languages functions are built from sequences of imperatives: “Do this and then that …” to understand functions you have to understand the order in which things get done (In lazy FPLs and logical languages this restriction is relaxed).

• Data structures just are. They don’t do anything. They are intrinsically declarative. “Understanding” a data structure is a lot easier than “understanding” a function.

Functions are understood as black boxes that transform inputs to outputs. If I understand the input and the output then I have understood the function. This does not mean to say that I could have written the function.

Functions are usually “understood” by observing that they are the things in a computational system whose job is to transfer data structures of type T1 into data structure of type T2.

Since functions and data structures are completely different types of animal it is fundamentally incorrect to lock them up in the same cage.

Why OO Sucks by Joe Armstrong

Human Brain Evolution

The human prefrontal cortex (PFC) is generally considered to have evolved from the granular frontal cortex areas present in the last common ancestor of primates. More specifically, the most significant expansion and differentiation occurred within the isocortical, granular PFC, which is the part that dominates the human frontal lobe.

A key evolutionary development in primates, especially humans, was the accretion and increased granularity of the PFC along a roughly posterior-to-anterior trajectory. This expansion is most pronounced in the anterior part of the PFC, particularly the frontopolar cortex (Area 10), which is relatively larger in humans than in other great apes. This human-specific expansion is associated with enhanced cognitive functions, including:

• Increased working memory capacity.
• Greater ability to link discontinuous or distant data.
• Higher capacity for abstraction, planning, and problem-solving.

Impact on Object Organization Preference

The evolutionary development of the PFC, particularly its role in abstraction, planning, and integrating information for goal-directed behavior and cognitive control, strongly impacts the human preference for functional organization of objects over categorical organization, especially for non-living objects.

Prefrontal Cortex and Functional Organization

The PFC is essential for establishing and maintaining “rules of the game,” which involves synthesizing sensory input into representations of learned task contingencies, concepts, and abstract rules.

• Goal-Directed Behavior: Functional organization involves grouping objects based on their use or role in an action sequence (e.g., grouping a knife, cutting board, and vegetables because they function together to prepare a meal). The PFC’s specialization in planning and executive function naturally favors this organization because it is critical for constructing and executing complex, multi-step behaviors directed toward a goal.
• Abstract Representation: The ability of the PFC to encode more abstract, relational, and contextual information (rather than just specific features, which are often processed in posterior cortical areas) supports the abstraction necessary for functional grouping. Function is an abstract relationship, not a sensory category.

Functional vs. Categorical Organization

Research suggests a link between the type of object and the preferred organizational scheme:

• Living Objects: Representations often rely more on visual/sensory properties (e.g., shape, color), supporting categorical grouping (e.g., all animals).
• Non-Living Objects (Artifacts): Representations tend to rely more on functional properties (how they are used or what they do), supporting functional grouping (e.g., all tools).

The expansion of the granular PFC provided the neural substrate for the enhanced cognitive control and the integration of diverse information into abstract, action-oriented representations, making the functional significance of an object a more salient and powerful organizing principle for human thought, especially for the artifacts central to human tool-use and technology.

The prefrontal cortex (PFC) evolution, which favors abstraction, planning, and goal-directed functional organization, would generally enhance a programmer’s preference for functional (FP) and procedural paradigms when compared to the strict categorical organization sometimes emphasized in Object-Oriented Programming (OOP).

PFC Influence on Programming Paradigm Preference

The functional specializations of the granular PFC align directly with the core tenets of functional and procedural styles:

Functional and Procedural Paradigms

These paradigms center on process and transformation, directly mapping to the PFC’s role in planning and goal-directed sequencing:

1. Functional Organization and Data Flow:
   • The PFC’s enhanced capacity for synthesizing task contingencies and abstract rules (the “rules of the game”) favors thinking about a program as a series of abstract, self-contained transformations (functions) applied to data.
   • Functional Programming focuses on what to do with data, emphasizing pure functions and data immutability. This aligns with the PFC’s need for a clear, predictable flow to execute a plan or goal without unexpected external state changes.
2. Procedural Planning and Execution:
   • Procedural Programming focuses on the sequence of steps (procedures) to achieve a result. This directly leverages the PFC’s fundamental role in planning, sequencing, and cognitive control—breaking a large goal into ordered, manageable sub-goals.

Object-Oriented Programming (OOP)

While OOP uses functions (methods) and sequences, its core organizing principle—the Class—is fundamentally categorical:

1. Categorical Organization (Classes):
   • OOP’s primary structure often starts with defining objects based on the real-world or conceptual category they belong to (e.g., a Car class, a Dog class). This relies on an initial categorical grouping of data (attributes) and methods (functions) into an encapsulated entity.
   • Although a class is also defined by its behavior (functionality), the initial cognitive load is often on categorization and hierarchical structure (inheritance, class relationships). The human preference, stemming from PFC development, shifts away from simple categorical organization (like grouping a knife and fork as “utensils”) toward functional organization (like grouping a knife, cutting board, and ingredients as “meal preparation tools”).
2. Reduced Functional Focus:
   • When the cognitive bias is toward functional groupings (what things do together for a goal), the requirement to rigidly group functions based on the data structure (the object/class) can become a secondary constraint, or even a cognitive barrier, to the goal-directed, procedural thought process.

Therefore, the evolutionary bias for abstraction-for-action (functional/procedural logic) over simple abstraction-for-classification (categorical/OOP logic) can manifest as a preference for paradigms that prioritize the sequence of transformation and functional purity as the primary organizational tool.