Coding Voyage: From Mind to Code

Copyright Page

1. Joint Authorship
2. Copyright Declaration
3. Permitted Uses

Introduction: What This Book Will Make Clear

1. What This Book Is Not
2. What This Book Is
3. What We Will Cover
4. How to Read This Book
5. The Authors’ Perspective
6. A Note on Language
7. A Note on AI and Learning
8. What You Will Become
9. If You Cannot Afford This Book

Author Interview: Meet the Three Voices Behind This Book

A Small Theater: The First Meeting

Chapter 1: How Does a Computer Actually Work?

1. 1.1 The Skeleton: CPU, Memory, Storage, Motherboard
2. 1.2 L’s “Terminology Breakdown Corner”
3. 1.3 Hands-On: Look at Your Own Computer

1.1 Information Literacy: What Did You Actually Learn?

1. The Three-Sentence Rule
2. The “Why Should I Care?” Section
3. Quick Quiz: Can You Pass the “Grandma Test”?
4. A Real Problem: Can You Spot the Mistake?
5. One More: The “Price” Question
6. The Takeaway: What You Should Remember from This Chapter
7. Onward to Chapter 2

1.2 The Value Cube: How to Learn Anything (Including Code)

1. The Psychologist’s Question
2. What This Means for Learning Code
3. The Grandma Test (Revisited)
4. The “Why Do I Need to Know This?” Moment
5. A Real Example: Learning Pointers
6. The “Second Brain” Method
7. The One Question to Ask Yourself
8. Practice: Five Exercises to Train Your Learning Method
9. Onward to Chapter 2

Chapter 2: First Contact — The C Language

1. 2.1 Why C? A Brief History
2. 2.2 Where Does C Fit in the Language Family?
3. 2.3 Your First C Program
4. 2.4 Line-by-Line Breakdown
5. 2.5 Variables: Putting Things in Memory
6. 2.6 Printing Variables: printf with Placeholders
7. 2.7 Getting Input: scanf
8. 2.8 Doing Something: A Simple Calculation
9. 2.8.1 Break It on Purpose
10. 2.9 What You’ve Learned in This Chapter
11. 2.10 Practice: You Build Something
12. 2.11 T’s Information Literacy Summary
13. 2.12 Value Cube: Understanding C — Its History, Power, and Limits

Chapter 3: Variables, Memory, and Writing Safe Code

1. 3.1 Memory Is Just a Big List of Numbers
2. 3.2 Every Variable Has Three Properties
3. 3.3 How Much Memory Does Each Type Use?
4. 3.4 Memory Layout: How Variables Are Arranged
5. 3.5 The Stack: Where Local Variables Live
6. 3.6 What Are Reserved Words (Keywords)?
7. 3.7 What Are Header Files?
8. 3.8 Creating Your Own Header File
9. 3.9 <> vs ““ — What’s the Difference?
10. 3.10 Naming Conventions: How to Write Readable Code
11. 3.11 Memory Safety: How Variables Affect Security
12. 3.12 The Golden Rules of Safe Variable Usage
13. L’s Quick Interruption
14. Practice: Explore Your Own Memory
15. T’s Information Literacy Summary
16. Chapter 3 Checklist
17. 3.12 T’s Information Literacy Summary
18. 3.13 Value Cube: The Story of Variables — From Math to Memory to Security

Chapter 4: Pointers — The Address of Everything (Expanded Edition)

1. Part 1: What Are Variables, Pointers, and Functions?
2. Part 2: Why Do We Need Pointers?
3. Part 3: The Two Operators You Must Know
4. Part 4: Declaring and Using Pointers
5. Part 5: Pointers and Functions — Passing by Reference
6. Part 6: Swapping Two Numbers
7. Part 7: Pointers and Arrays
8. Part 8: Pointers to Different Types
9. Part 9: NULL Pointers
10. Part 10: Common Mistakes with Pointers
11. Part 11: Pointers in Real-World Scenarios
12. Part 12: L’s Quick Interruption
13. Practice: Write Your Own Pointer Programs
14. T’s Information Literacy Summary
15. Chapter 4 Checklist

4.1 Information Literacy: What Did You Actually Learn?

1. Core Concepts in One Sentence Each
2. Small Experiments to Try
3. So Why Should You Care?
4. Common Mistakes and How to Avoid Them
5. Quick Check: Can You Answer These?
6. The Big Picture: How This Chapter Connects to Everything Else
7. Checklist
8. Onward

Chapter 4: Pointers — The Address of Everything

1. Chapter Introduction
2. Prologue: The Sticky Note with the Room Number
3. 4.1 Three Core Concepts
4. 4.2 Why Do We Need Pointers?
5. 4.3 The Two Operators: & and *
6. 4.4 Declaration, Assignment, Reading, and Modifying via Pointer
7. 4.5 Pointers and Functions: Why C Is “Pass-by-Value”
8. 4.6 Classic Example: Swapping Two Numbers with Pointers
9. 4.7 Pointers and Arrays
10. 4.8 Pointers to Different Types
11. 4.9 NULL: A Sticky Note That Says “No Address”
12. 4.10 The Five Most Common Pointer Mistakes
13. 4.11 Pointers in Real-World Scenarios
14. 4.12 Quick Reference Table
15. Chapter Checklist
16. Practice Exercises
17. 5.2 Value Cube: The Warehouse That Kept Growing

Chapter 5: The Warehouse That Grows — Dynamic Memory Allocation

1. 5.1 The Stack vs The Heap
2. 5.2 malloc — Allocating Memory on the Heap
3. 5.3 Using Allocated Memory
4. 5.4 free — Returning Memory to the System
5. 5.5 Allocating Memory for Arrays
6. 5.6 calloc — Allocate and Zero
7. 5.7 realloc — Resizing Memory
8. 5.8 Common Dynamic Memory Mistakes
9. 5.9 Real-World Scenario: Reading Unknown Input
10. 5.10 L’s Quick Interruption
11. Practice: Dynamic Memory Exercises
12. 5.11 T’s Information Literacy Summary
13. 5.1 Information Literacy: What Did You Actually Learn?
14. Core Concepts in One Sentence Each
15. Small Experiments to Try
16. What Happens When You Forget to Free?
17. Quick Check: Can You Answer These?
18. Before You Move On
19. Chapter 6: The Sentence That Wasn’t a Sentence

Chapter 6: Strings in C — The Sentence That Wasn’t a Sentence

1. 6.1 What Is a String in C?
2. 6.2 Declaring Strings
3. 6.3 The ‘\0’ Invisible Dot
4. 6.4 String Length: strlen
5. 6.5 Copying Strings: strcpy and strncpy
6. 6.6 Concatenating Strings: strcat and strncat
7. 6.7 Comparing Strings: strcmp and strncmp
8. 6.8 Reading Strings from the User
9. 6.9 Arrays of Strings
10. 6.10 Finding Characters in Strings: strchr and strrchr
11. 6.11 Finding Substrings: strstr
12. 6.12 Common String Mistakes (Detailed)
13. 6.13 Real-World Scenario: Processing User Input
14. 6.14 Putting It All Together: A String Reversal Program
15. L’s Quick Interruption
16. Practice: String Exercises
17. 6.1 Information Literacy: What Did You Actually Learn?
18. Core Concepts in One Sentence Each
19. Small Experiments to Try
20. What Happens When You Forget the '\0'?
21. Quick Check: Can You Answer These?
22. Before You Move On
23. Chapter 7: The Box That Wanted to Hold More

Chapter 7: The Box That Wanted to Hold More — Structures in C

1. 7.1 What Is a Structure?
2. 7.2 Declaring and Using Structures
3. 7.3 Initializing Structures
4. 7.4 Copying Structures
5. 7.5 Arrays of Structures
6. 7.6 Pointers to Structures
7. 7.7 Passing Structures to Functions
8. 7.8 Nested Structures
9. 7.9 typedef — Creating Type Aliases
10. 7.10 Self-Referential Structures
11. 7.11 Common Structure Mistakes
12. 7.12 Real-World Scenario: Student Database
13. 7.13 L’s Quick Interruption
14. Practice: Structure Exercises
15. 7.1 Information Literacy: What Did You Actually Learn?
16. Core Concepts in One Sentence Each
17. Small Experiments to Try
18. What Happens When You Pass a Large Structure by Value?
19. Quick Check: Can You Answer These?
20. Before You Move On
21. Chapter 8: The Notebook That Never Lost a Page
22. 8.1 What Is a File?
23. 8.2 Opening and Closing Files
24. 8.3 Writing to a Text File
25. 8.4 Reading from a Text File
26. 8.5 Appending to a File
27. 8.6 Reading and Writing Binary Files
28. 8.7 Checking for Errors
29. 8.8 Common File Mistakes
30. 8.9 Real-World Scenario: Student Database with Files
31. 8.10 L’s Quick Interruption
32. Practice: File Exercises
33. 8.11 Information Literacy: What Did You Actually Learn?

Chapter 8: The Notebook That Never Lost a Page — File I/O in C

1. 8.1 What Is a File?
2. 8.2 Opening a File: fopen
3. 8.3 Closing a File: fclose
4. 8.4 Writing to a Text File: fprintf
5. 8.5 Reading from a Text File: fscanf
6. 8.6 Reading a Whole Line: fgets
7. 8.7 Writing a Whole Line: fputs
8. 8.8 Reading/Writing Binary Files: fread and fwrite
9. 8.9 File Position: ftell and fseek
10. 8.10 Common File I/O Mistakes
11. 8.11 Putting It All Together: A Simple File Database
12. 8.12 L’s Quick Interruption
13. Practice: File I/O Exercises
14. 8.1 Information Literacy: What Did You Actually Learn?
15. Core Concepts in One Sentence Each
16. Small Experiments to Try
17. What Happens When You Forget to Close a File?
18. What Happens When You Open a File That Doesn’t Exist?
19. Quick Check: Can You Answer These?
20. Before You Move On
21. Chapter 9: The Recipe That Wrote Itself

Chapter 9: The Recipe That Wrote Itself — Preprocessor and Macros

1. 9.1 The Compilation Process
2. 9.2 #include — Copying Files
3. 9.3 #define — Text Substitution
4. 9.4 Why the Parentheses?
5. 9.5 The Dark Side of Macros
6. 9.6 Conditional Compilation: #ifdef, #ifndef, #endif
7. 9.7 Header Guards: The #ifndef Pattern
8. 9.8 Common Macros You Already Use
9. 9.9 Putting It All Together: A Debug System
10. 9.10 L’s Quick Interruption
11. Practice: Preprocessor Exercises
12. 9.1 Information Literacy: What Did You Actually Learn?
13. Core Concepts in One Sentence Each
14. Small Experiments to Try
15. What Happens When You Forget a Header Guard?
16. Quick Check: Can You Answer These?
17. Before You Move On
18. Chapter 10: The Book That Became Too Big

Chapter 10: The Book That Became Too Big — Modular Programming

1. 10.1 Why Split Code Into Multiple Files?
2. 10.2 Header Files (.h) and Source Files (.c)
3. 10.3 The Compilation Process for Multiple Files
4. 10.4 #include — Connecting Files
5. 10.5 Scope: Who Can See What?
6. 10.6 static and extern
7. 10.7 A Real Example: A Calculator Library
8. 10.8 Common Modular Programming Patterns
9. 10.9 Common Mistakes
10. 10.10 L’s Quick Interruption
11. Practice: Modular Programming Exercises
12. 10.1 Information Literacy: What Did You Actually Learn?
13. Core Concepts in One Sentence Each
14. Small Experiments to Try
15. What Happens When You Forget to Add math.c to the Compilation?
16. What Happens When You Include a Header in Another Header?
17. Real-World Tip: Where Do Header Guards Go?
18. What Happens When You Put a Definition in a Header?
19. The Two Types of Linking
20. The Makefile: Automating Compilation
21. Quick Check: Can You Answer These?
22. Before You Move On
23. Chapter 11: The Mirror That Reflected Itself

Chapter 11: The Mirror That Reflected Itself — Recursion and Function Pointers

1. Part 1: Recursion
2. 11.1 What Is Recursion?
3. 11.2 How Recursion Works: The Stack
4. 11.3 Classic Recursion: Factorial
5. 11.4 Classic Recursion: Fibonacci
6. 11.5 Recursion vs Iteration
7. 11.6 Common Recursion Mistakes
8. Part 2: Function Pointers
9. 11.7 What Is a Function Pointer?
10. 11.8 Why Use Function Pointers?
11. 11.9 qsort — The Classic Function Pointer Example
12. 11.10 Function Pointer Syntax
13. 11.11 Putting It All Together: Recursion + Function Pointers
14. 11.12 L’s Quick Interruption
15. Practice: Recursion and Function Pointer Exercises
16. 11.1 Information Literacy: What Did You Actually Learn?
17. Core Concepts in One Sentence Each
18. Small Experiments to Try
19. Recursive vs Iterative: Which One to Choose?
20. What Happens When You Forget the Base Case?
21. Why Is Fibonacci Recursion So Slow?
22. Quick Check: Can You Answer These?
23. Before You Move On
24. Chapter 12: The Room That Became a Study

Chapter 12: The Room That Became a Study — Building a Complete Project

1. 12.1 Before We Write Code: The Project Lifecycle
2. 12.2 Requirements: What Should the Program Do?
3. 12.3 Design: What Are the Modules?
4. 12.4 The Header File: student.h
5. 12.5 The Implementation: student.c
6. 12.6 The Storage Module: storage.h
7. 12.7 The Storage Implementation: storage.c
8. 12.8 The User Interface: main.c
9. 12.9 Compiling the Project
10. 12.10 What You Just Built
11. 12.11 What You Learned from This Project
12. 12.12 L’s Final Thought
13. Practice: Extend the Project
14. 12.1 Information Literacy: The End of One Journey — And the Beginning of Another
15. Before You Move On
16. 12.2 Value Cube: The Engineer’s Mindset
17. Chapter 13: The Packed Suitcase

Chapter 13: The Packed Suitcase — Bitwise Operations and Memory Optimization

1. 13.1 What Is a Bit?
2. 13.2 Binary Number System
3. 13.3 Hexadecimal (Base 16)
4. 13.4 The Bitwise Operators
5. 13.5 Bitwise AND (&)
6. 13.6 Bitwise OR (|)
7. 13.7 Bitwise XOR (^)
8. 13.8 Bitwise NOT (~)
9. 13.9 Left Shift (<<)
10. 13.10 Right Shift (>>)
11. 13.11 Bitmasks: Using Bits as Flags
12. 13.12 Real-World Example: Packing Colors in 32 Bits
13. 13.13 Packing Data: Saving Memory with Bitfields
14. 13.14 Memory Alignment and Padding
15. 13.15 Common Bitwise Use Cases
16. 13.16 L’s Quick Interruption
17. 13.1 Information Literacy: Why Bits Matter — And Where They Show Up
18. Before You Move On
19. 13.2 Value Cube: The Engineer’s Judgment — How to Tell Good Code from Bad Code
20. Chapter 14: The Map That Led to More Maps

Chapter 14: The Map That Led to More Maps — Advanced Pointers

1. 14.1 Pointers to Pointers (Double Pointers)
2. 14.2 Why Do We Need Double Pointers?
3. 14.3 Arrays of Pointers
4. 14.4 Function Pointers — Real-World Use Cases
5. 14.5 Function Pointers as “Maps to Code”
6. 14.6 Complex Pointer Declarations
7. 14.7 Using typedef with Function Pointers
8. 14.8 Common Mistakes with Advanced Pointers
9. 14.9 L’s Quick Interruption
10. Practice: Advanced Pointer Exercises
11. 14.1 Information Literacy: Reading Code Like a Pro
12. Chapter 15: The City of Memory

Chapter 15: The City of Memory — Program Memory Layout

1. 15.1 The Five Memory Regions
2. 15.2 Text (Code) Segment
3. 15.3 Data Segment (Initialized Data)
4. 15.4 BSS Segment (Uninitialized Data)
5. 15.5 The Heap
6. 15.6 The Stack
7. 15.7 Visual Memory Layout (Addresses)
8. 15.8 Stack vs Heap: Detailed Comparison
9. 15.9 Real-World Example: Variable Locations
10. 15.10 Common Memory Errors
11. 15.11 L’s Quick Interruption
12. Practice: Memory Layout Exercises
13. 15.1 Information Literacy: Seeing Memory with Your Own Eyes
14. Chapter 16: The Toolbox That Never Stops Growing

Chapter 16: The Toolbox That Never Stops Growing — Libraries in C

1. 16.1 What Is a Library?
2. 16.2 Why Use Libraries?
3. 16.3 How Static Libraries Work
4. 16.4 Creating a Static Library
5. 16.5 How Dynamic Libraries Work
6. 16.6 Creating a Dynamic Library (Linux/Unix)
7. 16.7 Static vs Dynamic Libraries — When to Use Which
8. 16.8 Using Existing Libraries
9. 16.9 Practical Example: A Simple Math Library
10. 16.10 Library Documentation
11. 16.11 Using Third-Party Libraries
12. 16.12 L’s Quick Interruption
13. Practice: Library Exercises
14. 16.1 Information Literacy: Static vs Dynamic Libraries — A Practical Guide
15. Chapter 17: The Assembly Line

Chapter 17: The Assembly Line — How Your Code Becomes a Program

1. 17.1 The Four Stages of Compilation
2. 17.2 Stage 1: Preprocessing
3. 17.3 Stage 2: Compilation
4. 17.4 Stage 3: Assembly
5. 17.5 Stage 4: Linking
6. 17.6 The C Preprocessor — Deeper Dive
7. 17.7 Conditional Compilation — Advanced Patterns
8. 17.8 The Compiler Flags You Should Know
9. 17.9 Real-World Example: Building a Multi-file Project
10. 17.10 L’s Quick Interruption
11. Practice: Preprocessor and Compilation Exercises
12. Chapter 18: The Detective and The Watchmaker

Chapter 18: The Detective and The Watchmaker — Debugging and Profiling

1. 18.1 What Is Debugging?
2. 18.2 The Simplest Debugging Tool: printf
3. 18.3 GDB — The GNU Debugger
4. 18.4 Common Debugging Techniques
5. 18.5 Valgrind — Finding Memory Bugs
6. 18.6 What Is Profiling?
7. 18.7 Profiling with gprof
8. 18.8 The Optimization Process
9. 18.9 Common Optimization Techniques
10. 18.10 Common Debugging and Profiling Mistakes
11. 18.11 L’s Quick Interruption
12. Practice: Debugging and Profiling Exercises
13. 18.1 Information Literacy: Debugging and Profiling in Practice
14. Chapter 19: The Recipe That Cooked Itself

Chapter 19: The Recipe That Cooked Itself — Makefiles and Build Automation

1. 19.1 What Is a Makefile?
2. 19.2 A Simple Makefile
3. 19.3 Multiple Targets
4. 19.4 Multi-File Projects
5. 19.5 Makefile Variables
6. 19.6 Pattern Rules
7. 19.7 Phony Targets
8. 19.8 A Complete Makefile
9. 19.9 Using the Complete Makefile
10. 19.10 Common Makefile Mistakes
11. 19.11 L’s Quick Interruption
12. Practice: Makefile Exercises
13. 19.1 Information Literacy: Make and Build Tools — A Complete Guide
14. Chapter 20: The Library of Everything

Chapter 20: The Library of Everything — Version Control and Project Management

1. 20.1 What Is Version Control?
2. 20.2 Git — The Most Popular Version Control System
3. 20.3 Getting Started with Git
4. 20.4 A Typical Git Workflow
5. 20.5 Branching
6. 20.6 Merging
7. 20.7 Working with Remote Repositories
8. 20.8 The Four Stages of Git
9. 20.9 Common Git Commands
10. 20.10 The .gitignore File
11. 20.11 Real-World Workflow Example
12. 20.12 Project Management Beyond Git
13. 20.13 L’s Quick Interruption
14. Practice: Git Exercises
15. 20.1 Information Literacy: Version Control — The Backbone of Modern Development
16. Special Issue 1: Windows — The Operating System You Probably Already Use
17. 1.1 What Is Windows?
18. 1.2 Windows Architecture: A Bird’s-Eye View
19. 1.3 Windows and C: A Love Story
20. 1.4 Common Windows Headers and What They’re For
21. 1.5 Building Windows C Programs
22. 1.6 Windows Security: How the OS Protects Itself
23. 1.7 C Language Security: Why C Is Powerful — And Dangerous
24. 1.8 Windows Security Features for Developers
25. 1.9 Common C Errors on Windows and How to Fix Them
26. 1.10 Windows Command-Line Basics Every C Programmer Should Know
27. 1.11 Windows vs Linux: What C Programmers Need to Know
28. 1.12 L’s Final Thought
29. Quick Check: Can You Answer These?
30. Special Issue 2: Linux — The Operating System That Runs the World
31. 1.1 What Is Linux?
32. 1.2 Linux Philosophy: The Unix Way
33. 1.3 Linux Distributions
34. 1.4 Linux and C: A Deep Connection
35. 1.5 The Linux Filesystem Hierarchy
36. 1.6 Linux Command Basics Every C Programmer Should Know
37. 1.7 Compiling C on Linux
38. 1.8 Common Linux C Errors and Fixes
39. 1.9 Debugging on Linux
40. 1.10 Linux vs Windows: C Programmer’s View
41. 1.11 L’s Final Thought
42. Quick Check: Can You Answer These?
43. Special Issue 3: Android — The Operating System That Lives in Your Pocket
44. 1.1 What Is Android?
45. 1.2 Android Architecture: A Layered View
46. 1.3 Android and C: The Native Connection
47. 1.4 The NDK: Writing C for Android Apps
48. 1.5 JNI: Java Native Interface
49. 1.6 Common Android C Headers and Libraries
50. 1.7 Logging in Android C Code
51. 1.8 Android vs Linux: What C Programmers Need to Know
52. 1.9 Common Android C Errors and Fixes
53. 1.10 The APK Structure
54. 1.11 Building Android C Code: CMake
55. 1.12 L’s Final Thought
56. Quick Check: Can You Answer These?
57. Special Issue 4: macOS — The Operating System That Hides Power Behind Elegance
58. 1.1 What Is macOS?
59. 1.2 macOS Architecture: The Two Layers
60. 1.3 macOS and C: The Connection
61. 1.4 The XNU Kernel: Two Worlds in One
62. 1.5 macOS for C Programmers: What You Need to Know
63. 1.6 macOS vs Linux: What C Programmers Need to Know
64. 1.7 Installing C Tools on macOS
65. 1.8 Common macOS C Errors and Fixes
66. 1.9 Debugging on macOS
67. 1.10 macOS C Libraries You Should Know
68. 1.11 macOS vs Windows vs Linux
69. 1.12 L’s Final Thought
70. Quick Check: Can You Answer These?
71. Side Story: The Gates of Code
72. Chapter 21: The Key That Opened the Mountain
73. Chapter 21: The Life of a Program — From Source to Process
74. Practice: Process Exercises
75. Chapter 21: The Key That Opened the Mountain
76. Chapter 21: The Life of a Program — From Source to Process
77. Practice: Process Exercises