Word of the Day — Full Archive
All 365 curated IT English terms, grouped by domain. Every entry has a plain-English definition, IPA pronunciation, and a real engineering usage example.
Agile & Scrum (26)
- Sprint /sprɪnt/ A fixed-length iteration (usually 1–4 weeks) during which a development team works on a committed set of backlog items.
- Backlog /ˈbæklɒɡ/ An ordered list of all work items waiting to be completed, maintained and prioritised by the Product Owner.
- Velocity /vɪˈlɒsɪti/ The average number of story points a team completes per sprint, used to forecast delivery timelines.
- Retrospective /ˌretrəˈspektɪv/ A meeting at the end of each sprint where the team reflects on what went well, what didn't, and what to improve.
- Epic /ˈepɪk/ A large body of work that can be broken down into smaller stories; represents a high-level business goal or feature.
- Story Points /ˈstɔːri pɔɪnts/ Relative units of effort used to estimate the size and complexity of a user story, not hours.
- Standup /ˈstændʌp/ A short daily team meeting (typically 15 minutes) where each member shares: yesterday's work, today's plan, and any blockers.
- Definition of Done /ˌdefɪˈnɪʃən əv dʌn/ A shared team checklist of criteria a user story must meet before it is considered complete.
- Blocker /ˈblɒkər/ An impediment that prevents a team member from progressing on their work; raised in standup for immediate resolution.
- Spike /spaɪk/ A time-boxed research task to investigate an unknown or technical risk before committing to a full implementation.
- Acceptance Criteria /əkˈseptəns kraɪˈtɪəriə/ Specific conditions a user story must satisfy to be accepted by the Product Owner.
- Burndown Chart /ˈbɜːndaʊn tʃɑːt/ A graph showing remaining work versus time in a sprint; the ideal line slopes downward to zero by sprint end.
- Refinement /rɪˈfaɪnmənt/ A recurring meeting where the team reviews, estimates, and clarifies upcoming backlog items before sprint planning.
- Technical Debt /ˈteknɪkəl det/ The implied cost of shortcuts and suboptimal design decisions taken now that will require rework later.
- Scrum Master /skrʌm ˈmɑːstər/ A facilitator who ensures the team follows Scrum practices, removes impediments, and protects the team from distractions.
- Product Owner /ˈprɒdʌkt ˈəʊnər/ The person responsible for maximising product value by managing and prioritising the product backlog.
- Sprint Review /sprɪnt rɪˈvjuː/ A meeting at the end of the sprint where the team demos completed work to stakeholders and collects feedback.
- WIP Limit /wɪp ˈlɪmɪt/ Work In Progress limit — a constraint on the number of tasks that can be actively worked on simultaneously in Kanban.
- Definition of Ready /ˌdefɪˈnɪʃən əv ˈredi/ Criteria a backlog item must meet before the team agrees to pull it into a sprint.
- Capacity Planning /kəˈpæsɪti ˈplænɪŋ/ Calculating how much work a team can realistically take on in a sprint based on availability and past velocity.
- Increment /ˈɪŋkrɪmənt/ The sum of all completed product backlog items at the end of a sprint; must be usable and potentially shippable.
- Kanban /ˈkænbæn/ A visual workflow management method using a board with columns (To Do, In Progress, Done) to track task flow.
- MVP /em viː piː/ Minimum Viable Product — the smallest version of a product that delivers value to users and enables learning.
- Cycle Time /ˈsaɪkəl taɪm/ The total time from starting work on an item to completing it; a key lean/Kanban metric.
- Lead Time /liːd taɪm/ The total time from a customer request being raised to it being delivered; includes queue time plus cycle time.
- Refactoring /riːˈfæktərɪŋ/ Restructuring existing code to improve its internal quality without changing its external behaviour.
Databases & SQL (25)
- Index /ˈɪndeks/ A database structure that speeds up read queries on a column at the cost of extra storage and slightly slower writes.
- Transaction /trænˈzækʃən/ A unit of work that groups multiple database operations to execute atomically — all succeed or all roll back.
- ACID /ˈæsɪd/ Four properties guaranteeing reliable database transactions: Atomicity, Consistency, Isolation, and Durability.
- N+1 Query /en plʌs wʌn ˈkwɪəri/ A performance anti-pattern where loading N items triggers N additional database queries instead of a single join.
- Sharding /ˈʃɑːdɪŋ/ Horizontally partitioning a database by splitting rows across multiple servers based on a shard key.
- Normalisation /ˌnɔːməlaɪˈzeɪʃən/ Organising database tables to reduce data redundancy and improve integrity by separating related data into distinct tables.
- Migration /maɪˈɡreɪʃən/ A versioned script that applies incremental schema changes to a database in a repeatable, tracked way.
- ORM /əʊ ɑː em/ Object-Relational Mapper — a library that converts between database rows and programming language objects.
- Connection Pool /kəˈnekʃən puːl/ A cache of database connections maintained so applications can reuse them instead of creating a new connection per query.
- Deadlock /ˈdedlɒk/ A state where two transactions each wait for a lock held by the other, causing both to halt indefinitely.
- Query Plan /ˈkwɪəri plæn/ The execution strategy chosen by the database engine showing which indexes and operations it will use for a query.
- Foreign Key /ˈfɒrɪn kiː/ A column that references the primary key of another table, enforcing referential integrity between related data.
- Replication /ˌreplɪˈkeɪʃən/ Copying data from a primary database to one or more replicas to improve read performance and provide failover capability.
- Normalised Data /ˈnɔːməlaɪzd ˈdeɪtə/ Data structured to reduce redundancy by separating into related tables with references, following normal forms.
- Aggregate Function /ˈæɡrɪɡɪt ˈfʌŋkʃən/ A SQL function (COUNT, SUM, AVG, MIN, MAX) performing a calculation on a set of rows, returning a single value.
- Stored Procedure /stɔːd prəˈsiːdʒər/ A pre-compiled SQL script stored in the database that can be called by name to execute a sequence of operations.
- Trigger /ˈtrɪɡər/ A database procedure that runs automatically when a specific event occurs (INSERT, UPDATE, DELETE) on a table.
- View /vjuː/ A stored SQL query that looks like a table — it simplifies complex queries and provides a security layer.
- Inner Join /ˈɪnər dʒɔɪn/ A SQL JOIN returning only rows where the join condition matches in both tables.
- Left Join /left dʒɔɪn/ A SQL JOIN returning all rows from the left table and matching rows from the right — unmatched rows get NULL.
- Denormalisation /ˌdiːˌnɔːməlaɪˈzeɪʃən/ Intentionally introducing redundancy into a database for read performance — trading consistency complexity for query speed.
- Write-Ahead Log /raɪt əˈhed lɒɡ/ A journal (WAL) recording all changes before applying them to data files — enables crash recovery and replication.
- Connection String /kəˈnekʃən strɪŋ/ A formatted string containing database host, port, credentials, and database name to establish a connection.
- Materialised View /məˈtɪəriəlaɪzd vjuː/ A database view whose result is pre-computed and stored, refreshed periodically — faster reads at the cost of staleness.
- Eventual Consistency /ɪˈventʃuəl kənˈsɪstənsi/ A distributed systems model where replicas will converge to the same state given no new updates — consistency is not immediate.
DevOps & Cloud (24)
- Pipeline /ˈpaɪplaɪn/ An automated sequence of steps (build → test → deploy) triggered by a code push to ensure quality and deliver changes.
- CI/CD /siː aɪ siː diː/ Continuous Integration / Continuous Deployment — a practice of automatically building, testing, and releasing code on every change.
- Blue-green Deployment /bluː ɡriːn dɪˈplɔɪmənt/ A release strategy using two identical environments (blue = current, green = new), switching traffic instantly with zero downtime.
- Canary Release /kəˈneəri rɪˈliːs/ A deployment strategy that gradually routes a small percentage of traffic to the new version before a full rollout.
- Feature Flag /ˈfiːtʃər flæɡ/ A configuration toggle that enables or disables a feature at runtime without deploying new code.
- SLO /es el əʊ/ Service Level Objective — an internal reliability target (e.
- Error Budget /ˈerər ˈbʌdʒɪt/ The acceptable amount of downtime or errors permitted by an SLO before the reliability target is breached.
- Observability /əbˌzɜːvəˈbɪlɪti/ The ability to understand a system's internal state from its external outputs: logs, metrics, and distributed traces.
- Runbook /ˈrʌnbʊk/ A documented set of procedures for operating a system, handling incidents, or performing routine operational tasks.
- Postmortem /ˈpəʊstˌmɔːtəm/ A blameless document written after an incident that analyzes root causes and defines action items to prevent recurrence.
- Rollback /ˈrəʊlbæk/ Reverting a deployed application to a previous working version after a failed release.
- On-call /ɒn kɔːl/ A rotation where engineers are reachable 24/7 to respond to production alerts outside business hours.
- Incident /ˈɪnsɪdənt/ An unplanned event that causes disruption to a service, classified by severity from SEV-1 (critical) to SEV-4 (minor).
- IaC /aɪ eɪ siː/ Infrastructure as Code — managing and provisioning infrastructure through machine-readable configuration files instead of manual processes.
- Zero-downtime Deploy /ˈzɪərəʊ ˈdaʊntaɪm dɪˈplɔɪ/ A deployment strategy where new code is released without any interruption in service availability.
- Health Check /helθ tʃek/ An endpoint or script that reports whether a service is running correctly; used by load balancers and orchestrators.
- Container /kənˈteɪnər/ A lightweight, isolated runtime environment that packages an application with all its dependencies.
- Distributed Tracing /dɪˈstrɪbjuːtɪd ˈtreɪsɪŋ/ Tracking a request's journey across multiple services using a unique trace ID, enabling end-to-end performance analysis.
- OpenTelemetry /ˈəʊpən ˌteləˈmetrɪ/ An open standard for collecting telemetry data (traces, metrics, logs) from services with a vendor-neutral SDK.
- Artifact /ˈɑːtɪfækt/ A built output from the CI pipeline — a Docker image, JAR file, or npm package — stored in a registry for deployment.
- SRE /es ɑː iː/ Site Reliability Engineering — applying software engineering to operations to build scalable, reliable systems.
- Toil /tɔɪl/ Manual, repetitive operational work that scales linearly with service growth — SRE aims to automate it away.
- Mean Time to Recovery /miːn taɪm tə rɪˈkʌvəri/ MTTR — the average time from an incident starting to the service being restored, a key reliability metric.
- Rollout Strategy /ˈrəʊlaʊt ˈstrætɪdʒi/ A plan for gradually releasing a new feature or change to users to minimise risk and gather feedback.
Cybersecurity (22)
- Threat Model /θret ˈmɒdəl/ A structured analysis of potential security threats and mitigations for a system, done before building or changing it.
- Attack Surface /əˈtæk ˈsɜːfɪs/ The total number of points where an attacker could try to enter or extract data from a system.
- XSS /eks es es/ Cross-Site Scripting — an injection attack where malicious scripts are injected into pages viewed by other users.
- CSRF /siː es ɑː ef/ Cross-Site Request Forgery — an attack forcing a user's browser to make unintended requests using their active session.
- Zero Trust /ˈzɪərəʊ trʌst/ A security model assuming no user or system is trusted by default — every request must be authenticated and authorised.
- MFA /em ef eɪ/ Multi-Factor Authentication — requiring two or more verification factors (password + OTP, passkey, etc.
- Principle of Least Privilege /ˈprɪnsɪpəl əv liːst ˈprɪvɪlɪdʒ/ A security practice granting users and services only the minimum permissions needed for their specific function.
- CVE /siː viː iː/ Common Vulnerabilities and Exposures — a public list of security vulnerabilities with unique identifiers (CVE-2024-12345).
- SQL Injection /es kjuː el ɪnˈdʒekʃən/ An attack where malicious SQL is inserted into a query via unsanitised user input, allowing data theft or modification.
- Penetration Testing /ˌpenɪˈtreɪʃən ˈtestɪŋ/ An authorised simulated cyberattack to identify and exploit vulnerabilities before real attackers do.
- Encryption /ɪnˈkrɪpʃən/ The process of encoding data so only authorised parties can read it, using symmetric or asymmetric algorithms.
- SIEM /siːm/ Security Information and Event Management — a system collecting and analysing security logs to detect threats in real time.
- OWASP Top 10 /ˈəʊwæsp tɒp ten/ A widely referenced list of the most critical web application security risks, updated periodically by OWASP.
- Social Engineering /ˈsəʊʃəl ˌendʒɪˈnɪərɪŋ/ Manipulating people into divulging information or performing actions that compromise security.
- Authentication vs Authorisation /ɔːˌθentɪˈkeɪʃən vɜːsəs ˌɔːθəraɪˈzeɪʃən/ Authentication proves who you are; authorisation determines what you're allowed to do.
- OAuth2 /ˈəʊɔːθ tuː/ An authorisation framework allowing a third-party app to access a user's resources without exposing credentials.
- IDOR /aɪ diː əʊ ɑː/ Insecure Direct Object Reference — an access control vulnerability where changing an ID parameter accesses another user's data.
- WAF /wæf/ Web Application Firewall — a security layer filtering HTTP traffic to block common attacks like SQLi, XSS, and DDoS.
- Open Redirect /ˈəʊpən rɪˈdaɪrekt/ A vulnerability where a URL parameter controls the redirect destination, allowing phishing attacks via trusted domains.
- SSRF /es es ɑː ef/ Server-Side Request Forgery — attacker makes the server perform requests on their behalf, potentially accessing internal services.
- Path Traversal /pɑːθ trəˈvɜːsəl/ An attack using .
- JWT /dʒɒt/ JSON Web Token — a compact, self-contained token encoding claims as JSON, signed with HMAC or RSA.
Software Architecture (21)
- Coupling /ˈkʌplɪŋ/ The degree to which software components depend on each other — lower coupling means components can change without affecting others.
- Microservices /ˈmaɪkrəʊˈsɜːvɪsɪz/ An architectural style where an application is composed of small, independently deployable services communicating over APIs.
- Circuit Breaker /ˈsɜːkɪt ˈbreɪkər/ A pattern that detects failures in service calls and temporarily stops sending requests to an unhealthy service.
- CQRS /siː kjuː ɑː es/ Command Query Responsibility Segregation — separating write operations (commands) from read operations (queries).
- Event-Driven Architecture /ɪˈvent ˈdrɪvən ˈɑːkɪtektʃər/ A design where services communicate by producing and consuming events through a message broker.
- Domain-Driven Design /dəˈmeɪn ˈdrɪvən dɪˈzaɪn/ A software design approach modelling the system around the real-world business domain and its language.
- CAP Theorem /kæp ˈθɪərəm/ A theorem stating distributed systems can guarantee at most two of three properties: Consistency, Availability, Partition tolerance.
- Strangler Fig Pattern /ˈstræŋɡlər fɪɡ ˈpætən/ A migration pattern where new functionality is built around an existing system, gradually replacing it.
- Bounded Context /ˈbaʊndɪd ˈkɒntekst/ A DDD concept defining the boundary within which a particular domain model is defined and applicable.
- Eventual Consistency /ɪˈventʃuəl kənˈsɪstənsi/ A property where distributed data replicas will become consistent over time in the absence of new updates.
- Race Condition /reɪs kənˈdɪʃən/ A bug where outcome depends on the timing of concurrent operations — the result differs based on which runs first.
- Saga Pattern /ˈsɑːɡə ˈpætən/ A way to manage long-lived transactions across microservices by chaining local transactions with compensating actions on failure.
- Hexagonal Architecture /hekˈsæɡənəl ˈɑːkɪtektʃər/ An architecture (ports and adapters) isolating core business logic from infrastructure concerns like databases and UIs.
- Dead Letter Queue /ded ˈletər kjuː/ A message queue that receives messages which failed processing after the maximum retry limit.
- Dependency Injection /dɪˈpendənsi ɪnˈdʒekʃən/ A design pattern where dependencies are passed in from outside rather than created internally — improves testability and flexibility.
- SOLID /ˈsɒlɪd/ Five design principles for maintainable OOP code: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion.
- Service Mesh /ˈsɜːvɪs meʃ/ Infrastructure layer handling service-to-service communication — providing mTLS, load balancing, and observability without code changes.
- API Gateway /eɪ piː aɪ ˈɡeɪtweɪ/ A server acting as entry point for clients, routing requests to appropriate microservices, handling auth and rate limiting.
- Backpressure /ˈbækpreʃər/ A mechanism for a consumer to signal to a producer to slow down when it cannot process data fast enough.
- Idempotent Consumer /aɪˈdempətənt kənˈsjuːmər/ A message consumer that safely processes the same message multiple times without duplicate side effects.
- Graceful Degradation /ˈɡreɪsfəl ˌdeɡrəˈdeɪʃən/ Designing a system to continue functioning with reduced capability when a dependency fails, rather than failing completely.
Git & Version Control (20)
- Commit /kəˈmɪt/ A snapshot of changes saved to the Git repository with a message describing what was changed and why.
- Branch /brɑːntʃ/ A pointer to a specific commit that lets developers work on features or fixes in isolation from the main codebase.
- Rebase /riːˈbeɪs/ A Git operation that reapplies a series of commits onto a different base commit, resulting in a clean, linear history.
- Cherry-pick /ˈtʃeri pɪk/ A Git command that applies the changes from a specific commit to the current branch without merging the entire branch.
- Stash /stæʃ/ A temporary storage area in Git that saves uncommitted changes so you can switch branches without committing or losing work.
- Squash /skwɒʃ/ Combining multiple commits into a single commit, often done during PR review to clean up a noisy commit history.
- Hotfix /ˈhɒtfɪks/ An urgent fix deployed directly to production to resolve a critical live issue, bypassing the normal release process.
- Pull Request /pʊl rɪˈkwest/ A request to merge code changes from one branch to another, used as the entry point for code review.
- LGTM /el dʒiː tiː em/ "Looks Good To Me" — a code review approval phrase indicating no blocking issues with the pull request.
- Merge Conflict /mɜːdʒ ˈkɒnflɪkt/ A situation where two branches changed the same part of the same file, requiring manual resolution before merging.
- Tag /tæɡ/ A named pointer to a specific commit, typically used to mark release versions (e.
- Fork /fɔːk/ A personal copy of someone else's repository that lets you experiment or contribute via pull request.
- HEAD /hed/ A pointer in Git that indicates the currently checked-out commit or branch tip.
- Interactive Rebase /ˌɪntərˈæktɪv riːˈbeɪs/ A Git operation (git rebase -i) that lets you rewrite history: squash, reorder, edit, or drop individual commits.
- Semantic Versioning /sɪˈmæntɪk ˈvɜːʃənɪŋ/ A versioning convention (MAJOR.
- Monorepo /ˈmɒnəʊriːpəʊ/ A single repository containing multiple projects or packages — developers can make cross-cutting changes atomically.
- Trunk-Based Development /trʌŋk beɪst dɪˈveləpmənt/ A branching strategy where developers push small, frequent commits directly to main/trunk, avoiding long-lived feature branches.
- Blame /bleɪm/ Git blame (git blame) annotates each line of a file with the commit and author that last changed it — useful for context, not criticism.
- Pull Request Review /pʊl rɪˈkwest rɪˈvjuː/ A structured code review process within a pull/merge request — reviewers comment, request changes, or approve before merging.
- Feature Branch /ˈfiːtʃər bræntʃ/ A short-lived git branch for developing a single feature or fix, merged back to the main branch when complete.
JavaScript & TypeScript (20)
- Closure /ˈkləʊʒər/ A function that retains access to its outer scope's variables even after that scope has finished executing.
- Promise /ˈprɒmɪs/ An object representing the eventual result (or failure) of an asynchronous operation, with .
- async/await /eɪˈsɪŋk əˈweɪt/ Syntactic sugar over Promises that lets you write asynchronous code in a sequential, readable style.
- Event Loop /ɪˈvent luːp/ The mechanism in JavaScript that handles asynchronous callbacks by cycling through the call stack and task queue.
- Hoisting /ˈhɔɪstɪŋ/ JavaScript's behaviour of moving var declarations and function declarations to the top of their scope at compile time.
- Optional Chaining /ˈɒpʃənəl ˈtʃeɪnɪŋ/ The ?.
- Nullish Coalescing /ˈnʌlɪʃ kəʊˈæləsɪŋ/ The ?? operator that returns the right-hand value only when the left side is null or undefined (not falsy).
- Type Guard /taɪp ɡɑːd/ A TypeScript function or expression that narrows a type within a conditional block.
- Generics /dʒɪˈnerɪks/ A TypeScript feature allowing functions, classes, and interfaces to work with multiple types while preserving type information.
- Destructuring /dɪˈstrʌktʃərɪŋ/ Syntax that extracts values from arrays or properties from objects into distinct variables.
- Tree Shaking /triː ˈʃeɪkɪŋ/ A build optimisation that removes unused code (dead code) from the final bundle by analysing static imports.
- Prototype /ˈprəʊtətaɪp/ The object from which another object inherits properties in JavaScript's prototype chain.
- Module /ˈmɒdjuːl/ A self-contained file that exports specific functions or values, enabling code reuse and separation of concerns.
- JavaScript Prototype Chain /ˈdʒɑːvəskrɪpt ˈprəʊtətaɪp tʃeɪn/ The linked chain of objects from which a JavaScript object inherits properties and methods.
- Union Type /ˈjuːnjən taɪp/ A TypeScript type allowing a value to be one of several types — string | number | undefined.
- Type Narrowing /taɪp ˈnærəʊɪŋ/ TypeScript's ability to refine a variable's type within a conditional block based on type guards or checks.
- Utility Types /juːˈtɪlɪti taɪps/ Built-in TypeScript generic types for common transformations: Partial<T>, Required<T>, Pick<T,K>, Omit<T,K>.
- Spread Operator /spred ˈɒpəreɪtər/ The .
- Async Generator /eɪˈsɪŋk ˈdʒenəreɪtər/ A JavaScript function using async + yield to produce values asynchronously, consumed with for-await-of.
- Service Worker /ˈsɜːvɪs ˈwɜːkər/ A background script running between the browser and the network — enables offline support, background sync, and push notifications.
Data Structures & Algorithms (20)
- Big O Notation /bɪɡ əʊ nəʊˈteɪʃən/ A mathematical notation describing how an algorithm's time or space grows relative to input size.
- Hash Map /hæʃ mæp/ A data structure mapping keys to values using a hash function, providing O(1) average lookup, insert, and delete.
- Recursion /rɪˈkɜːʃən/ A function call to itself with a smaller input, solving problems by breaking them into identical sub-problems.
- Binary Search /ˈbaɪnəri sɜːtʃ/ An O(log n) search algorithm halving the search space each step, requiring a sorted collection.
- Stack /stæk/ A LIFO (Last In, First Out) data structure — push adds to the top, pop removes from the top.
- Queue /kjuː/ A FIFO (First In, First Out) data structure — enqueue adds to the back, dequeue removes from the front.
- Dynamic Programming /daɪˈnæmɪk ˈprəʊɡræmɪŋ/ An optimisation technique solving problems by breaking them into sub-problems and caching results to avoid recomputation.
- Graph /ɡrɑːf/ A data structure of nodes (vertices) connected by edges — used to model networks, dependencies, and paths.
- Linked List /lɪŋkt lɪst/ A data structure of nodes where each node holds a value and a pointer to the next node.
- Tree /triː/ A hierarchical data structure with a root node and child nodes — no cycles, each node has one parent.
- Memoisation /ˌmemərɪˈzeɪʃən/ An optimisation caching the results of expensive function calls and returning the cached result for the same inputs.
- Sorting Algorithm /ˈsɔːtɪŋ ˈælɡərɪðəm/ An algorithm reordering elements in a collection — merge sort is O(n log n); quicksort averages O(n log n) but degrades to O(n²).
- Breadth-First Search /bredθ fɜːst sɜːtʃ/ A graph traversal visiting all neighbours at the current depth before moving deeper — uses a queue.
- Depth-First Search /depθ fɜːst sɜːtʃ/ A graph traversal following edges as deep as possible before backtracking — uses a stack or recursion.
- Two-Pointer Technique /tuː ˈpɔɪntər tekˈniːk/ An algorithm pattern using two index pointers moving towards each other or in the same direction to solve array problems in O(n).
- Sliding Window /ˈslaɪdɪŋ ˈwɪndəʊ/ An algorithm pattern processing a fixed-size or variable-size sub-array by moving the window one step at a time.
- Namespace /ˈneɪmspeɪs/ A container that scopes identifiers to prevent naming collisions — used in languages, DNS, Kubernetes, and XML.
- Endianness /ˈendiənnɪs/ The order bytes are stored in memory: big-endian (most significant byte first) vs little-endian.
- Hot Path /hɒt pɑːθ/ The section of code executed most frequently — optimising the hot path yields the greatest performance gains.
- Tree Traversal /triː trəˈvɜːsəl/ Visiting all nodes in a tree structure: in-order, pre-order, post-order for binary trees; BFS or DFS for general trees.
Soft Skills for IT (19)
- Stakeholder /ˈsteɪkhəʊldə/ Any person or group with an interest in — or affected by — the outcome of a project, internal or external.
- Scope Creep /skəʊp kriːp/ The gradual, uncontrolled expansion of a project's requirements beyond the original definition, without adjusting timeline or budget.
- Escalation /ˌeskəˈleɪʃən/ Raising an issue to a higher level of authority or urgency to resolve it faster.
- Alignment /əˈlaɪnmənt/ Ensuring all stakeholders and team members share the same understanding of goals, priorities, and approach.
- Technical Trade-off /ˈteknɪkəl ˈtreɪd ɒf/ A decision where gaining one advantage requires accepting a disadvantage — e.
- Bandwidth /ˈbændwɪdθ/ In a professional context: a person's available capacity to take on additional work (analogous to network bandwidth).
- Knowledge Transfer /ˈnɒlɪdʒ ˈtrænsˌfɜːr/ The process of sharing expertise, context, or documentation from one person or team to another.
- Sign-off /saɪn ɒf/ Formal approval from a stakeholder, manager, or authority that a deliverable meets requirements and can proceed.
- Pushback /ˈpʊʃbæk/ Disagreement or resistance to a proposal, typically from a stakeholder or colleague, expressed professionally.
- Buy-in /baɪ ɪn/ Securing agreement and commitment from relevant parties before proceeding with a decision or change.
- Expectation Management /ˌekspekˈteɪʃən ˈmænɪdʒmənt/ Proactively communicating what will and won't be delivered, by when, to prevent misunderstandings.
- Blue Screen of Death /bluː skriːn əv deθ/ Informal term for Windows' critical error stop screen (BSOD) — used loosely to mean any catastrophic system failure.
- Rubber Duck Debugging /ˈrʌbər dʌk dɪˈbʌɡɪŋ/ Explaining your code problem out loud — often to an inanimate object or colleague — to discover the solution yourself.
- Bikeshedding /ˈbaɪkˌʃedɪŋ/ Spending excessive time on trivial decisions (naming, colour) while ignoring important complex ones.
- Minimum Viable Product /ˈmɪnɪməm ˈvaɪəbl ˈprɒdʌkt/ The smallest version of a product that delivers core value and validates assumptions with minimum effort.
- Action Item /ˈækʃən ˈaɪtəm/ A specific task assigned to a named person with a due date, created from a meeting or retrospective.
- On the Same Page An English idiom meaning everyone has the same understanding or information about a topic.
- Deep Dive /diːp daɪv/ A thorough, detailed investigation into a specific topic or problem — more comprehensive than a surface-level review.
- Bus Factor /bʌs ˈfæktər/ The minimum number of team members who must be hit by a bus (leave) before a project is critically impaired.
Testing & QA (19)
- Unit Test /ˈjuːnɪt test/ A test that verifies a single function or module in isolation, without involving external systems.
- Integration Test /ˌɪntɪˈɡreɪʃən test/ A test verifying how multiple components or services work together, including real database or API calls.
- TDD /tiː diː diː/ Test-Driven Development — write a failing test first, then the minimum code to pass it, then refactor.
- Mock /mɒk/ A fake object replacing a real dependency in tests, with configurable return values and call verification.
- Stub /stʌb/ A simplified replacement for a real object that returns predefined responses — simpler than a mock, no verification.
- Test Coverage /test ˈkʌvərɪdʒ/ The percentage of code lines, branches, or paths executed by automated tests.
- Flaky Test /ˈfleɪki test/ A test that produces inconsistent results without code changes — sometimes passing, sometimes failing, due to timing issues.
- Regression /rɪˈɡreʃən/ A bug where previously working functionality breaks after a code change — caught by regression tests.
- Smoke Test /sməʊk test/ A quick sanity check verifying the most critical paths work after a deployment, before running full test suites.
- Load Test /ləʊd test/ A test simulating concurrent users to measure system performance and find bottlenecks under expected load.
- Test Pyramid /test ˈpɪrəmɪd/ A model advocating for many cheap unit tests at the base, fewer integration tests, and fewest E2E tests at the top.
- E2E Test /iː tuː iː test/ End-to-End test — a test that exercises the full application stack from UI to database, simulating real user flows.
- Left Shift Testing /left ʃɪft ˈtestɪŋ/ Moving testing earlier in the development lifecycle to catch bugs sooner and reduce the cost of fixing them.
- Contract Testing /ˈkɒntrækt ˈtestɪŋ/ Testing that verifies services interact according to a shared contract without deploying all services together.
- Mutation Testing /mjuːˈteɪʃən ˈtestɪŋ/ A technique that introduces small code changes (mutations) to verify tests catch the error — measures test quality, not coverage.
- Snapshot Testing /ˈsnæpʃɒt ˈtestɪŋ/ A test that compares the current output (HTML, JSON, image) against a stored snapshot, failing if they differ.
- Feature Test /ˈfiːtʃər test/ A test verifying a complete user-facing feature from input to output, often matching acceptance criteria.
- Code Coverage Report /kəʊd ˈkʌvərɪdʒ rɪˈpɔːt/ A report showing which lines, branches, and functions are executed by tests — typically shown as a percentage.
- Monkeypatch /ˈmʌŋkiˌpætʃ/ Dynamically replacing a method or attribute at runtime — common in testing to override system or library behaviour.
CSS & Frontend (18)
- Specificity /ˌspesɪˈfɪsɪti/ The CSS rule determining which style wins when multiple rules target the same element — calculated from selector types.
- Flexbox /ˈfleksbɒks/ A CSS layout model that distributes items along a single axis (row or column) with alignment and spacing control.
- CSS Grid /siː es es ɡrɪd/ A two-dimensional CSS layout system that controls rows and columns simultaneously.
- CSS Custom Property /siː es es ˈkʌstəm ˈprɒpəti/ A CSS variable (--property-name: value) that holds reusable values and can be updated dynamically via JavaScript.
- BEM /bem/ Block Element Modifier — a CSS naming convention using double underscores and hyphens for predictable, component-based class names.
- Breakpoint /ˈbreɪkpɔɪnt/ A specific viewport width at which a CSS media query changes the layout for different screen sizes.
- Box Model /bɒks ˈmɒdəl/ The CSS concept defining that every element is a rectangular box with content, padding, border, and margin layers.
- Pseudo-class /ˈsjuːdəʊ klɑːs/ A CSS selector suffix (:hover, :focus, :nth-child) that matches elements based on state or position.
- Cascade /kæˈskeɪd/ The algorithm that determines which CSS rules apply when multiple conflicting declarations target the same element.
- Responsive Design /rɪˈspɒnsɪv dɪˈzaɪn/ A web design approach that makes layouts adapt to different screen sizes using flexible grids, images, and media queries.
- z-index /zed ˈɪndeks/ A CSS property that controls the stacking order of positioned elements — higher values appear on top.
- Utility Class /juːˈtɪlɪti klɑːs/ A single-purpose CSS class that applies one specific style (e.
- Pseudo-element /ˈsjuːdəʊ ˈelɪmənt/ A CSS keyword (::before, ::after, ::placeholder) that styles a specific part of an element.
- CSS Logical Properties /siː es es ˈlɒdʒɪkəl ˈprɒpətiz/ CSS properties using flow-relative terms (inline, block, start, end) instead of physical directions (left, right, top, bottom).
- Container Query /kənˈteɪnər ˈkwɪəri/ A CSS feature allowing styles to change based on the size of a parent container, not the viewport.
- Stacking Context /ˈstækɪŋ ˈkɒntekst/ A three-dimensional context formed by position + z-index — z-index only competes within the same stacking context.
- Semantic HTML /sɪˈmæntɪk eɪtʃ tiː em el/ Using HTML elements for their meaning (<article>, <nav>, <header>) rather than styling with generic <div> tags.
- Web Vitals /web ˈvaɪtəlz/ Google's metrics for user experience quality: LCP (loading), INP (interactivity), CLS (visual stability).
Linux & Command Line (18)
- Daemon /ˈdiːmən/ A background process on Linux/Unix that runs continuously, waiting for requests or performing scheduled tasks.
- Cron /krɒn/ A time-based job scheduler in Unix-like systems running commands at specified intervals defined in a crontab file.
- Shell /ʃel/ A command-line interface that interprets and executes user commands, e.
- Pipe /paɪp/ The | operator passing the output of one command as input to the next, enabling command chaining.
- Process /ˈprəʊses/ A running instance of a program, identified by a PID, with its own memory space and state.
- Environment Variable /ɪnˈvaɪrənmənt ˈveəriəbl/ A named value stored in the shell environment, used to configure applications without hardcoding settings.
- SSH /es es eɪtʃ/ Secure Shell — a cryptographic network protocol for securely operating a remote computer over an unsecured network.
- Symlink /ˈsɪmlɪŋk/ A symbolic link — a file pointing to another file or directory, like a shortcut in Linux/macOS.
- sudo /ˈsuːduː/ Superuser Do — a command that runs a subsequent command with root (administrator) privileges.
- grep /ɡrep/ A command-line utility searching text using patterns (strings or regex) and printing matching lines.
- Permission /pəˈmɪʃən/ Linux file access rights (read/write/execute) assigned to owner, group, and others — shown as rwxr-xr-x.
- stdin/stdout/stderr /ˈstændərd ɪn aʊt er/ Standard input, output, and error streams — the default text channels for commands in Unix.
- Shell Script /ʃel skrɪpt/ A text file with shell commands executed in sequence — used to automate repetitive tasks on Linux/macOS.
- Mount /maʊnt/ Attaching a filesystem (disk, network share, container volume) to a directory in the Linux filesystem tree.
- Redirect /rɪˈdaɪrekt/ Sending the output of a command to a file (>) or appending to it (>>) instead of printing to the terminal.
- awk /ɔːk/ A command-line text-processing tool that processes files line by line, splitting fields and applying programs.
- sed /sed/ Stream Editor — a command-line tool applying text transformations (substitute, delete, insert) to each line.
- tmux /tiː mʌks/ A terminal multiplexer allowing multiple terminal sessions within one window — sessions persist after disconnect.
Data Science & ML (16)
- Overfitting /ˌəʊvəˈfɪtɪŋ/ When an ML model learns training data too precisely — including noise — and fails to generalise to new examples.
- Inference /ˈɪnfərəns/ The process of running new input data through a trained model to generate predictions.
- Embeddings /ɪmˈbedɪŋz/ Dense vector representations of data (text, images) that capture semantic meaning, enabling similarity search.
- RAG /ræɡ/ Retrieval-Augmented Generation — augmenting LLM prompts with relevant retrieved documents to ground responses in facts.
- Hallucination /həˌluːsɪˈneɪʃən/ When an LLM generates plausible-sounding but incorrect or fabricated information not grounded in its training data.
- Hyperparameter /ˈhaɪpərˌpærəmɪtər/ A configuration value set before training (learning rate, batch size, layer count) that controls the training process.
- Precision vs Recall /prɪˈsɪʒən vɜːsəs rɪˈkɔːl/ Precision measures correctness of positive predictions; recall measures how many actual positives were found.
- Model Drift /ˈmɒdəl drɪft/ The degradation of a model's accuracy over time as real-world data patterns diverge from its training distribution.
- Cross-validation /krɒs ˌvælɪˈdeɪʃən/ A technique splitting data into k folds and training/evaluating k times to get a robust performance estimate.
- Feature Engineering /ˈfiːtʃər ˌendʒɪˈnɪərɪŋ/ The process of transforming raw data into informative input features that improve model performance.
- Data Leakage /ˈdeɪtə ˈliːkɪdʒ/ Using information in model training that would not be available at prediction time, causing inflated performance metrics.
- Model Serving /ˈmɒdəl ˈsɜːvɪŋ/ Deploying a trained ML model as an API endpoint so applications can request predictions in real or batch time.
- MLOps /em el ɒps/ Machine Learning Operations — combining ML development with DevOps practices for reliable model deployment and monitoring.
- Training vs Inference /ˈtreɪnɪŋ vɜːsəs ˈɪnfərəns/ Training updates model weights using data; inference applies a fixed model to new inputs to make predictions.
- Context Window /ˈkɒntekst ˈwɪndəʊ/ The maximum number of tokens an LLM can process at once — input + output combined must fit within this limit.
- Confusion Matrix /kənˈfjuːʒən ˈmeɪtrɪks/ A table showing the counts of true/false positives and negatives for a classification model.
API Design (15)
- Endpoint /ˈendpɔɪnt/ A specific URL in an API that accepts requests for a particular resource or action.
- Idempotency /aɪˈdempətənsi/ A property where applying the same operation multiple times produces the same result as applying it once.
- Rate Limiting /reɪt ˈlɪmɪtɪŋ/ A technique controlling how many API requests a client can make in a given time window to protect the server.
- Pagination /ˌpædʒɪˈneɪʃən/ Splitting large API responses into pages using offset/limit or cursor-based parameters.
- Webhook /ˈwebhʊk/ A mechanism where one service sends an HTTP POST to a registered URL when an event occurs.
- OpenAPI / Swagger /ˈəʊpən eɪ piː aɪ ˈswæɡər/ A specification and tooling for describing REST APIs in a machine-readable format, producing interactive documentation.
- GraphQL /ˈɡræf kjuː el/ A query language for APIs where the client specifies exactly what data it needs, avoiding over- or under-fetching.
- Bearer Token /ˈbeərər ˈtəʊkən/ An access token included in the Authorization header that grants API access without credentials per request.
- Breaking Change /ˈbreɪkɪŋ tʃeɪndʒ/ An API change that is incompatible with existing clients, requiring them to update their integration.
- REST /rest/ Representational State Transfer — an architectural style for APIs using HTTP methods and stateless communication.
- API Versioning /eɪ piː aɪ ˈvɜːʃənɪŋ/ The practice of maintaining multiple API versions (/v1, /v2) to allow clients to migrate at their own pace.
- GraphQL Subscription /ˈɡræf kjuː el sʌbˈskrɪpʃən/ A real-time GraphQL operation using WebSocket to push updates to a client when data changes.
- API Mocking /eɪ piː aɪ ˈmɒkɪŋ/ Creating a simulated API that returns predefined responses — used by frontend teams to develop before the real API is ready.
- HTTP Caching /eɪtʃ tiː tiː piː ˈkæʃɪŋ/ Browser and proxy mechanisms (Cache-Control, ETag, Last-Modified) to avoid downloading unchanged resources.
- CORS /kɔːz/ Cross-Origin Resource Sharing — browser mechanism restricting API calls to different domains unless the server allows them.
Cloud Infrastructure (14)
- Region /ˈriːdʒən/ A geographic area containing multiple AWS/GCP/Azure data centres, chosen to reduce latency and meet data residency requirements.
- Availability Zone /əˌveɪləˈbɪlɪti zəʊn/ A physically separate data centre within a cloud region — deploying across AZs provides fault isolation.
- Serverless /ˈsɜːvələs/ A cloud execution model where the provider allocates resources automatically — you pay per execution, not per running instance.
- IAM /aɪ eɪ em/ Identity and Access Management — the system managing who can access what resources in a cloud environment.
- Auto-scaling /ˈɔːtəʊ skeɪlɪŋ/ A cloud feature automatically adding or removing compute instances based on demand to maintain performance.
- VPC /viː piː siː/ Virtual Private Cloud — a logically isolated private network where you control IP ranges, subnets, and routing.
- Object Storage /ˈɒbdʒɪkt ˈstɔːrɪdʒ/ A cloud storage model (S3, GCS, Azure Blob) storing data as objects with metadata — highly scalable, inexpensive.
- Spot Instance /spɒt ˈɪnstəns/ A discounted cloud VM that can be terminated by the provider with short notice — ideal for fault-tolerant batch jobs.
- Egress Cost /ˈiːɡres kɒst/ Cloud charges for data transferred out of the cloud provider to the internet or another region.
- Managed Service /ˈmænɪdʒd ˈsɜːvɪs/ A cloud-operated service (RDS, ElastiCache, Kinesis) where the provider handles maintenance, patching, and scaling.
- CDN Invalidation /siː diː en ɪnˌvælɪˈdeɪʃən/ Removing cached objects from a CDN's edge servers before they naturally expire — forces fresh content to be fetched.
- Load Balancer Health Check /ləʊd ˈbælənsər helθ tʃek/ Periodic probes from a load balancer to each backend instance to determine if it can receive traffic.
- Infrastructure as Code /ˈɪnfrəstrʌktʃər æz kəʊd/ Defining and managing cloud infrastructure through code files (Terraform, CloudFormation) instead of manual clicks.
- GitOps /ˈɡɪt ɒps/ A practice where Git is the single source of truth for declarative infrastructure and application deployments.
Mobile Development (14)
- Native App /ˈneɪtɪv æp/ A mobile application built specifically for one platform (iOS or Android) using its native APIs and language.
- Deep Link /diːp lɪŋk/ A URL scheme that opens a specific screen inside a mobile app directly, rather than just launching the app homepage.
- Push Notification /pʊʃ ˌnəʊtɪfɪˈkeɪʃən/ A message delivered from a server to a device at any time, displayed even when the app is closed.
- Code Signing /kəʊd ˈsaɪnɪŋ/ Cryptographically signing the app binary to verify its identity and integrity for the App Store or enterprise distribution.
- OTA Update /əʊ tiː eɪ ˈʌpdeɪt/ Over-The-Air update — delivering a new JavaScript bundle to users without requiring an App Store submission.
- Crash Reporting /kræʃ rɪˈpɔːtɪŋ/ Automated collection and reporting of crashes from user devices in production, with stack traces and context.
- App Lifecycle /æp ˈlaɪfsaɪkəl/ The states a mobile app moves through: foreground, background, suspended, terminated — each triggering system callbacks.
- Cold Start /kəʊld stɑːt/ The delay when a mobile app or serverless function is launched from a completely stopped state — involves full initialisation.
- Safe Area /seɪf ˈeəriə/ The portion of the screen free from device hardware elements like notches, home indicators, or rounded corners.
- Haptic Feedback /ˈhæptɪk ˈfiːdbæk/ Tactile vibration patterns on mobile devices providing physical confirmation of user interactions.
- APK / IPA /eɪ piː keɪ aɪ piː eɪ/ The installable app package formats: APK for Android, IPA for iOS — contains the compiled binary and assets.
- TestFlight /ˈtestflaɪt/ Apple's platform for distributing beta iOS builds to internal and external testers before App Store release.
- Cross-Platform /krɒs ˈplætfɔːm/ Mobile frameworks (React Native, Flutter) allowing a single codebase to run on both iOS and Android.
- In-App Purchase /ɪn æp ˈpɜːtʃɪs/ A transaction made within a mobile app — App Store and Google Play take a 15–30% commission on IAP revenue.
Networking & Protocols (12)
- DNS /diː en es/ Domain Name System — translates human-readable domain names (api.
- Load Balancer /ləʊd ˈbælənsər/ A component distributing incoming traffic across multiple servers so no single server becomes overwhelmed.
- TLS /tiː el es/ Transport Layer Security — the cryptographic protocol securing communications over the internet (the 'S' in HTTPS).
- CDN /siː diː en/ Content Delivery Network — a geographically distributed network of servers that delivers static content from locations closer to users.
- WebSocket /ˈwebˌsɒkɪt/ A protocol providing full-duplex communication over a single TCP connection, enabling real-time bidirectional messaging.
- Latency /ˈleɪtənsi/ The time delay between sending a request and receiving the first byte of a response, measured in milliseconds.
- Reverse Proxy /rɪˈvɜːs ˈprɒksi/ A server sitting in front of backend servers, forwarding client requests and returning responses on their behalf.
- Firewall /ˈfaɪərwɔːl/ A security system controlling network traffic based on rules — blocking or allowing connections between systems.
- TCP vs UDP /tiː siː piː vɜːsəs juː diː piː/ TCP provides reliable, ordered delivery with connection handshake; UDP is faster but unreliable — no guaranteed delivery.
- HTTP Status Code /eɪtʃ tiː tiː piː ˈsteɪtəs kəʊd/ A three-digit code returned by a server indicating the result of an HTTP request (200 OK, 404 Not Found, 500 Internal Server Error).
- Bandwidth /ˈbændwɪdθ/ The maximum rate of data transfer across a network link, measured in Mbps or Gbps.
- gRPC /dʒiː ɑː piː siː/ A modern RPC framework by Google using Protocol Buffers over HTTP/2 — strongly typed, fast, with code generation.
UI/UX Design (12)
- Wireframe /ˈwaɪəfreɪm/ A low-fidelity structural sketch of a UI showing layout and content hierarchy without colour or final design.
- Design System /dɪˈzaɪn ˈsɪstəm/ A collection of reusable components, tokens, and guidelines ensuring visual and functional consistency across a product.
- Accessibility (a11y) /əkˌsesɪˈbɪlɪti/ Designing products usable by people with disabilities — meeting WCAG guidelines for keyboard, screen reader, and contrast.
- Skeleton Screen /ˈskelɪtən skriːn/ A loading placeholder that mimics the shape of content being loaded, reducing perceived wait time.
- CTA /siː tiː eɪ/ Call to Action — a button or link prompting the user to take a specific desired action.
- User Flow /ˈjuːzər fləʊ/ A diagram showing the sequence of screens and actions a user takes to complete a specific task.
- Toast Notification /təʊst ˌnɒtɪfɪˈkeɪʃən/ A non-intrusive, auto-dismissing popup message appearing briefly at the corner of the screen to confirm an action.
- Modal /ˈməʊdəl/ A dialog box that appears above the page content, requiring user interaction before they can return to the main page.
- WCAG /ˈwɪkæɡ/ Web Content Accessibility Guidelines — standards defining how to make web content accessible, with three levels: A, AA, AAA.
- Affordance /əˈfɔːdəns/ A visual or tactile property of a UI element that signals how it should be used — buttons look clickable, sliders draggable.
- Dark Mode /dɑːk məʊd/ A UI colour scheme using light text on a dark background — reduces eye strain in low light and saves battery on OLED screens.
- Prototype /ˈprəʊtətaɪp/ An interactive simulation of a product used for user testing before committing to full development.
Open Source & Community (12)
- Open Source /ˈəʊpən sɔːs/ Software with publicly available source code that anyone can view, use, modify, and distribute.
- License /ˈlaɪsəns/ A legal contract specifying how open-source software may be used, modified, and distributed (MIT, Apache 2.
- Maintainer /meɪnˈteɪnər/ The person or team responsible for reviewing contributions, merging PRs, and deciding the direction of an open-source project.
- SemVer /sem vɜːr/ Semantic Versioning — MAJOR.
- Bus Factor /bʌs ˈfæktər/ The minimum number of team members who must be 'hit by a bus' before the project becomes inoperable.
- Upstream /ˈʌpstriːm/ The original repository a fork derives from — when you submit a PR to the source project, you're contributing upstream.
- CHANGELOG /ˈtʃeɪndʒlɒɡ/ A file documenting notable changes for each version of a project, in reverse chronological order.
- RFC /ɑː ef siː/ Request for Comments — a document proposing a change or new feature for community discussion before implementation.
- Good First Issue /ɡʊd fɜːst ˈɪʃuː/ A GitHub label on issues suitable for first-time contributors — typically well-scoped with clear instructions.
- Inner Source /ˈɪnər sɔːs/ Applying open-source development practices (forks, pull requests, transparent code) within a private company.
- Dependency Hell /dɪˈpendənsi hel/ A situation where conflicting transitive dependency versions make it impossible to satisfy all package requirements simultaneously.
- Lock File /lɒk faɪl/ A file (package-lock.
Developer Tooling (11)
- IDE /aɪ diː iː/ Integrated Development Environment — a software application with code editor, debugger, and build tools in one package.
- Linter /ˈlɪntər/ A static analysis tool that checks code for stylistic issues, potential errors, and violations of coding conventions.
- Formatter /ˈfɔːmætər/ A tool that automatically rewrites code to adhere to consistent style (indentation, quotes, line length).
- Package Manager /ˈpækɪdʒ ˈmænɪdʒər/ A tool managing library dependencies — installing, updating, and removing packages (npm, pip, Cargo, Maven).
- Debugger /dɪˈbʌɡər/ A tool letting you pause code execution at breakpoints, inspect variables, and step through logic line by line.
- Hot Reload /hɒt rɪˈləʊd/ A development feature instantly reflecting code changes in the running app without a full restart.
- dotfiles /dɒt faɪlz/ Configuration files with names starting with a dot (.
- REPL /ˈrepəl/ Read-Eval-Print Loop — an interactive shell that reads input, evaluates it, prints the result, and repeats.
- Profiler /ˈprəʊfaɪlər/ A tool measuring CPU time, memory usage, and call frequency to identify performance bottlenecks.
- Git Hook /ɡɪt hʊk/ A script that runs automatically at specific Git events (pre-commit, pre-push, commit-msg).
- Linting /ˈlɪntɪŋ/ Automated static analysis of code to detect style violations, potential bugs, and anti-patterns without running it.
Agile & Lean (7)
- WIP Limit /wɪp ˈlɪmɪt/ Work in Progress limit — a constraint capping how many tasks can be active simultaneously in Kanban.
- OKR /əʊ keɪ ɑː/ Objectives and Key Results — a goal-setting framework pairing a qualitative objective with quantitative measurable results.
- Flow Efficiency /fləʊ ɪˈfɪʃənsi/ The ratio of active work time to total lead time — measures how much of the process is value-added vs.
- SAFe /seɪf/ Scaled Agile Framework — a methodology for scaling agile practices across large enterprises with multiple teams.
- Lean /liːn/ A philosophy of maximising value by eliminating waste — applied to software as reducing everything that doesn't serve the customer.
- Cumulative Flow Diagram /kjuːˈmjuːlətɪv fləʊ ˈdaɪəɡræm/ A stacked area chart showing the count of items in each stage over time — used to visualise bottlenecks in Kanban.
- Pair Programming /peər ˈprəʊɡræmɪŋ/ An agile practice where two developers work together at one workstation — one writes code, the other reviews in real time.
No terms match your search. Try a different keyword or clear the search.