General Dev

The 10x developer myth claims some programmers are 10 times more productive than others. In reality, the biggest productivity multipliers come from not bui

Agile is a philosophy of building software in short cycles, learning from real feedback, and adapting quickly instead of following a massive upfront plan.

Algebraic data types are like Lego for type systems.

An algorithm is just a step-by-step recipe for solving a problem. Sort a list? There is an algorithm. Find the shortest path? Algorithm. Make a sandwich?

Android Studio is to Android what Xcode is to iOS — the official, unavoidable IDE. It's built on IntelliJ so it's actually quite good.

An ADR documents WHY you made a technical decision, not just what you decided. Why PostgreSQL over MongoDB? Why microservices over monolith?

An argument is the actual value you hand to a function when you call it.

An array is a list of things in order, like a numbered row of boxes. Box 0 holds the first item, box 1 holds the second, and so on.

Assembly is programming in the language the CPU actually speaks.

Async means 'don't wait around'. You order food at a restaurant, then chat with friends instead of standing at the kitchen window staring.

The backlog is the master to-do list for a product — every feature, bug, and idea that hasn't been built yet, prioritised by importance.

Base64 is like translating a photo into text by converting it to a long string of letters and numbers.

Bash is the most common shell — the language your terminal speaks by default on most Linux and older Mac computers.

Big O notation is how we describe how fast (or slow) an algorithm gets as the input grows. O(1) means instant no matter the size.

A binary is a file your computer can run directly — it has already been translated from human-readable code into the 1s and 0s the CPU speaks.

Bit rot is when software slowly stops working even though nobody changed it.

Bitrot is when code that worked perfectly six months ago mysteriously stops working. Nobody changed it.

A Blameless Postmortem analyzes incidents without pointing fingers. 'The system failed' not 'Bob failed.

A blocker is anything that completely stops you from doing your work — a broken build, a missing API, a review that's been pending for three days, or acces...

Code you have to write every single time you start a project but that doesn't actually do anything interesting.

A boolean is the simplest value in programming — it is either true or false. On or off. Yes or no. 1 or 0. Named after mathematician George Boole.

A branded type is like putting a name tag on a string so TypeScript doesn't let you accidentally mix up a UserId with an Email, even though they're both ju...

A breakpoint is like a 'pause game' button you place on a specific line of code.

Brooks's Law: 'Adding people to a late software project makes it later.

The opposite of greenfield — a project with existing code you have to work with (and work around). Most real-world development is brownfield.

A buffer overflow is like trying to pour 10 gallons of water into a 1-gallon jug — it spills everywhere and can destroy things nearby.

A bug is anything in your code that makes it behave wrong.

A build is the process of turning your development code into something a real computer or browser can run efficiently.

Bun's built-in package manager is the speed demon of the JavaScript world — it installs packages so fast it makes npm look like it's running through molass

Bun Shell lets you write shell scripts in TypeScript. No more 'this bash script only works on Mac'. Template literals run commands cross-platform.

C# is Microsoft's answer to Java. It started as 'Java but better' and evolved into a genuinely excellent language.

CLI is just the fancy term for any tool you use by typing commands instead of clicking buttons.

COBOL is the zombie language that refuses to die because banks are too scared to kill it.

The person who gets blamed when the technology doesn't work.

When your JavaScript code has so many nested callbacks it looks like a pyramid (or a sideways Christmas tree).

Cargo is Rust's all-in-one tool: it builds your code, downloads dependencies (called crates), runs tests, benchmarks, and generates docs.

Copying code without understanding why it works. Like a cargo cult that builds fake airplanes hoping real planes will come.

Cargo culting is copying code patterns without understanding why they work. You saw it in a tutorial, it fixed the problem, so you use it everywhere.

Change Failure Rate is the percentage of deployments that cause a production incident. Deploy 100 times, 5 cause issues? That's 5% CFR.

Changefreq is the sitemap XML hint telling search engines how often a page changes. Mostly ignored by crawlers, still widely used.

Changelog anxiety is the dread you feel when a dependency releases a major version update and the changelog is 47 pages long. What broke?

Changesets asks developers to leave a note (a changeset) describing what they changed and whether it's a patch, minor, or major change.

Chocolatey is Homebrew for Windows. Instead of downloading an .

A clack map is a keyboard-nerd term for the diagram of which keys make what mechanical-switch sound.

A class is a blueprint for creating objects.

Clojure is Lisp that actually got a real job. It lives on the JVM, loves immutable data, and uses more parentheses than a passive-aggressive text message.

A code editor is like a word processor but for code — it makes text look pretty with colors and helps you type faster.

A code kata is a small coding exercise you repeat to build muscle memory — like a martial arts kata but for programming.

A code review is when another developer reads your code before it gets merged, looking for bugs, bad practices, or anything confusing.

The codebase is the whole collection of source code that makes up a project — every file, folder, and line of code.

The command line is the place inside the terminal where you actually type your commands.

Compiling is translating your human-friendly code into machine-friendly instructions.

A compiler is like a translator that reads your entire code book, converts it all into a language the CPU understands, and hands you the finished translate...

Composer is what npm is to Node, but for PHP. Before Composer, PHP devs copied library files manually into projects. It was as fun as it sounds.

Composition Over Inheritance means building objects by combining small, focused pieces instead of creating deep inheritance trees.

Concurrency is juggling multiple tasks at once — not necessarily at the exact same instant, but switching between them fast enough that they all seem to be...

A conditional is an if/else decision in your code — 'if this is true, do this; otherwise, do that.' It is how your program makes choices.

Conditional types are if-else statements for TypeScript's type system. 'If T extends string, give me a number, otherwise give me a boolean.

Config is the settings panel for your code.

A constant is a box you seal shut after putting something in. You can look inside any time you want, but you can't swap out what's in there.

Jumping between different tasks and losing focus each time.

Contravariance is covariance's weird sibling that goes the opposite direction.

Convention Over Configuration means frameworks make assumptions about what you want so you write less config.

Conway's Law says your software architecture will mirror your org chart. Three teams? You'll end up with three services. Frontend team and backend team?

A coroutine is a function that can pause itself, let other things run, then resume right where it left off.

Covariance means 'if a Dog is an Animal, then a Box of Dogs is also a Box of Animals.

Cron is a scheduler that runs your code automatically at set times.

Crystal is Ruby if Ruby went to the gym and got really, really fast. Same beautiful syntax, but compiled to native code with static typing.

DORA Metrics are four numbers that measure how well your team delivers software: how often you deploy, how fast code goes from commit to production, how of...

DRY: Don't Repeat Yourself. If you're copy-pasting code, you're doing it wrong. Extract it into a function. But beware — not all similar-looking code shoul

DX (Developer Experience) is UX but for developers. How painful is it to set up the project? How fast is the feedback loop?

Dart is the language Flutter is written in. Google made it to fix JavaScript's problems, then it found its real home as the Flutter language.

Dashboard-driven development is when you spend more time building beautiful monitoring dashboards than actually improving the thing being monitored.

A data structure is a way of organizing information in your code so it is easy to use and fast to access.

Dead code is code that exists in the codebase but never runs — unreachable conditions, unused functions, commented-out blocks that 'might be needed later'...

A deadlock is when two things are each waiting for the other to go first, and neither ever does. Thread A holds Lock 1 and wants Lock 2.

Debugging is the process of finding and fixing the gremlins in your code. Something is broken, and you need to play detective — adding clues (console.

A debugger is a special tool that lets you pause your running program mid-execution, look around at all the variables, and step through the code one line a...

Demo-driven development is when every technical decision is made to look impressive in the next demo. Need a database?

A dependency is a package your project relies on to work. Your app depends on React to render UI, axios to make requests, and dotenv to read config.

When your project's packages need different versions of the same thing and everything breaks.

Deploying is taking your code from your computer and making it live on the internet for real users. Before: only you can see it.

Deployment Frequency is how often you ship to production. Elite teams: multiple times per day.

DevEx debt is every broken developer experience your team has accepted: slow tests, flaky CI, 10-minute cold starts, broken hot reload.

Devbox is Nix for people who don't want to learn Nix.

Developer Experience is everything about how pleasant or miserable it is to work with a piece of software as a developer.

A Developer Portal is a one-stop shop for everything developers need: API docs, service catalog, onboarding guides, templates, and tools.

Developer Productivity isn't just 'write more code faster.

A discriminated union is like a box that could contain a cat, a dog, or a fish — but it has a label on the outside telling you which one.

Documentation is written explanation of how your code works and why.

Doom scrolling logs is mindlessly scrolling through thousands of lines of application logs hoping the bug will just jump out at you.

Duck typing is the ultimate 'don't ask for a resume' approach. If it walks like a duck and quacks like a duck, it's a duck.

The Dunning-Kruger effect is when beginners think they know everything and experts think they know nothing. That junior who just finished a bootcamp and wa

Dynamic typing is like a box that can hold anything — toys, food, or a cat — and you don't have to label what goes in it ahead of time.

Elixir is like Ruby's syntax mated with Erlang's superpower: millions of tiny processes running independently, each with their own memory.

Elm is the language that promises zero runtime exceptions in your frontend code.

Emacs is the text editor that became an operating system. Want email in your editor? Done. Calendar? Sure. A game of Tetris? Absolutely.

Engineering Excellence is the culture of doing things RIGHT, not just doing things.

Engineering metrics measure how well your development process works. How often do you deploy? How long do PRs take to merge? How many bugs escape to produc

An enum is a named list of options that are all related.

An epic is a big chunk of work that's too large to finish in one sprint, so it gets broken down into smaller user stories.

Erlang was built by a telecom company in the 80s to handle phone calls that must never drop.

An error is when your program says 'I cannot do that' and either stops or complains loudly. It is the computer's way of telling you something went wrong.

Error handling is the art of planning for things to go wrong and dealing with them gracefully instead of letting everything catch fire.

An exception is a special kind of error that 'throws' itself up through your code like a hot potato, looking for someone to catch it.

F# is C#'s functional sibling that nobody at your job has heard of but is quietly excellent. It's like Haskell but you can still use .

A feature is something your software can DO — a capability you build on purpose. The login button is a feature. Dark mode is a feature.

Feature creep is when a project starts as 'a simple to-do app' and slowly becomes 'a to-do app with social features, AI integration, real-time collaboratio...

A float is a number with a decimal point — 3.14, 1.5, -0.001. The name comes from 'floating point' because the decimal point can be anywhere.

A feature or tool that makes it really easy to shoot yourself in the foot — meaning it's easy to make a mistake that hurts you.

A formatter automatically makes all your code look consistent — same indentation, same quote style, same line breaks — so the whole team's code looks like...

Fortran is the OG programming language from 1957 that scientists still use because nothing else crunches numbers as fast.

A function is a reusable recipe. You write the steps once, give it a name, and call it whenever you need those steps done.

Functional programming is like cooking with strict rules: no shared bowls, no side dishes contaminating each other, and every dish must be exactly reproduc...

A functor is a box you can map over. Array? Functor. Optional? Functor. Promise? Functor.

GUI is everything you see and click on — buttons, menus, windows, icons. It is the opposite of a CLI where you type commands. Your phone is all GUI.

Garbage collection is your programming language's automatic cleanup crew. When you create variables and objects, they take up memory.

A generic is like a recipe that works for any ingredient.

Generic constraints are like telling a restaurant 'I'll eat anything... as long as it has cheese.

A Gist is a GitHub feature for sharing a single file or small snippet of code publicly (or privately).

GitOps means Git is the single source of truth for EVERYTHING — code AND infrastructure. Push to the repo, and automation deploys it. Want to know what's r

Gleam is the friendly functional language that runs on the BEAM (Erlang's VM) but with real types and great error messages.

Adding unnecessary polish and features nobody asked for. Like spending 3 days perfecting the loading animation when the client just wanted a form.

A Golden Path is the recommended, well-supported way to do something in your organization. Need a new service? Follow the Golden Path template.

Goodhart's Law: 'When a measure becomes a target, it ceases to be a good measure.' Measure lines of code? People write verbose code.

A graph is like a network of dots connected by lines. Each dot is a node and each line is an edge.

Green threads are fake threads managed by your programming language instead of the operating system.

A brand new project with zero existing code. A blank canvas.

Groovy is Java with the suit jacket off and sleeves rolled up. It makes Java more fun by adding dynamic typing, closures, and a relaxed syntax.

curl is powerful but its syntax reads like a crossword puzzle. HTTPie is curl for people who like readable commands: 'http GET api.example.

In coding, a hack is a clever but ugly solution that works without being pretty or proper. It is duct tape on a leaky pipe.

A coding sprint where teams build something from scratch in 24-48 hours. Pizza is consumed. Sleep is optional.

Hanlon's Razor: 'Never attribute to malice that which is adequately explained by stupidity.' That teammate who merged broken code didn't do it on purpose —

A hash map is a super-fast lookup table. You store a value under a key (like a label), and you can find it instantly without searching through everything.

Haskell is the language PhD students use to make you feel bad about for-loops. Everything is immutable. Side effects are quarantined in monads.

A bug that disappears when you try to find it. Named after Heisenberg's uncertainty principle — the act of observing (debugging) changes the behavior.

Helix takes vim's modal editing and flips it: instead of verb-then-noun (delete word), it's noun-then-verb (select word, then delete).

Hex is Elixir's package manager. It lives inside Mix, Elixir's build tool. You add a dep to mix.exs, run 'mix deps.get', and hex.pm delivers your package.

Homebrew is how Mac developers install tools without downloading .dmg files like animals. 'brew install node' beats hunting the Node.js website.

A controversial opinion about technology that's designed to start arguments on Twitter/X. 'Tailwind is just inline styles.' 'TypeScript slows you down.

A hotfix is an emergency patch you ship immediately to fix a critical bug in production — no waiting for the next planned release.

Hype-driven development is choosing your tech stack based on what's trending on Twitter/X instead of what's appropriate for your project.

Hyrum's Law: 'With enough users, every observable behavior of your system will be depended on by somebody.

An IDE is like a super-powered notebook for writing code. It comes with a pen, a spell-checker, a dictionary, and a built-in teacher all in one app.

Idempotent means you can do the same thing multiple times and get the same result as doing it once.

Immutability means once you create something, you can't change it — like writing in pen. Want to make a change? Create a new copy with the change.

Impostor syndrome is when every developer feels like a fraud who's about to be exposed. 'They're going to find out I have no idea what I'm doing.' Spoiler:

A loop that never stops running. It goes around and around forever because the exit condition is never met (or doesn't exist).

Infrastructure as Code means defining your servers, networks, and databases in code files instead of clicking buttons in a web console. Version it, review

Inner Source applies open-source practices inside your company. Any developer can contribute to any team's codebase via pull requests.

An integer is a whole number — no decimal point. 1, 42, -7, 1000 are integers. 1.5 is NOT an integer, that is a float.

IntelliJ is what happens when you spend 20 years making developers productive in Java.

An interface is like a job description. It says 'whatever fills this role must be able to do X, Y, and Z' without caring how they do it.

An Internal Developer Platform (IDP) is the self-service layer that lets developers deploy, monitor, and manage their apps without bugging the ops team.

An interpreter reads your code and runs it line by line in real time, like a live translator at a conference.

An issue is GitHub's word for a ticket — a filed report about a bug, feature request, or question.

JSDoc is like writing sticky notes for your JavaScript code that IDEs can actually read.

JetBrains makes IDEs that understand your code better than you do. They have a specialized IDE for every language — IntelliJ for Java, WebStorm for JavaScr

Julia is what scientists use when their Python code is too slow but they refuse to learn C++.

KISS: Keep It Simple, Stupid. The best code is the code that doesn't make you think. No clever tricks, no over-engineered abstractions, no 'look how smart

Kanban is a visual workflow system where tasks move through columns — To Do, In Progress, Done. Unlike Scrum with fixed sprints, Kanban is continuous flow.

Donald Knuth said: 'Premature optimization is the root of all evil.' Don't waste time making code fast before you know it's slow. Write it clearly first, m

Kotlin is like Java's cooler younger sibling who went to art school and came back with null safety and coroutines.

Coroutines are like async/await but smarter.

Flow is Kotlin's version of RxJava, but readable. It's a stream of values that flows from a producer to a collector.

Kotlin Multiplatform (KMP) lets you write your data models, API calls, and business logic once in Kotlin, then use them in your Android app and your iOS ap...

The Law of Leaky Abstractions states that all non-trivial abstractions leak — Joel Spolsky named it, every senior dev has lived it.

LazyVim is Neovim for people who want a fully configured IDE out of the box without spending 200 hours tweaking Lua configs. It's like buying a pre-built g

Lead time is how long it takes from code commit to running in production. Elite teams do it in under an hour. Low performers take over six months. It measu

Lead Time for Changes measures how long it takes from code commit to production deployment. Elite teams: less than an hour. Slow teams: weeks or months.

Old code that nobody wants to touch but everyone depends on.

Lerna was the grandfather of JavaScript monorepos before Nx and Turborepo showed up.

The project management tool that developers actually enjoy using. While Jira feels like filing taxes, Linear feels like using a well-designed app.

A linked list is like a treasure hunt where each clue tells you where the next clue is. Each item (node) holds a value AND a pointer to the next item.

Lint theater is enforcing hyper-strict lint rules that waste everyone's time debating tabs vs spaces, quote styles, and variable names while actual bugs sh...

A linter is the code police — it automatically checks your code for style violations, bad patterns, and potential bugs without running it.

Linus's Law: 'Given enough eyeballs, all bugs are shallow.' The more people who look at the code, the more likely someone will spot the bug.

Localhost is your computer pretending to be a web server just for you.

A localhost millionaire is someone whose side projects work beautifully on their own machine and never see the light of production.

A lock file is a snapshot of the exact versions of every package your project is using right now.

Lock file resolution is the process of pinning every single dependency (and their dependencies, and their dependencies' dependencies) to exact versions. It

Logging is writing a diary for your program.

A logic error is the sneakiest kind of bug — the code runs perfectly fine, no crashes, no errors, but it does the WRONG thing.

A loop makes your code do something over and over until a condition says stop.

Lua is the language embedded inside other things. Roblox runs on it. World of Warcraft addons are written in it. Nginx can run Lua scripts.

MATLAB is what engineers use in university and then spend the rest of their careers trying to rewrite in Python.

An MVP is the simplest version of your product that actually works well enough for real users to use and for you to learn from.

A random number in your code with no explanation. Like writing `if (age > 17)` instead of `if (age > MINIMUM_AGE)`.

A magic string is a hardcoded string value buried in code with no explanation — like finding a mysterious note that says 'ADMIN_OVERRIDE_7742' deep in the...

The person who keeps an open-source project alive.

Mapped types let you create new types by transforming every property of an existing type.

Markdown is a simple way to format text using just plain characters. Put `**asterisks**` around a word and it becomes **bold**.

Mean Time to Recovery (MTTR) is how fast you bounce back from production incidents. Elite teams recover in under an hour.

A memory leak is when your program keeps grabbing more memory but never gives it back, like filling a bathtub without a drain.

A method is just a function that belongs to an object or class. Your Dog object has a bark() method — it's the dog's personal function.

Mise is the 'one version manager to rule them all'.

Mob programming is pair programming on steroids — the entire team works on the same thing, on the same computer, at the same time.

Mojo is Python's superhero alter ego. By day it looks just like Python, but by night it runs 35,000x faster because it compiled itself to MLIR.

A monad is a design pattern for chaining operations that have extra 'context' — like maybe-empty values, async results, or errors.

Changing how existing code works at runtime by overwriting functions or objects — without touching the original source code.

A monorepo is when you put all your different projects — frontend, backend, shared libraries — in one giant single repository instead of separate repos.

When developers refuse to use existing libraries because 'we can build it better ourselves.

NaN means 'Not a Number' — it is what JavaScript gives you when math goes wrong in a weird way. Try to parse a word as a number and you get NaN.

Presenting someone with an interesting problem that's so fascinating they HAVE to solve it, even though they have actual work to do.

Nim is the language that read Python's diary, stole its pretty syntax, then compiled everything to C for blazing speed.

Nix makes your dev environment as reproducible as a Docker container, but without Docker. Write a flake.

Nominal typing is the VIP list at a club — even if you look exactly like someone on the list, you can't get in unless your name matches.

NuGet is .NET's package manager. Packages come from nuget.org.

Null means 'intentionally nothing' — a programmer chose to say 'there is no value here'. It is a deliberate absence.

Nx is like a smart contractor for your monorepo.

OCaml is the language that Jane Street (a major quant trading firm) bet their entire infrastructure on.

OOP is a way of organising code by modelling the world as objects — things that have properties (what they are) and methods (what they do).

An object is like a labeled container — instead of numbered boxes like an array, each box has a name.

Objective-C is the language Apple used before Swift, and it looks like C and Smalltalk had a baby during a bracket sale.

An off-by-one error is when you're exactly one too many or one too few — the most common bug in programming. Is it < or <=? Does the array start at 0 or 1?

Open source means the recipe is public. Anyone can read it, copy it, tweak it, and share their version. It's the opposite of a secret sauce.

Option type is the type system's way of saying 'this might have a value, or it might be empty, and you MUST handle both cases.

Optional dependencies are packages that your code CAN use if they're available but won't cry about if they're not. It's like a recipe that says 'add truffl

Oxlint is the linter that makes you realize how slow ESLint is.

A polite (okay, sarcastic) way of saying the problem is the user, not the software. When someone reports a bug but they're actually just using it wrong.

A POC is a quick experiment to prove an idea can work before you spend months building it properly. It's the 'will this even work?' test.

A package is a bundle of code someone else wrote and published so you don't have to reinvent the wheel. Need to parse dates? There's a package for that.

A package manager is the app store for your code — it downloads libraries, manages versions, and makes sure everything plays nice together. It's like a gro

Parallelism is doing multiple things at literally the exact same time — two chefs cooking two dishes simultaneously.

A parameter is the placeholder name inside a function definition — it's the label on the slot where you plug things in.

Parkinson's Law: 'Work expands to fill the time available.' Give a developer 2 weeks for a 2-day task, and they'll spend 12 days gold-plating, over-enginee

A patch is a small update that fixes something specific without replacing the whole program.

Pattern matching is like a super-powered switch statement that can look inside data structures and pull out the parts you need.

A paved road is Netflix's version of a golden path — the well-maintained, easy route that most teams should take. It's not mandatory, but going off-road me

Peer dependencies are like a library saying 'I work with React, but I'm not going to install it for you — you should already have it.' It's the BYOB (Bring

Perl is the language that invented the 'just get it done' philosophy. It's why they say TMTOWTDI (There's More Than One Way To Do It).

A Platform Team builds internal tools and infrastructure so product teams can ship faster.

A port is like an apartment number on a building. Your computer is the building (localhost), and multiple services live inside.

Postel's Law: 'Be conservative in what you send, be liberal in what you accept.

Premature Optimization is Knuth's famous warning: 'Premature optimization is the root of all evil.

The final boss of the individual contributor track. Principal engineers shape the technical direction of entire companies.

A process is a full running program with its own isolated chunk of memory.

A product type is 'this thing has a name AND an age AND an email — all at once.' It's your everyday struct or object.

Pseudocode is fake code written in plain English that describes what your real code should do, without worrying about syntax.

A pure function is the well-behaved kid of programming.

PyCharm is the IDE that makes Python development feel luxurious. It manages your virtual environments, understands Django/Flask, debugs visually, and even

A queue is like a line at a coffee shop — first come, first served. The first person to get in line is the first to get their coffee.

R is what statisticians use when Excel isn't enough. It's built around the idea that your data is a vector or data frame, not individual values.

A README is the instruction manual taped to the front of a code project. It tells newcomers what the project does, how to install it, and how to use it.

A not-so-polite way of saying 'the answer is in the documentation, go read it.

A race condition is when two parts of your code are racing to do something at the same time and the winner isn't guaranteed — leading to unexpected, hard-t...

When a developer gets so frustrated they slam their laptop shut and walk away.

Recursion is when a function calls itself to solve a smaller version of the same problem, like a set of Russian nesting dolls.

Refactoring is cleaning and reorganizing your code without changing what it does — like tidying your room without throwing anything away.

Referential transparency means you can replace a function call with its return value and nothing changes.

Regex is a secret language for describing patterns in text.

An RFC is a proposal document shared with the team before making a big technical decision.

Result type is like a delivery that's either your package (Ok) or a note explaining why it failed (Err).

A retro (retrospective) is when the team looks back at the last sprint and asks three questions: What went well? What sucked? What should we change?

A return value is what a function hands back to you after doing its work. You send a coffee machine beans and water, it returns coffee.

Roc is the functional language for people who want Elm's safety and simplicity but for backend code too.

A rollback is the panic button. When you deploy something and it breaks production, you hit rollback and the system reverts to the last working version — l...

When something snaps back to where it was, like pulling a rubber band. In UI, it's that bouncy effect when you scroll past the edge.

The rubber duck method is explaining your code problem to a rubber duck (or any inanimate object). By forcing yourself to describe the problem step by step

Approving a pull request without actually reading the code. Just clicking 'LGTM' and moving on. We've all done it. We've all been burned by it.

Runtime is the environment where your code actually runs.

A runtime error is one that only shows up when your program is actually running, not before.

Rush is Microsoft's monorepo manager for when your repository has 500 packages and Lerna cried and quit.

An SDK is a toolkit a company gives you so you can build stuff that works with their platform.

SOLID is five principles that keep object-oriented code from turning into spaghetti: Single Responsibility, Open-Closed, Liskov Substitution, Interface Seg

A sandbox is a safe, isolated play area where code can run without affecting anything real.

Scaffolding is when a tool auto-generates the skeleton of your project for you.

Scala is like Java got a functional programming makeover. It has classes AND functions AND type inference AND implicits AND... it compiles slowly.

A script is a file full of commands that run automatically one after another, so you do not have to type them all yourself.

Scrum is a specific recipe for doing Agile.

Semantic versioning uses three numbers — MAJOR.MINOR.PATCH — where each number means something. PATCH (1.0.1) = bug fix. MINOR (1.1.

Semver is the numbering system for software versions: MAJOR.MINOR.PATCH.

The shell is the program that reads what you type in the terminal and makes things happen.

When developers chase every new framework, language, or tool instead of finishing what they started. 'Ooh, a new JS framework! Let me rewrite everything!

Shipping means getting your feature or fix out to users — it's the end goal of all the coding.

A side effect is when a function secretly does something beyond just giving you an answer — like changing a global variable, writing to a file, or sending...

A snippet is a short piece of code that does one specific thing, saved so you can paste it anywhere you need it.

Space complexity is how much extra memory your algorithm uses as the input grows.

A spike is a short, time-boxed experiment to figure out if something is even possible before committing to building it. 'Can we integrate with this API?

A sprint is a fixed time-box — usually 1-2 weeks — where a team commits to completing a specific set of tasks.

Sprint zero is the sprint before the real sprints begin.

A stack is a pile of things where you can only add to the top and take from the top — like a stack of plates.

A stack overflow happens when a function keeps calling itself forever, like a mirror facing a mirror.

A stack trace is the error report that tells you exactly which functions were called right before your code crashed.

StackOverflow-driven development is when your entire engineering process is: encounter error → copy error message → paste into search → find StackOverflow...

The senior developer who chose to stay technical instead of becoming a manager.

A standup is a short daily team meeting — meant to be done standing so it stays brief.

Starship is the shell prompt upgrade that makes your terminal look like it belongs in a sci-fi movie.

Static typing means you have to tell the computer what type each variable is when you write the code, and it checks everything is correct BEFORE running.

Story points are a way to estimate how hard a task is — not how long it takes, but how complex and uncertain it is. A 1-point task is trivial.

A string is text in programming — any sequence of characters wrapped in quotes. 'Hello', 'user@email.com', '12345' — if it is in quotes, it is a string.

Structural typing is TypeScript's dating philosophy: it doesn't care about your name, only your shape.

A sum type is 'this thing is EITHER a cat OR a dog OR a fish — pick one.' It's like a multiple choice question for types.

Swift is Apple's way of saying 'Objective-C was a great experiment, but let's make something humans can actually read.

SwiftUI is Apple's answer to React — instead of manipulating views imperatively, you declare what the UI should look like given some state and SwiftUI figu...

Sync means one thing at a time, in order. You order food, stare at the kitchen wall, and only get to sit down when the food arrives.

Syntax is the grammar rules of a programming language — where to put the curly braces, where to put semicolons, how to write a function.

A syntax error is when you write code that the computer cannot even understand — like handing someone a sentence with no verbs.

Tail call optimization is when the compiler realizes your recursive function's last action is calling itself, so instead of stacking calls until the stack...

The developer who got promoted into having opinions about architecture AND managing people.

A Tech Radar is a visual map of technologies your org evaluates, adopts, or avoids.

All the technologies used in your project, stacked together like a sandwich.

Template literal types let TypeScript understand string patterns at the type level.

The terminal is a black window where you talk to your computer using text commands instead of clicking buttons.

When your computer (or your team) spends so much time switching between tasks that nothing actually gets done.

A thread is a mini-worker inside your program that can run tasks independently.

A ticket is a single unit of work in a project management tool — it could be a bug to fix, a feature to build, or a task to complete.

Time complexity is how the time your algorithm takes grows as the input gets bigger. Does it take twice as long when you double the data? Ten times longer?

Toolchain tax is the time you spend wrestling with your build tools, IDE, linters, formatters, and CI instead of writing code.

Transpiling is like translating code from one programming language to another, both at a similar level.

A tree is a data structure shaped like an upside-down tree — one root at the top, branches going down, and leaves at the very bottom.

Try/catch is your safety net. You put risky code in the 'try' box, and if it blows up, the 'catch' box catches the explosion and handles it gracefully inst...

When you keep watching tutorials and following along but never build anything on your own.

A type tells the computer what kind of thing a value is — is it a number, text, true/false, or a list?

A type guard is like a bouncer at a club checking IDs. Before your code enters the VIP section, the guard checks 'are you a string or a number?

Type inference is the compiler being smart enough to figure out what type something is without you having to spell it out.

Type narrowing is TypeScript being a detective.

TypeScript Strict Mode is like putting a hall monitor on your code.

UTF-8 is the most popular way to turn Unicode characters into actual bytes on disk. It's clever — English letters take 1 byte, exotic characters take more.

Undefined in JavaScript means a variable exists but has never been given a value.

Unicode is the master list of every character ever invented by humans — letters, numbers, emojis, ancient Sumerian cuneiform, all of it.

A user story is a tiny description of a feature from the user's perspective, written in plain English: 'As a user, I want to reset my password, so that I c...

Utility types are TypeScript's built-in type transformers — like Instagram filters but for your interfaces.

V is the language that promised to compile in 0.5 seconds, have no undefined behavior, and be simpler than Go.

VS Code is the IDE equivalent of a fast food chain — it's everywhere, everyone uses it, there's an extension for literally everything, and yes it's technic...

A variable is a named box where you store information.

A virtual environment is an isolated bubble for your Python project's packages.

Volta is a JavaScript toolchain manager that pins Node versions per project and switches automatically when you cd into a directory. It's like your compute

WASM is the cool abbreviation for WebAssembly, because saying the full name every time would take longer than the code takes to execute.

Code that's not done yet. When you mark a PR as WIP, it means 'don't merge this — I'm still working on it.' It's like a 'wet paint' sign for your code.

WebStorm is the IDE that understood JavaScript before TypeScript even existed.

A workaround is a way to avoid a problem without actually fixing it. The door is broken so you use the window.

Works in staging is the sequel to 'works on my machine.' The code passed every test in the staging environment but immediately catches fire in production.

A workspace is how package managers understand a monorepo — they see multiple packages inside one repo and manage them together.

The workspace protocol (workspace:*) is how packages in a monorepo say 'I want to use the version of this package that's right here in our repo, not some v

Workspaces let you have multiple packages in one git repo that can import each other as if they were published npm packages. No more 'npm link' nightmares.

Xcode is Apple's gift to iOS developers, and like many Apple gifts, it looks beautiful and behaves mysteriously.

YAGNI: You Ain't Gonna Need It. Don't build features 'just in case.' That abstraction layer for a database switch that will 'probably' happen? It won't. Bu

YAML is a way to write structured data that actually looks like a human wrote it.

A YAML engineer is someone who spends more time writing configuration files than actual code.

Zed is what happens when the people who built Atom said 'let's rebuild it in Rust from scratch and make it actually fast.

Zig is C but the parts that make C dangerous are explicit instead of hidden. Want to allocate memory? You pass an allocator.

apt is how you install software on Debian-based Linux. 'sudo apt install nginx' and nginx appears.

asdf is the 'one version manager to rule them all' — it manages versions of Node, Python, Ruby, Go, Terraform, and basically anything through a plugin syst

bat is cat with wings. It does the same thing — prints file contents — but with syntax highlighting, line numbers, git integration, and pretty formatting.

cURL is the granddaddy of 'talk to the internet from the command line.' It's been around since 1998 and is installed on basically every computer ever made.

curl is the Swiss Army knife — it handles every HTTP method, protocol, and header you can dream of.

exa is ls but pretty. It color-codes file types, shows git status inline, renders tree views, and generally makes your terminal directory listings look lik

fish is the shell that decided 'what if it just worked, without spending two days configuring dotfiles?

fnm (Fast Node Manager) is the speedy alternative to nvm — it manages Node.js versions but doesn't make you wait 3 seconds every time you open a terminal.

fzf is a little Go program that adds fuzzy search to everything in your terminal.

In Ruby land, packages are called 'gems' because everything is precious and whimsical.

Your API returns 400 lines of JSON. You want just the name field from every object in the users array. 'curl url | jq .users[].name' does it in one pipe.

neovim is what happened when the vim community said 'this code is 30 years old, let's refactor it.

node_modules is the folder where npm dumps all the packages you install. It can grow to hundreds of megabytes instantly and contains thousands of files.

npm is like a vending machine for code. You say 'I want React' and it delivers React, plus React's 47 friends, plus their friends' friends.

npx is the 'try before you buy' of the npm world — it lets you run a package without permanently installing it. Need to scaffold a new project with create-

nvm (Node Version Manager) is the OG tool for managing multiple Node.js versions. Need Node 16 for the old project and Node 22 for the new one? nvm switche

pip is Python's shopping cart. You run 'pip install numpy' and numpy appears.

pnpm is the Marie Kondo of package managers. Instead of copying lodash into every project, it stores one copy on disk and symlinks to it everywhere.

pnpm Workspaces is pnpm's monorepo feature that lets multiple packages share a single node_modules store through the magic of symlinks. It's like having on

pub is Flutter's package manager, like npm for JavaScript. Your app's dependencies live in pubspec.yaml.

ripgrep (rg) does what grep does but much faster and smarter. It automatically skips node_modules, .git dirs, and anything in your .gitignore.

tmux lets you have multiple terminal windows inside one terminal, and — crucially — sessions survive if your SSH connection drops.

vim is a text editor with two modes: insert (type text) and normal (do everything else with keyboard shortcuts).

yarn is like npm but it took a productivity course.

yq is to YAML what jq is to JSON — a command-line tool that lets you read and modify YAML files without opening them in an editor.

zoxide remembers every directory you've visited and lets you jump to them by typing just a few letters. Instead of 'cd ~/Desktop/projects/my-app/src/compon

zsh is bash but with superpowers unlocked.