IT Glossary & Dictionary

A software development methodology that emphasizes iterative development, collaboration, and rapid response to change.

A step-by-step procedure for solving a problem or performing a computation, defined as a finite sequence of instructions.

The practice of designing application programming interfaces that are consistent, intuitive, and maintainable for developers to consume.

A mathematical notation that describes the worst-case performance of an algorithm as input size grows.

An efficient search algorithm that finds a target value in a sorted array by repeatedly dividing the search interval in half.

Code that is easy to read, understand, and maintain — following consistent conventions, meaningful naming, and single-responsibility functions.

A function that captures and retains access to variables from its enclosing scope, even after that scope has finished executing.

A surface indication in code that usually corresponds to a deeper problem in the system, suggesting the need for refactoring.

A design principle favoring object composition (has-a relationships) over class inheritance (is-a relationships) for code reuse.

The ability of a program to manage multiple tasks that can make progress during overlapping time periods.

A way of organizing and storing data in a computer so it can be accessed and modified efficiently.

The process of finding and fixing errors (bugs) in software code to ensure correct program behavior.

A design pattern where objects receive their dependencies from external sources rather than creating them internally.

A reusable solution template for commonly occurring problems in software design.

A software development principle that aims to reduce code duplication by abstracting common patterns into reusable components.

A software design pattern where components communicate by producing and consuming events rather than direct method calls.

A creational design pattern that provides an interface for creating objects without specifying their exact classes.

A programming paradigm that treats computation as the evaluation of mathematical functions, avoiding state changes and mutable data.

An automatic memory management process that identifies and reclaims memory no longer in use by a program.

A data structure that maps keys to values using a hash function, providing average O(1) time complexity for lookups, insertions, and deletions.

An object whose state cannot be modified after creation, providing thread safety and predictable behavior in concurrent systems.

A linear data structure where elements are stored in nodes, each containing data and a pointer to the next node in the sequence.

An optimization technique that caches function results for given inputs, avoiding redundant computations for repeated calls.

A programming paradigm that organizes software design around objects containing data and behavior.

A design pattern where an object (subject) maintains a list of dependents (observers) that are notified automatically of state changes.

A data structure that follows First-In-First-Out (FIFO) ordering, where elements are added at the rear and removed from the front.

A bug that occurs when the behavior of software depends on the timing or order of uncontrolled events like thread scheduling.

A programming technique where a function calls itself to solve a problem by breaking it into smaller subproblems.

Restructuring existing code without changing its external behavior to improve readability, maintainability, and performance.

A sequence of characters that defines a search pattern, used for string matching, validation, and text manipulation.

A design pattern that restricts a class to a single instance and provides a global point of access to that instance.

Five design principles for writing maintainable, flexible object-oriented code: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.

Five object-oriented design principles that guide developers in creating maintainable, flexible, and scalable software systems.

A data structure that follows Last-In-First-Out (LIFO) ordering, where elements are added and removed from the same end (top).

Two memory regions: the stack stores function call data with automatic cleanup, while the heap stores dynamically allocated objects.

The implied cost of additional rework caused by choosing a quick solution now instead of a better approach that would take longer.

The smallest unit of execution within a process, allowing concurrent operations to run within a single program.

A methodology of twelve best practices for building modern, scalable, maintainable software-as-a-service applications.

Testing individual components or functions of a program in isolation to verify they work correctly.

A system that records changes to files over time, allowing you to recall specific versions, collaborate, and track history.