I Am Learning SQL

I feel a tremor of excitement.

It is not necessarily about the SQL itself. It is about the act. Since my experiment with Cultivating the Reading Habit, this is my first voyage into a new technical territory.

This is not my first time learning a technology, of course. But I feel a distinct, rookie thrill—because this is a stress test. I am testing the new system.

In the past, I have abandoned countless subjects I swore I would master. The "I must learn this" list is a graveyard of ghost ships—ambitions left to drift. It is a common pathology. But I built this site for a reason (see The Story). This is the first technical trial on this new path I have carved.

This entry will be a living artifact, much like my reading log. I will return here to document what I read, what I watch, and what I discover in the silence of the code.

Why SQL?

In an era where everyone is begging artificial intelligence to do their heavy lifting, it is rare to hear someone admit they are learning the "basics."

Five years ago, writing a manifesto titled "I Am Learning SQL" would have been unnecessary. It was standard procedure. It is still popular, I suppose, but the act of learning it this way feels like an anachronism.

The primary answer is simple: Curiosity. The secondary answer: SQL is beautiful. Or, at least, I remember it being beautiful.

I recall loving the struggle of it during my university years. There is a specific potency in it for a developer. To harbor data, to summon it, to make it dance upon command—it is a satisfying kind of control. I want to play with that power again.

And, of course, there is the necessity.

I do not use SQL in my daily trade. I have spent my career traversing the surface of the Frontend; that is where I live. But AI has shifted the tectonic plates of our industry. I need to harden my defenses. I want to become competent across the spectrum.

I want to widen my aperture. I want to understand the machinery beneath the pixels I push.

You might ask, "Why not start by building a backend with a language?" I tried. Before this garden existed—before I shifted my mindset—I attempted to breach the fortress of backend development multiple times. I failed. And I am not talking about simply returning an http response. I mean understanding the architecture, the philosophy, the way problems are structured in the dark.

This time, I am choosing to ignore those past failures. I am starting with the data.

I have not fully architected the plan yet. First, I will investigate the history—the origin story of SQL. Why did it emerge? What problem was it trying to solve? Then, I will learn the syntax. I will practice the incantations.

Beyond that? I do not know. The map ends there. I will update this log as the path reveals itself.

The Method

I am beginning in the old way. The classic way. Udemy.

I paid a visit to an old friend and found a course: The Complete SQL Bootcamp. I decided in five minutes. It had high ratings, the instructor seemed competent, and frankly, I just need a guide to show me the perimeter.

My goal is to use the course as a compass, not a bible. I intend to learn by breaking things.

Naturally, Gemini will be my co-pilot. I use Claude Code, but for conceptual dialogue—for asking the "why" and "how" in the abstract—I prefer the Socratic method of Gemini Web.

This is the plan as of January 25th. The foundation of this garden is built on trial and error. If the video method fails me, I will change tactics.

But for now, the query begins.

Update: January 26

A few hours after the workday ended, I finally initiated the course.

It appears I made a sound choice. I am watching at 1.5x speed, and the content flows effortlessly. I have finished the first section, having already bypassed the installation phase.

The course uses PgAdmin, but I installed TablePlus. I did not care for PgAdmin; it felt too heavy. Since I am currently writing only fractured, minor queries, I thought a less complex tool would serve me better. Minimalism helps the focus.

I have learned the keywords necessary for the simplest incantations and ran a few practice drills.

Here is the visual evidence from Day 1:

I have grasped the usage of the following selectors (I am aware my jargon is not yet precise—I know some of these are functions or clauses, but forgive the rookie syntax):

• Select
• Distinct
• Count
• Order by
• Limit
• Between
• Where
• Like
• ILike

The course provides a pre-built database containing 8 or 10 tables. That is my sandbox. That is where I am practicing.

Update: January 28

I dedicated an hour to the curriculum today. I am updating this log immediately, while the logic is still resident in my short-term memory.

I am moving slowly. Deliberately. To be honest, nothing I encountered today felt alien or strange. However, there is a specific comfort in the act of remembering—that quiet moment of recognition where the mind whispers, "Ah, yes. I know how this works."

Today, I dissected the aggregation functions. I examined the architecture of Group By and ran drills with it. I also analyzed the Having clause and put it to the test. I archived a few notes in the process.

I am continuing with the course I mentioned above. The process is engaging. For now, the system is stable; there are no anomalies to report.

Day 2 Notes:

Today's functions and clauses:

• Count()
• Sum()
• Avg()
• Min()
• Max()
• Round()
• Group By
• Having

Update: February 8

I have refactored my learning protocol.

Instead of passively watching the course and transcribing notes, I have switched to a "Just-In-Time" execution model. I absorb a concept, then immediately write code to test it. This active state suits me better.

I have to admit, I never truly mastered the art of note-taking. I suspect I have been doing it wrong for years, and this SQL journey proved no different. The system was failing, so I deprecated it.

I am still consuming the Udemy course, but now, the moment I grasp a syntax, I switch contexts and practice. I find myself learning tangential things during these drills, which is a welcome side effect.

I have also decided to shift the update cadence for this log (and my other habit trackers) to a weekly schedule. I believe this batch processing will be more efficient.

Since this decision marks the start of a new order, I am labeling the first week of February as Week 1. I will increment from here.

Week 1

I have completed 55/83 of the course.

Up until now, the concepts felt deceptively simple while listening to the lectures. However, the moment I attempted to solve actual scenarios, the complexity revealed itself. Things that sounded logical in the abstract became tangled when faced with a blank editor.

No matter. I will proceed without haste.

This week's stack:

• Joins
• Subqueries
• CTEs
• String Functions
• Date Functions
• Math Functions

Additionally, on February 1st, I shipped my very first video artifact 🎉

This was a milestone: the first time I recorded, edited, and deployed a video. The nerves were real. I used this video to summarize my learnings from the first week.

Beyond that, I took the battle to Codewars to practice via SQL games. I decided to do this live on stream. It was surprisingly fun. I didn't know the answers to many things, but I struggled through them in real-time. It was a valuable experience.

The archive of that stream is here, yayyyy 🎉