IT Term Dictionary

A contract for one program to exchange data with another.

A secret string that authorizes use of an API.

A packaged bundle of developer tools.

The most common format for exchanging data.

The protocol browsers and servers use to exchange requests and responses.

Command-line tools driven by typed commands.

A tool that records and manages changes to code.

Where a project's code lives.

Saving a batch of changes as one recorded unit.

Submitting your changes for someone else's review.

A defect where behavior differs from what was intended.

Finding and fixing the cause of a problem.

A procedure that verifies behavior matches expectations.

A standardized test used to compare performance.

A model confidently producing plausible but false content.

A large language model trained on massive text.

An AI that performs multi-step tasks toward a goal.

Letting a model call external program functions.

A defined format for a model to request functions.

The instruction text sent to a model.

Instructions applied before the whole conversation.

The maximum amount of text a model can read at once.

The smallest unit a model processes text in.

Reusing previously processed prefixes to cut cost.

The stage where a trained model produces output.

An AI model run on your own machine.

Additional training of an existing model for a specific purpose.

Retrieval-augmented generation: fetch documents, then answer.

Representing text as a numeric vector.

A store that keeps embeddings and finds similar ones.

A standard protocol for connecting AI to external tools.

An isolated environment where experiments cannot affect the outside.

An AI that interacts through conversation.

A processor that handles many computations at once.

Memory attached to the graphics processor.

Lowering numeric precision to shrink a model.

A computer that handles requests and returns responses.

Putting your code into live service.

An intermediary that forwards requests.

Storing a result to avoid recomputing it.

Time between sending a request and receiving the response.

The system that maps domain names to server addresses.

A network of content copies placed near users.

A device that filters incoming and outgoing traffic.

Software whose source anyone may read and modify.

A legal document defining software usage terms.

The interface a user sees and operates.

Design that reflows to fit the screen size.

A scripting language that runs in the web browser.

An execution record left by the system.

The special memory AI compute uses to run fast.

The unit where a processor actually performs computation.

Each core can work alone, and a single core can also rotate between several threads. More threads let lightweight jobs (opening documents, rendering the interface) run at once. Too many at once, however, makes threads compete for the same resources and slows everything down.

More watts means more electricity drawn and more heat produced. An AI accelerator burns power while computing and dumps the heat as it goes, so power and cooling must be designed together. If the wall unit (the PSU) is undersized, the machine may shut down or fail.

When a model writes a sentence token by token, recomputing earlier text every time wastes work. The KV cache stores those intermediate results and reuses them for the next token. Hits make responses fast; very long conversations eventually exceed the cache budget. This is a different mechanism from prompt caching.

Instead of weighing every word equally, the model links words that belong together. In 'the animal ate the branch', attention captures how 'animal' relates to 'branch'. How strongly those links are computed decides most of natural-language performance.

Weights are numbers expressing how much each connection should count. Training nudges them to shrink the gap between the real answer and the model's mistake, and the tuned numbers themselves become the trained model.

The 3B, 7B, or 70B in a model name is this count. More parameters can hold more patterns and handle complex work, but the file grows and demands more memory and time. A larger model is not automatically the right choice.

Instead of buying hardware, you rent capacity and pay for what you use. The upside is scaling up on demand; the tradeoff is that your data leaves your machine. Work involving sensitive material is often safer locally.

Sensitive material stays local while heavy compute goes to the cloud. This balances security and throughput, but without a clear rule for what runs where, it simply adds complexity.

Two programs exchanging data need an agreed shape in advance. A schema is that contract; data that breaks it triggers errors. The schema attached to an API document tells you exactly what that service accepts and returns.

Save edited code and it is automatically tested, deployed, and verified. That chain of steps is a pipeline. Adding error checks at each stage makes it obvious where something broke.

When several people edit the same repository, their work must eventually be combined. That is a merge: non-overlapping changes join automatically, overlapping ones need a human. Long-lived projects make merges progressively harder.

If two people changed the same lines, the tool cannot decide which version wins and reports a conflict. It shows both versions side by side for you to choose. Leaving conflicts unresolved blocks later work, so they are best cleared immediately.

A copy kept so you can return to an earlier state after a replacement, a mistake, or a failure. A backup stored in the same place can be lost with it, so production systems keep copies across multiple locations and points in time.

Capture the whole state before a large change and you can return to that exact point if something goes wrong. Backups create copies to keep; snapshots create a place to roll back to. Usually only the most recent few are retained.

Packaging a program together with everything it needs to run solves the problem of working on my machine but not yours. Identical results follow everywhere, and containers coexist without interfering.

Many programs run on one machine at once, so each is assigned a number to identify incoming requests; that number is a port. Two programs claiming the same port collide, which is why they are managed deliberately.

Serious actions such as deleting files or moving money are permitted only after identity checks. Granting the minimum necessary scope keeps a mistake or intrusion from spreading. That is why read, write, and execute rights are managed separately.

Search engines send robots that follow links to collect page titles and text. The resulting index powers search results, and each page records where it came from through attribution metadata.