Glossary for Beginners

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.

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.

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:

1. Machine code (0s and 1s your CPU understands), or
2. 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.

The process of finding and fixing Bugs in your code.

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)

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.

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.

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.

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)

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.

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.

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.

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.

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.

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.

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.

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).

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.

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

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.