How Microsoft Access and WordPress Secretly Taught Me Programming

Mohamed Isaac — Thu, 25 Dec 2025 11:06:48 +0000

For a long time, I believed that my programming journey only truly began when I touched JavaScript, React, or Ruby. Looking back now, I realize that’s not true. Long before I wrote my first proper line of code, I was already learning the mental models of programming—just without knowing their names.

Two tools in particular shaped my understanding far more than I realized at the time: Microsoft Access and WordPress.

At the time, I thought I was just “using software.” In reality, I was learning how systems think.

Microsoft Access: My First Programming Teacher (Without Code)

Microsoft Access was my first exposure to structured thinking. I created two tables and connected them. I built queries—some manually, some using small bits of SQL. At the time, it felt like office work. Today, I recognize it as my first lesson in computer science fundamentals.

From Access, I learned:

That data is not stored in one big place, but in multiple connected tables
The idea of relationships between entities with their attributes and Primary/ foriegn keys (This will be later useful when designing database schemas in ER diagrams)
That data has types: text, numbers, Yes/No (It will be called Boolean in PL data types)
That text must be wrapped in quotation marks—what programming languages later called strings
Why naming matters: avoiding spaces in table names to prevent brackets in queries, and using underscores instead
Data validation, which later clicked for me as type safety
Data redundancy, and why repeating the same information is a problem (later the concept of Dynamic)

At the time, I had no idea these concepts would reappear years later in programming languages, databases, and frameworks. But when they did, they felt familiar—almost comforting.

Access quietly trained my brain to think in terms of structure, rules, and relationships.

WordPress and Moodle: Learning Systems, Not Just Websites

Later, I started building WordPress websites and Moodle platforms. Again, I didn’t think of this as programming. I thought of it as “setting up websites.”

But WordPress taught me an entirely different layer of thinking.

Through it, I learned:

What domains and hosting actually are
How software lives on servers and is accessed through the web
The vocabulary of the web: widgets, menus, plugins, themes, design, etc
Basic SEO concepts
How systems are extended through plugins instead of rewriting everything

Most importantly, WordPress gave me a taste of modularity.

I could install a plugin to add functionality. I could remove it without breaking the whole system. I could customize layouts, behaviors, and workflows without touching the core engine.

That’s when something inside me shifted.

When Customization Became Curiosity

At some point, WordPress stopped being enough.

I didn’t just want to use plugins anymore—I wanted to understand how they worked. I wanted deeper customization. I wanted control.

That appetite didn’t come from nowhere. It came from repeatedly interacting with systems that almost let me express my ideas—but not fully.

This is an important stage in a learner’s journey:

First, you accept the tool as-is
Then, you customize it
Finally, you want to build it yourself

WordPress unknowingly pushed me toward that final stage.

The Hidden Lesson: Transferable Thinking

What Microsoft Access and WordPress gave me wasn’t syntax. It was something far more valuable:

Systems thinking
Abstraction
Constraints
Structure
Cause and effect

When I later encountered programming terms like tables, schemas, components, props, validation, modularity, and reuse, they didn’t feel alien. They felt like old friends with new names.

I didn’t realize it then, but I was already preparing my mind for programming—slowly, imperfectly, and unconsciously.

Looking Back

It’s easy to dismiss tools like Access or WordPress as “not real programming.” I used to think that way too. Now I see them differently.

They were my on-ramp.

They taught me how computers organize the world. And once that clicked, learning actual programming languages became less about memorizing syntax and more about translating ideas I already understood.