Glossary for Beginners

Are you new to programming, studying computer science, or moving into tech from another field? If programming terms, tech jargon, or complex definitions ever leave you confused, you're in the right place.

This programming and computer science glossary is made for beginners and anyone seeking clear, simple explanations of key terms and concepts. All definitions are in plain language—no unnecessary complexity. We regularly add new terms and update existing definitions to keep this resource helpful and current.

Bookmark this page! It's a handy resource you can return to whenever you need clear explanations of programming and tech terms.

32 terms and counting

AI (Artificial Intelligence)

general

Software that can perform tasks that typically require human intelligence — like understanding language, recognizing images, or making decisions.

AI systems learn from data instead of following hard-coded rules. They find patterns and use them to make predictions or generate outputs.

Examples: ChatGPT (text), image generators, voice assistants, recommendation systems.

Algorithm

general

A step-by-step set of instructions to solve a problem or complete a task.

Think of it like a recipe — it tells you exactly what to do, in what order, to get a result.

Examples:

A sorting algorithm arranges items in order
A search algorithm finds an item in a list
A recommendation algorithm suggests videos you might like

Algorithm vs simple logic: Checking "if user is logged in, show dashboard" is basic logic. An algorithm solves a broader problem — like "find the fastest route between two cities" or "sort 1 million names alphabetically." It's a reusable procedure designed to handle complex tasks efficiently.

Algorithms are the building blocks of all software.

Assertion

testing

A line in a test that checks whether your code behaves the way you expect.

It compares an actual result with an expected result and tells the test whether it should pass or fail.

Boilerplate

general

Repetitive code that you need to write to get started, even though it's not unique to your project.

Examples:

HTML document structure (<!DOCTYPE html>, <head>, <body>)
Import statements at the top of every file
Config files for tools

Many tools offer "boilerplate templates" or "starter kits" to skip this setup.

Bootstrapping

general

The process of setting up and starting a project or system from scratch.

When you "bootstrap" a project, you're creating the initial structure — installing dependencies, configuring tools, and writing the basic files needed to get going.

Example: npx create-react-app my-app bootstraps a new React project with all the setup done for you.

Not to be confused with Bootstrap (the CSS Framework).

Bug

general

A bug is a problem in your code. It is a part of the code—sometimes just a single line—that doesn’t work the way it should. It might break your app or website, or simply produce incorrect results.

To fix it, you need to start Debugging, find the problem, and apply the correct solution.

CLI (Command Line Interface)

tools

A way to interact with a program by typing commands instead of clicking buttons.

The term refers to both:

The concept of text-based interaction
Specific tools that use this approach (e.g., "the git CLI")

Many developer tools are CLI-based:

git commit — save changes
npm start — run your project
node app.js — execute a file

CLIs are popular because they're fast, scriptable, and work well in automation.

Compiler

general

A special translator for computers. It takes code written in a High-level Programming Language (such as Python, JavaScript, or Java) and converts it into a lower-level form that a computer can execute.

This lower-level form could be:

Machine code (0s and 1s your CPU understands), or
An intermediate format, such as Java bytecode, which still needs further processing.

Compiling doesn’t always mean translating all the way to machine code—it simply means converting code into a more execution-ready form.

A file produced by a compiler is often called a binary or executable.

Debugging

general

The process of finding and fixing Bugs in your code.

Dependency

general

Code that your project relies on to work — usually a Framework or library someone else wrote.

Instead of building everything from scratch, you install dependencies to handle common tasks like making HTTP requests, formatting dates, or connecting to a database.

In JavaScript projects, dependencies are listed in package.json and installed with npm install.

DRY (Don’t Repeat Yourself)

principles

A programming principle that encourages avoiding repetition. If the same logic appears multiple times, it should be moved into a single place.

This creates a single source of truth and makes updates easier and safer.

// Instead of repeating this code in different files:
// fileA
let fullName1 = user.firstName + " " + user.lastName;

// fileB
let fullName2 = user.firstName + " " + user.lastName;

// Write it once
function getFullName(user) {
  return user.firstName + " " + user.lastName;
}

// Use it everywhere
let nameA = getFullName(user);
let nameB = getFullName(user);

Related principles: KISS (Keep It Simple, Stupid), YAGNI (You Aren’t Gonna Need It)

Framework

tools

A pre-built foundation that gives you a structure and set of tools to build applications faster.

Instead of writing everything from scratch, a framework provides:

Ready-made code for common tasks
A defined way to organize your project
Built-in features like routing, database handling, or security

Think of it like a house frame — the walls, roof, and foundation are already in place. You just need to add the rooms and decorations.

Framework vs Library: With a library, you decide when to use it — you call its functions. With a framework, the framework is in charge — it runs the show and calls your code when needed (e.g., "when a user visits /home, run this function"). This is called Inversion of Control.

Frameworks: Express.js, Django, Ruby on Rails, Next.js, Angular.

Libraries: Lodash, Axios, React, jQuery.

Hello World

general

A very simple program whose sole purpose is to display the phrase "Hello, World."
It’s traditionally the first program people write when learning a new programming language.

High-level Programming Language

general

A programming language designed to be easy for humans to read and write.
It uses words, symbols, and concepts closer to everyday thinking.

Examples include:

Python
JavaScript
Java

High-level languages hide most hardware and memory details so you can focus on solving problems instead of managing how the computer works internally.

IDE (Integrated Development Environment)

tools

An IDE is a workbench for programmers.

Instead of just a text editor, it usually includes:

A code editor
A compiler or interpreter
A debugger
Helpful features like auto-completion and syntax highlighting

Everything is bundled together so you can focus on building, not tool setup.

Inversion of Control

principles

A design principle where the framework controls the flow, not your code.

Normally, your code is in charge — it decides what to call and when. With inversion of control, you hand over that responsibility to a Framework.

You write small pieces of code, and the framework decides when to run them.

Example: In Express.js, you don't manually check every incoming request. You just say "when someone visits /home, run this function" — and the framework handles the rest.

KISS (Keep It Simple, Stupid)

principles

A programming principle that reminds you to keep your code as simple as possible.

When there are multiple ways to solve a problem, KISS encourages choosing the easiest solution that works, instead of adding unnecessary complexity for hypothetical future needs.

Related principles: DRY (Don't Repeat Yourself), YAGNI (You Aren’t Gonna Need It)

Language Server Protocol (LSP)

tools

A way for a code editor and a programming language to communicate.

It’s a small helper program that the editor starts when you open a file.
Through this communication, the editor can provide:

Error messages
Autocomplete suggestions
Go-to-definition
Type information

LSP makes advanced editor features work consistently across different editors.

Layout Shift

frontend

When elements on a webpage unexpectedly move after the page has already loaded.

Examples:

An image loads late and pushes text downward
A temporary font is replaced by the real font, changing text size

Layout shifts are bad for usability because users may click the wrong thing.

Mock

testing

A fake version of a function or object used during testing.

Mocks let you:

Control return values
Prevent side effects (like network or database calls)
Test code in isolation

They make tests faster, more reliable, and predictable.

Namespace

general

A label used to organize and separate code, preventing name conflicts.

Think of namespaces like labeled piggy banks:
even if they all contain coins, the labels keep them from being mixed up.

Namespaces allow things with the same name to exist safely in different contexts.

Occam's Razor

principles

A problem-solving principle that says:

If there are multiple possible explanations, the simplest one is usually correct.

In programming, this often helps when debugging — the most obvious cause is often the real one.

PATH

tools

A list of directories your computer checks, in order, to find a program you want to run.

On Unix-like systems, you can view it with: echo $PATH . This will show a long string of folder paths separated by :. Each folder is a place your system searches when you type a command.

QA Testing (Quality Assurance)

testing

A process that checks whether a feature or bug fix was implemented correctly.

QA testing can be done by:

Dedicated QA engineers
Developers testing their own code before review

The goal is to ensure correctness, stability, and usability.

Refactoring

general

Improving your code without changing what it does.

You're not adding features or fixing bugs — you're making the code cleaner, easier to read, or more efficient.

Examples:

Renaming a variable from x to userName
Breaking a long function into smaller ones
Removing duplicate code

Good refactoring makes future changes easier and reduces bugs.

Runtime

general

The moment when your program is alive and executing.

At runtime:

Memory is allocated
Variables hold values
Functions are called
Results are produced

The runtime environment includes everything needed to run the program, such as the engine, memory, and system tools (e.g. Node.js or the browser).

Shell

tools

The program that interprets and executes your commands. It runs inside a Terminal.

When you type ls or cd folder, the shell reads it, figures out what to do, and makes it happen.

Examples: Bash, Zsh, PowerShell, Fish.

Spy

testing

A testing tool used to observe a function without changing its behavior.

Spies allow you to check:

Whether a function was called
How many times it was called
Which arguments were used

Unlike mocks, spies do not replace the original function.

SSH

tools

A way to securely connect to another computer over a network using the CLI (Command Line Interface).

SSH (Secure SHell) lets you log into a remote machine and run commands on it as if you were sitting right in front of it — but everything you send and receive is encrypted.

Common uses:

Managing a web server
Deploying code to a remote machine
Securely transferring files

Example: ssh [email protected] connects you to a remote computer at that address.

Terminal

tools

The window application where you type commands. It displays text and sends your input to a Shell.

Think of it as the screen — it shows what's happening but doesn't do the actual work.

Examples: iTerm2, Windows Terminal, GNOME Terminal.

Terminal vs Shell vs CLI:

Terminal — the window (where you see text)
Shell — the program that runs your commands
CLI (Command Line Interface) — the concept of typing commands instead of clicking

Transpiler

tools

A special kind of Compiler that translates code from one high-level language to another.

Instead of compiling down to machine code, a transpiler compiles sideways.

Example:

TypeScript → JavaScript

YAGNI (You Aren't Gonna Need It)

principles

A programming principle that says:

Don't add code or features until you actually need them.

Build only what is required right now — not what you might need later.