Tag: Software
67 items found
Glossary Terms
Agile
Agile develops products in short cycles, uses feedback to adjust direction, and treats planning as a living part of software delivery.
API (Application Programming Interface)
An API is a contract that lets software systems request approved data or actions from one another through documented endpoints.
API Integration
API integration connects separate software systems so they can exchange data securely and keep workflows automated.
Asynchronous Programming
Asynchronous programming keeps applications responsive by running network, file, and other waiting work without blocking execution.
BDD (Behavior-Driven Development)
BDD describes expected behavior with Given-When-Then scenarios, creating a shared language between business and technical teams.
Binary Search
Binary search finds a target in sorted data by halving the range each step, aiming for O(log n) lookup time on sorted collections.
Clean Code
Clean Code is a way of writing software that makes intent clear, keeps units small, and reduces the cost of future change.
Code Coverage
Code coverage shows which lines, branches, or functions automated tests executed, helping reveal untested parts of a codebase.
Code Review
Code review checks code changes before merge so teams catch logic errors, security gaps, and maintainability issues early.
Concurrency
Concurrency structures software so several tasks make progress in the same time window, using wait time instead of blocking work.
CQRS (Command Query Responsibility Segregation)
CQRS separates commands from queries so write models and read models can be designed, scaled, and secured for different needs.
DDD (Domain-Driven Design)
DDD models complex business domains through domain language, bounded contexts, and software structures aligned with real rules.
Dependency Injection
Dependency injection lets a class receive the dependencies it needs from the outside instead of constructing them itself.
Dependency Management
Dependency management controls package versions, licenses, compatibility, and security updates across a software project.
Deque (Double-Ended Queue)
A deque is a double-ended queue that allows efficient insertion and removal at both the front and back of a collection.
Design Pattern
A design pattern describes a proven approach to recurring software design problems, independent of a specific language or framework.
End-to-End Test
An end-to-end test validates a user journey across the UI, API, database, and integrations in a flow close to real usage.
Environment Management (Dev/Staging/Prod)
Environment management separates development, testing, staging, and production settings, data, secrets, and release versions.
Event Sourcing
Event sourcing stores application state as ordered, immutable records of changes rather than only keeping the latest value.
Factory Pattern
The Factory pattern moves object creation decisions into a producer component so client code stays independent of concrete classes.
Feature Branch
A feature branch keeps new work in a separate Git branch, making experiments, reviews, and merges easier to control.
Git
Git is distributed version control that tracks code changes through commits and lets teams work in parallel with branching and merging.
GitFlow
GitFlow is a Git workflow that assigns separate roles to main, develop, feature, release, and hotfix branches for controlled releases.
GitHub
GitHub hosts Git repositories and brings software teams together with pull requests, issues, packages, security features, and automation.
Hash Table
A hash table is a data structure that maps keys into buckets with a hash function for fast lookup, insert, and delete.
Hotfix
A hotfix is a small urgent patch released to fix a critical production issue without waiting for the normal release cycle.
Integration Test
Integration testing verifies the expected data flow when multiple modules, services, or external systems work together.
Jest
Jest is a popular testing framework developed by Facebook for JavaScript and TypeScript, known for its ease of use.
Kanban
Kanban is a methodology for tracking work through visual board columns (To Do, In Progress, Done) and optimizing flow with WIP limits.
Kibana
Kibana is the visual component of the ELK Stack for visualizing and analyzing log and metric data stored in Elasticsearch.
Linting
Linting is the practice of automatically analyzing source code to flag programmatic and stylistic errors using tools like ESLint and Prettier.
Load Testing
Load testing is a performance test type that measures system stability and performance under high user traffic.
Logging
Logging is the practice of recording runtime events from applications and systems — critical for debugging and monitoring.
Merge Request / Pull Request
A merge request asks teammates to review, discuss, and approve branch changes before they are merged into a main code line.
Monitoring
Monitoring tracks application and infrastructure metrics, logs, and alerts to detect problems before users or SLAs are affected.
Monolith
A monolith packages the user interface, business logic, and data access layers in one codebase and one deployable unit.
Monorepo
A monorepo keeps multiple apps and packages in one Git repository so tooling, dependencies, and changes can be managed together.
MVC (Model-View-Controller)
MVC separates application code into Model, View, and Controller layers so data, interface, and request flow responsibilities stay clear.
Nx
Nx manages projects inside a monorepo with a dependency graph, task targets, and caching to reduce build and test times in large codebases.
Observability
Observability is the ability to understand a system's internal state from its external outputs (logs, metrics, traces) — a key DevOps principle.
Observer Pattern
The Observer pattern automatically notifies all attached observers when an object's state changes — an event-driven design pattern.
OpenTelemetry
OpenTelemetry is an open-source framework for collecting logs, metrics, and traces in a standard format for application observability.
Pair Programming
Pair programming is an Agile practice where two developers work on the same code simultaneously — one writes, the other reviews.
Playwright
Playwright is an open-source browser automation tool for testing web user flows across Chromium, Firefox, and WebKit with repeatable scripts.
Product Backlog
A backlog is a living list of pending product features, bugs, and technical work, ordered by priority, value, and readiness.
Refactoring
Refactoring improves the internal structure, readability, and maintainability of working software without changing what users experience.
Repository Pattern
The Repository pattern hides data source details behind a consistent interface so business code can read and write data without knowing storage details.
Rollback
A rollback restores a system to a previous known-good state after a faulty deployment, configuration change, or data operation.
SaaS (Software as a Service)
SaaS delivers software by subscription through a browser or app, with hosting, updates, and operations handled by the provider.
Saga Pattern
The Saga pattern splits a distributed business transaction into steps and uses compensating actions to preserve consistency when a step fails.
Scrum
Scrum is an Agile framework for managing product work through short sprints, clear roles, a visible backlog, and regular feedback loops.
Semantic Versioning (SemVer)
Semantic Versioning uses MAJOR.MINOR.PATCH numbers to distinguish breaking changes, backward-compatible features, and bug fixes.
Sentry
Sentry groups application errors with stack traces, releases, environments, and user impact so teams can monitor production issues.
Shift Left Testing
Shift left testing moves automated checks into requirements, design, and coding stages so defects are found before production.
Singleton Pattern
The Singleton pattern ensures a class has one application-wide instance, centralizing access to shared resources or configuration.
SOLID Principles
SOLID is a set of five object-oriented design principles for making classes easier to understand, test, and adapt to change.
Sprint
A Sprint is a short, time-boxed Scrum cycle where a team plans, builds, and delivers work toward a specific product goal.
Static Code Analysis
Static code analysis reviews source code without running the application, catching bugs, security flaws, and quality issues early.
Strangler Fig Pattern
The Strangler Fig pattern replaces parts of an old monolith with new services step by step, spreading modernization risk.
TDD (Test-Driven Development)
TDD is a development practice where a failing test is written first, then the smallest passing implementation shapes the design.
Technical Debt
Technical debt is deferred design, testing, or architecture work that accumulates as maintenance risk after short-term delivery choices.
Technical Documentation
Technical documentation explains how software is installed, used, operated, and changed so teams can work without relying on memory.
Test Automation
Test automation runs selected test scenarios repeatedly with tools and sends the results into CI pipelines or reporting systems.
Turborepo
Turborepo reduces monorepo build time by running tasks from a dependency graph with local or remote caching and parallel execution.
Unit Test
A unit test verifies a small code unit such as a function or class quickly and automatically while isolating external dependencies.
User Story
A user story is a short product requirement that explains who needs a feature, what they need, and why it matters.
Webhook
A webhook lets one system automatically send an HTTP request to another when an event occurs, so updates arrive without polling.