Inglés para Ingeniería de Software: Vocabulario Esencial

"time complexity"

A measure of how the running time of an algorithm scales as the input size grows, expressed using Big O notation such as O(n) or O(log n)

"The interviewer asked the candidate to explain the time complexity of their binary search solution and why it was more efficient than a linear scan."

"space complexity"

A measure of how much additional memory an algorithm requires relative to its input size, important when working with large datasets or memory-constrained environments

"The engineer chose an in-place sorting algorithm to reduce space complexity from O(n) to O(1), avoiding extra memory allocation on the embedded device."

"hash collision"

A situation where two different keys produce the same hash value in a hash table, requiring a collision-resolution strategy such as chaining or open addressing

"A poorly chosen hash function caused frequent hash collisions that degraded the lookup time from O(1) to O(n) under adversarial input."

"memoisation"

An optimisation technique that caches the results of expensive function calls and returns the cached result when the same inputs occur again, commonly used in dynamic programming

"Adding memoisation to the recursive Fibonacci function reduced its time complexity from exponential to linear by storing previously computed values."

"depth-first search"

A graph traversal algorithm that explores as far as possible along each branch before backtracking, implemented using recursion or an explicit stack

"The developer used depth-first search to detect cycles in the dependency graph before executing the build pipeline."

"greedy algorithm"

An algorithmic strategy that makes the locally optimal choice at each step in the hope of finding a global optimum, working well for problems with the greedy-choice property

"A greedy algorithm was sufficient for the interval scheduling problem because picking the task that ends earliest always led to the maximum number of completed tasks."

"amortised cost"

The average cost per operation over a sequence of operations, used when individual operations may be expensive but the overall cost averaged out is low

"Although resizing a dynamic array is O(n), the amortised cost of each append operation remains O(1) because resizing happens exponentially less frequently."

"tail call optimisation"

A compiler or runtime optimisation where a recursive function call in the tail position is transformed into a loop, preventing stack overflow in deeply recursive programs

"The functional language performed tail call optimisation automatically, allowing the developer to write clean recursive algorithms over millions of elements without stack overflow."

"separation of concerns"

A design principle that organises a system so that each component or module handles one distinct responsibility, making the code easier to maintain and test

"The architect enforced separation of concerns by splitting the monolith into distinct layers for data access, business logic, and presentation."

"tight coupling"

A design condition where components depend heavily on each other's internal implementation, making the system harder to change, test, or reuse independently

"The team spent a week refactoring the payment module because tight coupling to the user service meant a simple fee change required modifying six separate classes."

"event-driven architecture"

An architectural style where components communicate by producing and consuming events, enabling loose coupling, scalability, and asynchronous processing

"Switching to an event-driven architecture allowed the order service to notify inventory, billing, and shipping independently without any direct service-to-service calls."

"idempotency"

The property of an operation where performing it multiple times produces the same result as performing it once, critical for safe retries in distributed systems

"The payment API was designed for idempotency using unique request IDs, ensuring that a retried charge request never billed the customer twice."

"circuit breaker"

A resilience pattern that monitors calls to an external service and stops forwarding requests when failures exceed a threshold, preventing cascading failures across a distributed system

"The circuit breaker tripped after the recommendation service exceeded its error threshold, returning cached suggestions instead of propagating timeouts to the homepage."

"single source of truth"

An architectural principle where a piece of data is stored and managed in exactly one place, with all other systems referencing that authoritative source rather than maintaining their own copies

"The team established the user profile service as the single source of truth for account data, removing the duplicated user tables that had caused synchronisation bugs."

"eventual consistency"

A consistency model in distributed systems where replicas will converge to the same value given enough time and no new updates, trading strong consistency for availability and partition tolerance

"The product catalogue used eventual consistency across regions, accepting that users in Tokyo might see slightly stale stock counts in exchange for sub-50ms response times globally."

"hexagonal architecture"

An architectural pattern that isolates the core domain logic from external systems — databases, APIs, UIs — by connecting them through well-defined ports and adapters

"Adopting hexagonal architecture meant the team could swap from PostgreSQL to DynamoDB without touching a single line of business logic."

"blue-green deployment"

A release strategy that maintains two identical production environments — blue and green — and switches live traffic between them to enable zero-downtime deployments and instant rollback

"The blue-green deployment strategy let the team push the new billing engine to the green environment, run smoke tests, then flip the load balancer in under two minutes."

"infrastructure as code"

The practice of managing and provisioning computing infrastructure through machine-readable configuration files rather than manual processes, enabling version control and reproducible environments

"By committing all their AWS resources as infrastructure as code using Terraform, the team could spin up a complete staging environment in fifteen minutes."

"rolling update"

A deployment strategy that gradually replaces old instances of an application with new ones, ensuring the service remains available throughout the update process

"The rolling update replaced one pod at a time across the cluster, so the API stayed live at full capacity while the new version was progressively deployed."

"canary release"

A deployment technique that routes a small percentage of production traffic to a new version, allowing real-world validation before a full rollout

"The canary release sent 5% of users to the new checkout flow, and when error rates stayed flat for 24 hours the team promoted it to 100% of traffic."

"observability"

The degree to which the internal state of a system can be inferred from its external outputs — logs, metrics, and traces — enabling engineers to understand, debug, and improve system behaviour

"Investing in observability with distributed tracing revealed that 80% of API latency came from a single slow database query that had gone unnoticed for months."

"feature flag"

A configuration mechanism that enables or disables features at runtime without deploying new code, allowing controlled rollouts, A/B tests, and instant kill-switches

"The team used a feature flag to gradually enable the new recommendation engine for internal users, then 10% of customers, before removing the flag entirely after a successful rollout."

"mean time to recovery"

A reliability metric measuring the average time taken to restore a system to full operation after a failure, used to assess the effectiveness of incident response processes

"After implementing automated rollbacks, the team reduced their mean time to recovery from 45 minutes to under 5 minutes for the most common class of deployment failures."

"immutable infrastructure"

A deployment philosophy where servers are never modified after deployment — instead, new instances replace old ones for every change, eliminating configuration drift and making environments reproducible

"Immutable infrastructure meant every environment from development to production was built from the same container image, eliminating the "works on my machine" class of bugs."

"rate limiting"

A technique that controls how many requests a client can make to an API within a given time window, protecting services from overload and ensuring fair resource distribution

"After a viral post drove traffic to the public API, rate limiting at 1,000 requests per minute per API key prevented the database from being overwhelmed."

"pagination"

A pattern for dividing large API responses into smaller, sequential pages, typically controlled by cursor-based or offset-based query parameters

"The API used cursor-based pagination instead of offset pagination to ensure consistent results when new records were inserted between page requests."

"optimistic locking"

A concurrency control strategy that allows multiple transactions to proceed without locking resources, checking for conflicts only at commit time using a version number or timestamp

"Optimistic locking with a version field meant two engineers could edit the same document simultaneously, with the second save failing gracefully and prompting a merge."

"backpressure"

A flow-control mechanism in streaming systems where a consumer signals to a producer to slow down, preventing the consumer from being overwhelmed by data it cannot process quickly enough

"Without backpressure, the event streaming pipeline buffered millions of messages in memory during a traffic spike, eventually crashing the consumer service."

"service mesh"

An infrastructure layer that handles service-to-service communication in a microservices architecture, providing traffic management, observability, and security without application-level code changes

"Deploying Istio as a service mesh gave the platform team mutual TLS between every microservice and detailed request tracing without modifying a single application."

"contract testing"

A testing technique where the API contract between a consumer and provider is tested independently for each side, ensuring services can evolve without breaking their integration partners

"Contract testing caught a breaking change in the orders API three days before deployment, saving the team from a production incident that would have affected four downstream services."

"webhook"

A reverse HTTP callback mechanism where a server sends a POST request to a registered URL whenever a specified event occurs, enabling real-time integrations without polling

"Replacing the hourly polling job with webhooks reduced integration latency from up to 60 minutes to under two seconds and cut API call volume by 99%."

"graceful degradation"

A design principle where a system continues to operate with reduced functionality when a dependency fails, rather than failing entirely, improving overall resilience

"When the recommendation engine went down, the homepage gracefully degraded to show the most popular items globally instead of returning an error to every user."

"test coverage"

A metric expressing the percentage of source code lines, branches, or paths that are exercised by the automated test suite, used as a proxy for test thoroughness

"The CI pipeline blocked merges below 80% test coverage, though the tech lead reminded the team that high coverage did not guarantee the tests were actually meaningful."

"mock object"

A simulated object that replaces a real dependency in tests, programmed to return predefined responses, enabling unit tests to run in isolation without calling real services or databases

"The developer used a mock object for the payment gateway so the checkout tests ran in milliseconds and never triggered real charges during development."

"flaky test"

An automated test that produces inconsistent results — passing sometimes and failing at other times — without any change to the code, eroding developer trust in the test suite

"Three flaky tests in the end-to-end suite were causing developers to re-run pipelines automatically and ignore failures, masking real regressions in the process."

"test pyramid"

A testing strategy model that advocates writing many fast unit tests, fewer integration tests, and even fewer slow end-to-end tests to balance coverage speed, and maintenance cost

"The engineering lead used the test pyramid to argue that the team should write 20 unit tests for every one end-to-end test, reversing the existing slow and expensive test suite."

"cyclomatic complexity"

A software metric that quantifies the number of independent execution paths through a function, where high values indicate code that is difficult to test and understand

"The static analysis tool flagged a billing function with cyclomatic complexity of 34, prompting an immediate refactoring before the code was merged to main."

"snapshot testing"

A testing technique that captures the rendered output of a component or function at a point in time and fails future test runs if the output has changed unexpectedly

"Snapshot testing caught an unintentional change to the email template layout when a shared CSS refactor altered font sizes across thirty components."

"property-based testing"

A testing approach where the test framework generates hundreds of random inputs to verify that a function holds a given property for all valid inputs, rather than only the examples the developer thought to test

"Property-based testing revealed an integer overflow edge case in the discount calculation that hand-written example tests had never reached in three years of production."

"code smell"

A surface-level indicator in source code that suggests a deeper design problem, such as excessively long methods, duplicated logic, or feature envy between classes

"The reviewer flagged three code smells in the pull request — a 200-line method, copy-pasted validation logic, and a class that accessed another class's internal state directly."

"sprint velocity"

A measure of the amount of work a development team completes during a sprint, expressed in story points, used to forecast future capacity and plan upcoming sprints

"After three stable sprints with a velocity of 42 points, the product manager could confidently plan the quarterly roadmap based on realistic delivery forecasts."

"technical debt"

The accumulated cost of shortcuts, quick fixes, and deferred refactoring in a codebase, which increases maintenance burden and slows future development if left unaddressed

"The team allocated 20% of every sprint to reducing technical debt, recognising that every deferred fix was compounding interest on future feature delivery time."

"definition of done"

A shared checklist of criteria that must be satisfied before a user story or task is considered complete — typically including code review, tests passing, documentation, and deployment to staging

"The retrospective revealed that ambiguous acceptance criteria were causing rework, so the team tightened the definition of done to require explicit test cases for every story."

"pair programming"

A practice where two developers work together at one workstation — one writing code while the other reviews in real time — improving code quality and knowledge transfer

"The new hire pair programmed with a senior engineer for their first two weeks, absorbing codebase knowledge and team conventions far faster than code reading alone."

"spike"

A time-boxed research or exploration task used to investigate an uncertain technical problem before committing to a full implementation, reducing the risk of planning with incomplete information

"The team ran a two-day spike to evaluate three caching strategies before writing a single line of production code, avoiding a costly architecture decision based on assumptions."

"bus factor"

The minimum number of team members who would need to be suddenly unavailable — hit by a bus — before a project would be in serious jeopardy due to concentrated knowledge

"The architect flagged a bus factor of one on the authentication module, since only a single engineer understood the legacy token generation logic well enough to maintain it."

"rubber duck debugging"

A debugging technique where a programmer explains their code line by line to an inanimate object — originally a rubber duck — forcing them to articulate the logic and often revealing the bug in the process

"The developer solved a two-hour bug in five minutes through rubber duck debugging — the moment she explained her loop invariant aloud, the off-by-one error became obvious."

"bikeshedding"

The tendency for teams to spend disproportionate time debating trivial, easy-to-understand decisions while neglecting complex but more important ones, named after Parkinson's law of triviality

"The code review descended into bikeshedding over variable naming conventions while the architectural issue with the database schema went unmentioned for forty minutes."