Learning Library

Before you can learn Python you have to be able to run it, read what it tells you when it is unhappy, and know the difference between a scratchpad and a program — this course gets you there in fifteen minutes.

Python has no variables in the box-with-a-value sense — it has names bound to objects, and once you see that clearly, aliasing bugs, `is` versus `==`, and mutable default arguments all stop being mysteries.

Text is the data type you will touch most often and the one people learn least deliberately — this course covers slicing, the twenty methods that do ninety percent of the work, and the f-string format spec that almost…

Python's `for` loop does not count — it asks a container for its items one at a time, and understanding that difference is what turns clumsy index-juggling code into the Python people actually write.

A list is a mutable sequence you build up; a tuple is an immutable record you pass around — and confusing the two is why some code is full of defensive copying and some code has bugs that only appear on the second call.

Swapping a list for a set can turn a program that takes four minutes into one that takes four seconds — not by optimising anything, but by asking the right container the right question.

The default argument evaluated once at definition time, the name that silently becomes local because you assigned to it, the closure that captures a variable rather than its value — functions are where Python's most…

`import` does not paste a file into yours — it runs that file once, caches the result, and binds a name to it, which explains circular imports, the `__pycache__` folder, and why `if __name__ == "__main__"` exists.

Two projects, one needing an old library version and the other the new one — without virtual environments that is an unresolvable conflict, and with them it is a non-event you never think about again.

`except Exception: pass` is three words that convert a bug you would have fixed in ten minutes into one you will spend a day finding — this course is about the alternatives.

String concatenation for file paths, `open()` without an encoding, and writing directly over the file you are replacing — three habits that work on your laptop and fail in production, and all three have a one-line fix.

A generator lets you write code that reads like it processes a list of ten million records, while never holding more than one of them in memory — and it is the same `for` loop you already know, from the other side.

Python's objects are not Java's with different syntax — there is no `private`, inheritance is usually the wrong tool, and the real power sits in the dunder methods that let your class behave like a built-in.

Four lines of `@dataclass` replace twenty lines of `__init__`, `__repr__`, and `__eq__` — and one `Enum` replaces the scattered string literals that a typo turns into a silent bug.

`@decorator` above a function is exactly `func = decorator(func)` — once that clicks, the syntax stops being magic and becomes the most reusable tool in your Python vocabulary.

`with` is not a file-handling feature — it is a general mechanism for guaranteeing that a cleanup step runs, and writing your own takes four lines.

Python ignores your type hints completely at runtime — which is exactly why they are useful: they are a contract for readers and tools, checked before the code ever runs.

A test in pytest is a function whose name starts with `test_` containing a bare `assert` — the entire framework exists to make that as close to writing nothing as possible.

Code that works is the low bar — the difference between Python written by someone fluent and Python translated from another language shows up in about four lines, and every one of those differences is learnable.

`obj.attr` is not a lookup in one place — it is a documented protocol involving the instance dictionary, the type, the MRO, the descriptor machinery, and two fallback hooks, and knowing the order explains almost every…

Most of the utility code people write in their first years already exists, tested and fast, in a module they have not opened — and knowing which module is the difference between an afternoon and one line.

A regex is the fastest way to pull structure out of flat text — and the fastest way to write a line that nobody, including you next month, can safely change.

Adding threads to a Python program makes some workloads eight times faster and others very slightly slower — and one property of the interpreter tells you which one you have before you write a line.

CSV is the format everyone believes they already understand, and it causes more silent data corruption than every binary format combined — because a broken CSV usually parses successfully into the wrong answer.

JSON finally gives you types — six of them — and every problem in this course comes from what is missing from that list, or from YAML's enthusiasm for guessing which one you meant.

Every format so far stores a table the way you'd write it on paper, one row at a time. Parquet stores it one column at a time, and that single rotation is where predicate pushdown, projection pushdown, and most of the…

Parquet writes a schema into every file's own footer. Avro writes almost no type information into each record at all — it leans on a schema kept alongside the data instead, and that one design choice is what makes Avro…

Parquet is not the only columnar format in production — ORC does the same fundamental trade (column-major layout, embedded schema, statistics for pushdown) with a different internal shape and a different ecosystem…

Every format in this series eventually gets compressed, and the codec you pick changes more than file size — it changes whether a huge file can even be split across parallel workers, which is the kind of decision that…

An .xlsx file is not a data format in the sense CSV or Parquet are — it's a zip archive of a dozen-plus XML documents that a spreadsheet application knows how to reassemble, and every 'just parse it like a table'…

Parquet nails how to store one file's worth of columns efficiently, but it has nothing to say about the moment 200 of those files need to look like one consistent table to a hundred concurrent readers and writers…

Every course in this series covered one format in isolation; the harder, more common problem in practice is standing in front of a new pipeline stage with a blank slate and having to pick — and the eight prior courses…

AWS looks like two hundred unrelated products, but underneath it is one uniform HTTPS API, sliced by account and by region — and once you can see those three facts, the rest of the platform stops being a memory test.

IAM is not a permissions checklist — it is an evaluation algorithm, and once you can run that algorithm in your head you can debug any access denial and design any grant without guessing.

S3 has no directories, no rename, and no append — and every surprising thing about building a data lake on it follows from those three absences.

IAM decides who can act and S3 decides where data lives; a VPC decides who can even reach it — and almost every networking surprise in AWS comes from treating a route table entry or a security group rule as a formality…

Every AWS data pipeline eventually asks the same question at every stage: Lambda, ECS/Fargate, or EC2 — and the answer is decided by hard limits and a cost model, not by preference.

A pipeline that picks the wrong store doesn't fail loudly on day one — it works fine until a partition key choice creates a hot shard or a read-replica lag quietly serves stale data to a downstream job.

A pipeline is only as reliable as what happens when one stage fails at 3am — and AWS gives you Glue to do the transforming and Step Functions to decide what happens next, instead of a cron job and a prayer.

Three AWS services move data between systems that aren't talking directly to each other — a durable replayable log, a work queue, and a fan-out broadcast — and picking the wrong shape is the kind of mistake that only…

Almost every Snowflake question — why is this slow, why did that cost $400, why does the same query take 200 ms the second time — has the same answer: which of the three layers did the work, and how much of the data…

Snowflake's bill is not mysterious — it is seconds of warehouse uptime multiplied by a size rate, plus storage. What makes it surprising is how much of that uptime is spent doing nothing, or doing work nobody asked for.

Every table you have queried in courses 01 and 02 had to arrive somehow — and Snowflake's answer is unglamorous: point at some files, copy them in, remember which ones you already copied.

A relational table wants every row to have the same columns; the JSON your API actually sends has orders with three line items today and none tomorrow — VARIANT is Snowflake's answer to that mismatch, and getting it…

Course 01 told you pruning is the single biggest lever on Snowflake performance and cost; this course is the other half — how to deliberately shape layout with a clustering key, how to read the Query Profile to prove…

Course 01 established that micro-partitions are immutable and rewritten rather than edited in place; this course is about the three features that immutability quietly pays for — querying or restoring any past state of…

Every privilege in Snowflake — read a table, create a warehouse, drop a schema — is granted to a role, never directly to a person; this course is about how that one design decision shapes everything from day-to-day…

Course 06 covered zero-copy cloning — a new object pointing at the same micro-partitions inside one account; Secure Data Sharing is the same trick of not moving data, stretched across an account boundary, and the…

Almost every silently wrong number in a data pipeline traces back to one of three beliefs: that a table is a spreadsheet, that the clauses run in the order you typed them, or that `NULL` is a value.

A join is a filtered cross product, and the question it forces on you — "what does one row of my result mean?" — is the one question that decides whether your numbers are right.

`COUNT(*)` and `COUNT(col)` differ by exactly the number of `NULL`s, and that one-character difference has produced more wrong dashboards than any syntax error in the language.

`GROUP BY` answers "one row per group" by throwing the other rows away. A window function answers the same kind of question — a rank, a running total, a comparison to the previous row — while keeping every row you…

A subquery is a question inside a question. The moment it references the outer row, it stops being a single question and becomes one question asked once per row — and that distinction is the difference between a query…

An index is a second copy of your data, sorted a different way and kept in perfect sync — which is why it makes some lookups instant, makes every write slightly slower, and does absolutely nothing for a query that…

A transaction is a promise that a group of writes happens as one indivisible unit or not at all — but the moment a second transaction runs at the same time, that promise alone doesn't say what it's allowed to see of…

Normalization isn't a checklist to satisfy for its own sake — each normal form exists because skipping it lets the same fact live in more than one place, and the moment a fact lives in two places, an update to one copy…

Before you write a line of prompt code you make three decisions — whose model, where it runs, and what shape the system takes — and getting them wrong costs months, not hours.

A model call is a stateless HTTP request that bills by the token, fails by throttling, and returns text that may not be the shape you asked for — every production concern follows from those four facts.

An embedding turns text into a point in space where nearness means "talks about similar things" — which is powerful, deeply lossy, and not at all the same as "answers this question".

RAG is not a feature you add to a model — it is a second system, retrieval, bolted in front of the call you already know, and most RAG failures are retrieval failures wearing a generation costume.

An "agent" is not a model that acts in the world — it is a model that writes structured text, and your code that decides what to do with it. Understand that split and every mysterious agent failure becomes diagnosable.

Fine-tuning is the most over-reached-for tool in AI engineering — most "the model doesn't do what I want" problems are prompt problems, and the ones that actually need fine-tuning still don't mean anything until you…

A RAG pipeline that works in a demo and a RAG pipeline that survives production are the same code running under two different disciplines: knowing what every call costs, what every call adds to the clock, and how you'd…

Git is a small content-addressed database with a command-line interface bolted on, and once you can see the four object types and the pointers between them, the commands stop being spells and start being obvious.

Almost every confusing thing `git status` says makes immediate sense once you know there are three copies of your project, not two, and that every command you run is moving content between a specific pair of them.

A branch is a sticky note on one commit, and a merge is just two different ways of writing history that reconciles two sticky notes that drifted apart — once you see both as movements over the object graph from Course…

A remote-tracking branch like `origin/main` is not a live window onto GitHub — it is a local ref that goes stale the instant you stop fetching, and most "why is Git confused about the remote" moments trace back to…

"Rewriting history" sounds destructive, but every rewrite is really just Git writing brand-new commit objects and moving one ref to point at them — the old commits sit untouched in the object database, and the reflog…

Three commands that look unrelated — stash, cherry-pick, bisect — are all just ordinary Git operations wearing a disguise: a stash is a commit, a cherry-pick is a one-commit rebase onto a different target, and a bisect…

Three tools for the moment a repo stops being one person's project: hooks run your own scripts at specific points in Git's workflow but live outside version control entirely, submodules point at an exact commit in…

A Spark job is not one program running on one machine — it is a plan built on the driver, cut into stages at every shuffle, and executed as thousands of small tasks on machines that never talk to your Python process.…

A Spark `Column` is not a value and does not contain data — it is a description of a computation that Catalyst is free to rewrite, and that single fact explains why built-in functions are fast, why Python UDFs are not…

Almost every Spark job that feels slow for no obvious reason is slow for the same obvious reason once you look — a shuffle moved more data across the network than it needed to, and a join is usually what asked for it.

`.cache()` is the single most misused optimisation in Spark — it looks like a free performance switch, but called on the wrong DataFrame it does nothing but slow the job down and crowd out memory other stages needed.

The two most common ways Spark output goes wrong — a write that produces thousands of tiny files, and a downstream query that scans far more data than it needs — both trace back to decisions made about partitioning…

Spark's streaming engine does not process one row at a time as it arrives — it runs the exact same batch engine from course 01 over and over, on small slices of new data, which is why almost everything you already know…

Adaptive Query Execution lets Spark rewrite its own physical plan mid-query once it has real numbers instead of estimates, which is why the old ritual of hand-tuning `spark.sql.shuffle.partitions` per job matters far…

DNA doesn't do anything by itself — it takes a whole molecular assembly line, copying it into RNA, cutting that RNA down, and reading it three letters at a time, before anything resembling a working protein exists.

A gene is a fairly simple idea once you see its parts; a variant is just a difference from a reference sequence — but where that difference lands, and how common it is, is what decides whether it matters at all.

Three techniques — cutting and pasting genes, copying DNA a billionfold, and editing it with pinpoint precision — are the actual machinery behind everything from bacterial insulin to gene-editing cures, and each one is…

A genome is just a very long string over a four-letter alphabet — and nearly everything genomics does to it, from indexing to graph traversal to statistical testing at scale, is an algorithms problem wearing a lab coat.

Every method in this course answers the same question — does this bit of DNA track with this trait, more than chance would allow? — the differences are just which axis you scan, and how you handle variants too rare to…

A Nextflow pipeline isn't a script that runs top to bottom — it's a graph of independent processes wired together by data, and that one shift in mental model is what gives you free parallelism, free caching, and a…

Amplify isn't a new cloud — it's a layer that provisions and wires together real AWS services, so building a full-stack app means writing a few lines of TypeScript instead of clicking through half a dozen AWS consoles.

Cognito answers two different questions — 'who is this user?' and 'what AWS resources can they touch?' — and almost every point of confusion about it comes from mixing those two up.

Each of these four services does one job well on its own — the actual skill is knowing exactly where one service's responsibility ends and the next one's begins, and how Amplify wires the seams between them.

A shim API is a thin layer you put in front of a backend to change its contract without changing the backend itself — and Lambda is one of the cheapest places to build one, because you're paying for a translator, not a…

A traditional HPC cluster is a fixed pile of hardware you pay for whether or not anyone's running jobs on it — ParallelCluster's whole premise is that a cluster can appear when you submit a job and vanish when you…

At its core, a large language model does one narrow thing extremely well — predict the next token — and nearly everything impressive or frustrating about it falls out of that one fact.

A vector database finds the things closest in *meaning* to your query, not the things that share its words — and that single shift is why they sit underneath modern search, recommendations, and AI retrieval.

RAG is the trick that lets a language model answer questions about things it was never trained on — by handing it the right paragraph at the right moment instead of asking it to remember everything.

DuckDB turns any process you already run on AWS — a laptop, a Lambda function, a Fargate task — into a fast SQL engine over your S3 data lake, without a cluster to provision or a service to pay per query.

SnapLogic hands you a canvas, a few hundred pre-built connectors, and no opinion about how to build a production data pipeline — this course supplies the missing opinion, using a real vendor feed as the running example.

One recurring integration problem — files show up on an FTP server and need to end up as rows in a database — and SnapLogic's answer to it: a visual pipeline that stages the data as partitioned Parquet on S3 in…

Claude Code is an agent that reads, edits, and runs things in your actual project — this course covers the four ways you shape what it does: slash commands, skills, subagents, and plugins, plus the hooks that enforce…

Blue-green deployment turns a release from a nerve-wracking in-place upgrade into flipping a switch between two identical, already-running environments — so a bad release is undone in seconds, not hours.

Liquibase turns database schema changes into version-controlled, reviewable, replayable code — so your Postgres schema stops being the one part of the system nobody can diff, review, or roll back safely.

A hash table turns the question "where did I put that?" into arithmetic — and that one trick is why lookups stay fast whether you store ten items or ten million.