General IT Concepts

From time to time, I come across new words and concepts whose meanings I’m uncertain about. Therefore, I’ve created a concise glossary with simple definitions to aid in gaining insights into these terms. I hope this helps you.

A

ACID

Properties that guarantee reliable database transactions:

Atomicity: All operations complete or none do
Consistency: Data moves from one valid state to another
Isolation: Concurrent transactions don’t interfere
Durability: Committed data survives system failures

Actor Model

A concurrency model where “actors” are independent units that communicate only through messages. No shared state. Each actor has a mailbox and processes messages one at a time. Popular in Erlang, Akka, and Swift’s modern concurrency.

Algebraic Data Types (ADTs)

Types formed by combining other types:

Product Types: Combine types with “AND” (structs, tuples, records)
Sum Types: Combine types with “OR” (enums, tagged unions)

Applicative Functor

A functor that also supports applying wrapped functions to wrapped values. Useful when you have a function and its arguments all wrapped in some context (like Optional or Result).

Application Framework

An application framework is like a toolbox of ready-to-use software tools that help you build an app without having to write everything from scratch. It’s like having building blocks for your app.

Examples include:

React Native: For building mobile apps for iOS and Android
Ruby on Rails: For creating web applications
Spring Framework: For Java-based enterprise applications

Atomic Operation

An operation that completes entirely or not at all, with no possibility of interruption. Other threads see either the before or after state, never an intermediate state.

B

BASE

Alternative to ACID for distributed systems:

Basically Available: System responds to requests
Soft State: State may change without input
Eventually Consistent: System becomes consistent over time

Big O Notation

Describes algorithm efficiency as input grows:

O(1): Constant - same time regardless of size
O(log n): Logarithmic - halving with each step
O(n): Linear - proportional to input
O(n log n): Linearithmic - common in good sorting
O(n²): Quadratic - nested iterations
O(2ⁿ): Exponential - doubles with each addition

Blue-Green Deployment

Running two identical production environments. Traffic switches between them for zero-downtime deployments and easy rollbacks.

C

Caching

Storing computed results or frequently accessed data for faster retrieval. The hard part is knowing when to invalidate.

“There are only two hard things in Computer Science: cache invalidation and naming things.”

Canary Deployment

Rolling out changes to a small subset of users first. If problems occur, only a small percentage is affected.

CAP Theorem

Distributed systems can have at most two of three properties:

Consistency: All nodes see the same data
Availability: Every request gets a response
Partition Tolerance: System works despite network failures

Since network partitions are inevitable, you’re choosing between C and A during failures.

Circuit Breaker

Pattern that prevents cascading failures. If a service fails repeatedly, stop calling it temporarily and fail fast instead.

Closure

A function that captures variables from its enclosing scope, “closing over” them. The captured variables remain accessible even after the outer function returns.

Compare-and-Swap (CAS)

Atomic operation: compare a memory location to an expected value and, if equal, swap it with a new value. Foundation of lock-free programming.

Composition over Inheritance

Prefer building complex behavior by combining simpler objects rather than through class hierarchies. More flexible and avoids tight coupling.

Concurrency vs Parallelism

Concurrency: Dealing with multiple things at once (structure)
Parallelism: Doing multiple things at once (execution)

A single-core machine can be concurrent but not parallel.

Container

Lightweight, isolated environment that packages code and dependencies. Shares the host OS kernel but has isolated processes, networking, and filesystem.

Copy-on-Write

Sharing data until modification, then copying. Efficient for mostly-read data. Used in Swift’s value types.

Browser security feature controlling cross-origin HTTP requests. Server specifies which origins can access resources.

CQRS (Command Query Responsibility Segregation)

Separating read and write operations into different models. Useful when read and write patterns differ significantly.

Critical Section

Code that accesses shared resources and must not be executed by more than one thread at a time.

CSRF (Cross-Site Request Forgery)

Attack that tricks users into making unwanted requests to sites where they’re authenticated. Mitigated with tokens.

Currying

Transforming a function with multiple arguments into a sequence of single-argument functions.

// Uncurried
add(2, 3) → 5

// Curried
add(2)(3) → 5

D

Data Race

Two or more threads access the same memory location concurrently, at least one is a write, and there’s no synchronization. A specific type of race condition.

Deadlock

Two or more processes waiting for each other to release resources, creating a circular dependency where none can proceed.

Four conditions (Coffman conditions):

Mutual Exclusion
Hold and Wait
No Preemption
Circular Wait

Denormalization

Intentionally adding redundancy in database design for read performance. Trade storage and write complexity for faster reads.

Dependency Injection

Providing dependencies from outside rather than creating them internally. Enables testing and reduces coupling.

Dependent Types

Types that depend on values. Enables expressing invariants in the type system (e.g., “a list of exactly 5 elements”).

DRY (Don’t Repeat Yourself)

Every piece of knowledge should have a single, unambiguous representation. But beware: duplication is often better than the wrong abstraction.

E

Eventual Consistency

Data becomes consistent across all nodes given enough time without new updates. Trade-off for availability in distributed systems.

Event Sourcing

Storing state as a sequence of events rather than current state. Enables audit logs, time travel, and rebuilding state.

F

Fallacies of Distributed Computing

False assumptions that cause problems:

The network is reliable
Latency is zero
Bandwidth is infinite
The network is secure
Topology doesn’t change
There is one administrator
Transport cost is zero
The network is homogeneous

Feature Flag

Toggle that controls feature availability at runtime. Enables gradual rollouts, A/B testing, and kill switches.

First-Class Functions

Functions treated as values: stored in variables, passed as arguments, returned from other functions.

Functor

A type that implements map - something you can map over. Wraps a value and lets you transform the inner value while keeping the wrapper.

Laws:

Identity: map(id) == id
Composition: map(f ∘ g) == map(f) ∘ map(g)

Examples: Lists, Optional, Trees, Futures

Fuzzing

Testing by feeding random or malformed input to find crashes and vulnerabilities.

G

Garbage Collection

Automatic memory management that finds and frees unreachable objects.

Strategies:

Reference counting
Mark-and-sweep
Generational collection

Generics / Parametric Polymorphism

Writing code that works with any type, specified as a type parameter.

GraphQL

Query language for APIs where clients request exactly the data they need. Single endpoint, strongly typed schema.

gRPC

High-performance RPC framework using Protocol Buffers. Strong typing, bidirectional streaming, efficient binary format.

H

HATEOAS

Hypermedia as the Engine of Application State. REST principle where responses include links to related actions.

Heap vs Stack

Stack: Fast, automatic, limited size, LIFO order
Heap: Slower, manually managed, larger, flexible allocation

Higher-Order Functions

Functions that take other functions as arguments or return functions as results. Examples: map, filter, reduce.

I

Idempotency

An operation that produces the same result whether executed once or multiple times. Crucial for retry logic.

Immutability

Data that cannot be changed after creation. Instead of modifying, you create new data with the changes.

Benefits: Thread safety, easier reasoning, no unexpected mutations, enables sharing.

Infrastructure as Code (IaC)

Managing infrastructure through code rather than manual processes. Version controlled, reproducible, testable.

Inversion of Control (IoC)

Inverting the flow of control: instead of your code calling library code, the framework calls your code.

J

JWT (JSON Web Token)

Compact, self-contained token for transmitting claims. Signed for integrity, optionally encrypted for confidentiality.

K

KISS (Keep It Simple, Stupid)

Simplicity should be a key goal. Avoid unnecessary complexity.

L

Law of Demeter

“Only talk to your immediate friends.” A method should only call methods on its own object, parameters, objects it creates, or direct components.

Lazy Evaluation

Delaying computation until the result is actually needed. Enables infinite data structures and can avoid unnecessary work.

Leader Election

Choosing a coordinator among distributed nodes when tasks require centralized coordination.

Livelock

Similar to deadlock, but processes continuously change state in response to each other without making progress. Like two people in a hallway repeatedly stepping aside in the same direction.

Load Balancer

Distributes incoming traffic across multiple servers. Improves availability and responsiveness.

Lock-Free vs Wait-Free

Lock-Free: Guarantees system-wide progress (at least one thread advances)
Wait-Free: Guarantees per-thread progress (every thread advances)

M

Memoization

Caching function results based on inputs. Return cached result when called again with the same arguments.

Memory Leak

Memory allocated but never freed and no longer reachable. Causes gradual resource exhaustion.

Microservices

Application as a collection of small, independent services. Each runs in its own process, communicates via lightweight protocols.

Monad

Design pattern for composing functions that return wrapped values.

Common monads:

Maybe/Optional: Might not return a value
Either/Result: Might fail with an error
List: Multiple possible results
IO: Side effects
Future/Promise: Async computations

Monad Laws:

Left identity: return a >>= f equals f a
Right identity: m >>= return equals m
Associativity: (m >>= f) >>= g equals m >>= (λx → f x >>= g)

Mutex (Mutual Exclusion)

Synchronization primitive ensuring only one thread accesses a resource at a time. Like a key to a single-occupancy room.

N

N+1 Query Problem

Making N additional database queries after an initial query, usually from naive ORM usage. Solved with eager loading or joins.

Normalization

Organizing database data to reduce redundancy. Normal forms (1NF, 2NF, 3NF, etc.) define increasingly strict rules.

O

OAuth 2.0

Authorization framework letting applications access resources on behalf of users without sharing credentials.

Observability

Understanding system state through outputs:

Metrics: Numerical measurements over time
Logs: Discrete events
Traces: Request paths through distributed systems

P

Partial Application

Creating a new function by fixing some arguments of an existing function.

Pattern Matching

Checking a value against patterns and extracting components. More powerful than switch statements.

Phantom Types

Type parameters that don’t appear in the runtime representation but provide compile-time safety.

Premature Optimization

Optimizing before knowing where the real bottlenecks are. Usually wastes time and adds complexity.

“Premature optimization is the root of all evil.” — Donald Knuth

Property-Based Testing

Specifying properties that should hold for all inputs, then generating random test cases.

Protocol (Computing)

A set of rules for communication. Defines message format, order, and actions on transmission/receipt.

Pure Function

A function that:

Given the same input, always returns the same output
Has no side effects

R

Race Condition

Behavior depends on the relative timing of events, such as thread execution order. The system races to see which operation happens first.

Railway-Oriented Programming

Metaphor for error handling with Result types: data travels on tracks (success or failure), functions are switches that can change tracks.

Rate Limiting

Restricting request frequency to prevent abuse and ensure fair usage.

Reference Counting

Memory management by tracking references to objects. Free when count reaches zero. Challenge: circular references.

Referential Transparency

An expression can be replaced with its value without changing program behavior.

Replication

Copying data across multiple nodes. Improves read performance and availability.

REST

Architectural style using HTTP methods for CRUD operations on resources. Stateless, cacheable, uniform interface.

Reverse Proxy

Sits in front of servers, forwarding requests. Handles SSL termination, caching, compression, load balancing.

S

Saga Pattern

Managing distributed transactions through a sequence of local transactions with compensating actions for rollback.

Semaphore

Like a mutex, but allows a specified number of threads to access a resource. Like a parking lot with N spaces.

Serverless / FaaS

Functions deployed and managed by cloud provider. You write functions; provider handles scaling and infrastructure.

Service Mesh

Infrastructure layer handling service-to-service communication. Provides observability, traffic management, security.

Sharding

Splitting data across multiple databases. Enables horizontal scaling but adds complexity.

Side Effect

Any observable change outside a function’s scope: modifying variables, writing to disk, network requests.

SLA, SLO, SLI

SLI (Service Level Indicator): Measurement (e.g., latency)
SLO (Service Level Objective): Target (e.g., 99% requests < 200ms)
SLA (Service Level Agreement): Contract with consequences

SOLID Principles

Single Responsibility: One reason to change
Open/Closed: Open for extension, closed for modification
Liskov Substitution: Subtypes substitutable for base types
Interface Segregation: Many specific interfaces over one general
Dependency Inversion: Depend on abstractions, not concretions

SQL Injection

Inserting malicious SQL through user input. Mitigated with parameterized queries.

Starvation

A process perpetually denied resources because others are continuously given priority.

Static vs Dynamic Typing

Static: Types checked at compile time
Dynamic: Types checked at runtime

Strong vs Weak Typing

Strong: Little implicit type conversion
Weak: More implicit conversions allowed

Structural vs Nominal Typing

Nominal: Types compatible if they have the same name
Structural: Types compatible if they have the same structure

T

TCP vs UDP

TCP: Reliable, ordered, connection-oriented
UDP: Fast, unreliable, connectionless

TDD (Test-Driven Development)

Write tests before implementation:

Write a failing test
Write minimal code to pass
Refactor

Test Pyramid

More unit tests (fast, cheap), fewer integration tests, even fewer E2E tests (slow, expensive).

Transaction Isolation Levels

Control visibility of uncommitted changes:

Read Uncommitted: See uncommitted changes (dirty reads)
Read Committed: Only see committed changes
Repeatable Read: Consistent reads within transaction
Serializable: Full isolation

Two-Phase Commit (2PC)

Protocol for atomic commits across distributed nodes:

Prepare: All nodes agree to commit
Commit: Coordinator tells all nodes to commit

Type Inference

Compiler automatically deduces types without explicit annotations.

U

Unsafe Raw Pointer

An UnsafeRawPointer in Swift is a pointer that can access any memory location, regardless of its type or mutability. It provides no automatic memory management, no type safety, and no alignment guarantees.

You are responsible for handling the life cycle of any memory you work with through unsafe pointers, to avoid leaks or undefined behavior.

V

Variance

How subtyping of containers relates to their contents:

Covariant: List<Dog> is subtype of List<Animal> (output positions)
Contravariant: Opposite relationship (input positions)
Invariant: No subtyping relationship

Vector Clocks

Tracking causality in distributed systems. Each node maintains a vector of logical timestamps to determine event ordering.

W

WebSocket

Full-duplex communication channel over a single TCP connection. For real-time applications like chat and gaming.

X

XSS (Cross-Site Scripting)

Injecting malicious scripts into web pages viewed by others. Mitigated by escaping output.

Y

YAGNI (You Aren’t Gonna Need It)

Don’t add functionality until it’s actually needed. Avoid speculative generality.

This glossary is a living document. More concepts will be added over time.

A