How Humans Think

A Computational Introduction to the Mind

Before you learn to code, learn how you think

📋 Overview

You are a computational system. Your brain processes information, stores memories, runs procedures, and manages limited resources.

Computers were modeled after humans—not the other way around.

This course teaches you to see your own mind as an information-processing system, which makes learning programming feel like learning a formalized language for something you already do: think.

By understanding:

• How working memory functions (and its limits)
• How long-term memory stores and retrieves information
• How chunking allows complex thoughts
• How metacognition creates better thinkers
• How mental models shape what we understand

You'll grasp why code looks the way it does, why certain patterns exist, and why some problems feel "easy" while others feel impossible.

What You'll Learn:

• Cognition as an information system
• Working vs. long-term memory
• Chunking and abstraction in thought
• Metacognitive loops (plan → do → check → reflect)
• Why computers mirror human cognition

🎯 Key Outcomes

By the end of this course, you will:

• Understand your own thinking as a computational process with measurable limits and patterns
• See why programming exists as a formalization of human problem-solving
• Recognize cognitive load in yourself and in the systems you build
• Apply metacognition to become a more effective learner and builder
• Think about thinking in a way that makes learning any technical skill easier

🗺️ Course Curriculum

Below is the complete lesson structure. Each lesson includes video content, interactive scenarios, flashcards, quizzes, and reflection questions.

🔗 Connections

Leads To

• EC101 - Programming as Thinking - Apply these concepts to writing code
• EC103 - State Memory Process - Deep dive into memory systems
• EC201 - Algorithms - Mental procedures formalized

Related Tutorials

• [Coming Soon]

Used In Hackathon Lab

• Week 001 Kickoff - Understanding user mental models
• Every week uses EC000 for user empathy and design thinking

💡 Key Concepts

Concept 1: Working Memory as Cognitive RAM

Your working memory can hold ~7±2 "chunks" of information at once. This is why:

• Phone numbers are 7-10 digits
• Code should be broken into small functions
• Complex problems feel overwhelming without notes

In Software: Variables, function scopes, and stack frames mirror this limitation.

Concept 2: Chunking as Abstraction

Experts don't think in smaller pieces—they think in bigger chunks.

A beginner sees: f, o, r, (, i, =, 0, ...

An expert sees: "for loop iterating over a range"

In Software: Functions, classes, and modules are chunking mechanisms.

Concept 3: Metacognition as Debugging

The best learners constantly ask:

• "What am I trying to do?"
• "Is this working?"
• "What would I do differently next time?"

In Software: This becomes: planning, testing, refactoring, retrospectives.

Concept 4: Mental Models Shape Understanding

You can only understand new information through the lens of what you already know.

If your mental model of "computer" is "a magic box," you'll struggle with programming.

If your mental model is "a system that follows precise instructions," everything clicks.

In Software: APIs, documentation, and interfaces all try to match developers' mental models.

Concept 5: Cognitive Load Management

Your brain has limited processing power. Managing cognitive load means:

• Breaking problems into smaller pieces
• Externalizing memory (notes, diagrams)
• Automating repetitive tasks
• Building systems that respect human limits

In Software: This is why we have linters, formatters, autocomplete, and good UX design.

🛠️ Practical Applications

1. Learning Any Skill: Use metacognitive loops to learn faster
2. Problem Solving: Break problems into working-memory-sized chunks
3. Communication: Understand how others process information
4. System Design: Build software that respects cognitive limits
5. Debugging: Think like a debugger about your own thinking

📖 Resources

• Reading: "Thinking, Fast and Slow" by Daniel Kahneman
• Reading: "The Debugger's Mindset" (article)
• Practice: Keep a thinking journal for one week
• Community: community for discussion

🚀 Ready to Begin?

Difficulty: ⭐☆☆☆☆ Beginner
Time Commitment: ~6 hours
Prerequisites: None - start here!
Next Course: EC101 - Programming as Thinking