Developer Slang: A Glossary of IT Terms with Explanations and Examples

Developer slang is the informal professional vocabulary that people in tech use with each other instead of long, formal terms. Most of it comes from English and gets absorbed directly into other languages — words like "commit," "debug," and "deploy" travel unchanged across borders because the tools and platforms that use them are global.
There's a practical reason this language exists. Saying "deploy to prod" is faster than saying "publish the updated version of the application to the main production server." Slang saves time and makes communication inside a team more precise. It also serves a social function: fluency in professional jargon signals that someone belongs to the industry.
Developer slang keeps evolving. New technologies bring new words, and older terms fade out. There's no single definitive dictionary — but there's a core set of terms that anyone working in software development will hear constantly. Those are the ones worth learning first.

In tech teams, everyone has a role and a level of experience — and there's established vocabulary for all of it. A developer's level is often called their "grade" or "seniority," and it largely determines their salary. Here are the main words developers use to describe themselves and their colleagues:

• Junior (junior dev) — a developer with up to 1–2 years of experience. Writes code under the guidance of more senior teammates.
• Mid-level (middle) — a developer who handles most tasks independently.
• Senior — an experienced developer who designs complex systems and mentors juniors.
• Tech lead / team lead — the leader of a development team; balances hands-on coding with management responsibilities.
• Padawan — a jokey term for a trainee or apprentice, borrowed from Star Wars.
• Coder — a programmer, sometimes with a slight implication of "just writes code, doesn't think about architecture."
• HR — the recruiter or HR specialist who conducts the first interview.
• Client / customer — the person or company the product is being built for; the one who sets the requirements.
• Stakeholder — anyone with a vested interest in the project's outcome: a client, manager, or investor.

This is the core of the professional vocabulary — words that come up in conversations about code every single day. Without knowing them, a conversation between two developers sounds like static:

• Bug — an error in a program that causes it to behave incorrectly. The name comes from an actual moth that got stuck inside a computer in 1947 and caused a malfunction.
• Feature — a function or capability of a program. "It's not a bug, it's a feature" is the classic developer joke about passing off a mistake as an intentional design choice.
• Hack / workaround — a temporary, inelegant solution that makes code work but violates proper logic. Developers reach for hacks when there's no time to do it right.
• Legacy code — old code written long ago, often in ways nobody fully understands anymore, but which still runs and nobody dares touch.
• Refactoring — rewriting code to make it cleaner and easier to read, without changing what it actually does.
• Hardcode — values written directly into the code instead of being configurable. Generally considered bad practice.
• Fix — correcting an error. "Fix a bug" means eliminate the problem.
• Hotfix — an urgent fix for a critical error applied directly to a live, running product.
• Debug — the process of finding and fixing errors in code. "To debug" means to track down exactly where a bug is hiding.
• Feature request — a request to add a new capability to a program.

Development isn't just writing code — it involves a whole set of actions around it: saving changes, publishing, merging work from different people. Each action has its own verb:

• Commit — saving a batch of changes to a version control system. "To commit" means to checkpoint a piece of work.
• Push — sending saved changes to a shared server so teammates can see them.
• Merge — combining changes from different developers into the shared codebase.
• Deploy — publishing the application to a live server where real users can access it.
• Production (prod) — the main live server where the application runs for real users. A bug "in prod" is the worst kind.
• Sprint — a short work cycle (usually 1–2 weeks) during which the team completes a planned set of tasks.
• Release — shipping a new version of the application.
• Deadline — the hard cutoff date for delivering a task.
• Standup — a short daily team meeting where everyone shares what they did, what they're doing, and whether anything is blocking them.
• Ticket — an individual task in a project management system, formatted as a card.
• Code review (review) — one developer's code being checked by others before it's merged into the shared project.

A whole category of words exists just to describe the quality of someone's code — or your own. Assessments are rarely neutral: developers feel strongly about code quality, because they're the ones who have to work with it afterward:

• Spaghetti code — code with such tangled logic that following it is as hard as untangling a bowl of spaghetti.
• Reinventing the wheel — writing a solution from scratch for a problem that's already been solved many times over. Wasting effort on something that didn't need building.
• Clean code — the opposite: readable, well-organized, easy to follow. Considered a mark of skill.
• Over-engineering — making a solution needlessly complex when a simple approach would have been fine. The opposite extreme from a hack.
• Technical debt — accumulated shortcuts and half-finished work in the codebase that will need fixing later, like a loan that accrues interest.
• Dead code — code that exists in the codebase but is never actually executed. Takes up space and creates confusion.
• Magic numbers — unexplained numeric values hardcoded directly into the logic, with no comment explaining what they mean.

Popular programming languages have informal nicknames, often based on wordplay or the language's logo:

• Java — sometimes called "the coffee language" (java is a slang word for coffee in English), or just referred to by name.
• PHP — still going strong despite decades of jokes at its expense; powers a huge chunk of the web.
• Python — named after Monty Python, not the snake, though the snake imagery is everywhere.
• JavaScript — often called "JS"; despite the name, has almost nothing to do with Java.
• C / C++ — C++ is sometimes called "C with classes" or just "the plusses" (for the two plus signs in the name).
• C# (C Sharp) — the "sharp" comes from the musical notation symbol; developed by Microsoft.
• Go (Golang) — Google's language for fast server-side programs; called "Go" or "Golang" to distinguish it in search results.
• Rust — valued for memory safety; growing fast in systems programming.

These nicknames don't just save time — they create a sense of shared culture. Someone who refers to JavaScript as "JS" and Python as "the snake" is already speaking the community's language.

Beyond slang, developers constantly use English abbreviations. Even a beginner benefits from knowing these:

• API — the way one program communicates with another. Short for Application Programming Interface.
• MVP — the smallest working version of a product that can be shown to users. Stands for Minimum Viable Product.
• DRY — "Don't Repeat Yourself": the principle of not duplicating the same logic in multiple places.
• TDD — Test-Driven Development: writing tests before writing the actual code.
• PR (pull request) — a request to add your changes to the shared codebase, pending review by teammates.
• QA — Quality Assurance: the role or process responsible for testing a product before it ships.
• UI / UX — UI is the interface itself; UX is how intuitive and pleasant it is to use.
• CI/CD — automated building and deploying of code, eliminating manual repetitive steps.
• KISS — "Keep It Simple, Stupid": the principle of not overcomplicating things when a straightforward solution exists.

If your child has gotten into coding, it won't be long before words like "bug," "debug," and "commit" start showing up at the dinner table. Knowing this language lets you engage with what they're saying rather than tuning out words that don't register.
There's a practical side too. When a child says "I used a hacky workaround because I was running out of time," they're actually describing a real engineering trade-off between speed and quality. Behind the slang are genuine professional concepts — and talking about them is a natural opening to discuss what working as a developer actually looks like.
Knowing the vocabulary also helps a parent gauge how seriously a child has gotten into the subject. If they're confidently using words like "refactoring," "debugging," and "pull request," they've moved well past just pressing buttons — they understand how real software development works. That's a good sign that an interest has turned into a meaningful skill.
At Rocket Tech School, children from age 5 learn to code through real projects: building games in Scratch, writing code in Python, and developing in Unity. They pick up professional vocabulary naturally in the process of building things they actually care about — so by the time they're teenagers, they're already fluent in the language that adults only encounter when they first step into tech.