5 exercises on degree adverbs that collocate with technical adjectives: the difference between "highly available" and "very available" is the difference between engineering vocabulary and guesswork.
Fixed degree adverb collocations in this set
highly available — not "very" or "fully"; maps to "high availability"
tightly coupled — not "strongly" or "closely"; canonical bad-coupling term
loosely integrated — mirrors "loose coupling" in architecture
deeply nested — not "highly" or "very"; natural pair for hierarchical depth
0 / 5 completed
1 / 5
An SRE discusses system design:
"The payment service is ___ available — it runs across five regions with automatic failover and has maintained 99.995% uptime over the past 12 months."
Which degree adverb collocates with "available" to describe the highest level of uptime?
Highly available is the established collocation. "Highly" is the correct degree adverb here — it collocates naturally with "available" to form the technical concept of High Availability (HA). This is the adjective form of the noun phrase "high availability."
Why the others fail:
fully available — implies 100% availability at all times; too absolute; not the technical term
totally available — informal register; not used in technical documentation
very available — grammatically valid but never used professionally; "very" is too vague for a technical context
The collocation pair:
highly available (adjective form) ↔ high availability (noun form)
Both are used: "a highly available system" / "design for high availability"
Common collocations:
highly available cluster
highly available database
highly scalable (parallel structure)
2 / 5
A code reviewer leaves a comment:
"This module is ___ coupled to the database layer — changing the schema requires modifying code in seven different places across this class."
Which degree adverb describes coupling that is extreme and problematic?
Tightly coupled is the canonical collocation. "Tight" is the fixed adjective for high coupling in software design — it is part of the established pair: tightly coupled (bad) / loosely coupled (good). This pair is so standard that it appears in SOLID principles, Clean Architecture, and every major software design resource.
Why the others fail:
strongly coupled — not the standard term; "strong" is not the collocating adjective for coupling in software engineering
closely coupled — sounds natural but is not the established phrase; "close" coupling is not a term of art
heavily coupled — informal; not used in technical documentation
The canonical pair — memorise this:
tightly coupled — high interdependency; a change in one component requires changes in others
loosely coupled — low interdependency; components interact via interfaces and can change independently
3 / 5
An architect describes a system integration:
"The new payment gateway is ___ integrated with our existing order management system — they share a common event bus but each evolves on its own release schedule."
Which adverb describes integration that is flexible and non-restrictive?
Loosely integrated is the correct collocation, drawing from the established "loose coupling" vocabulary in software architecture. "Loosely" is the standard degree adverb for describing flexible, non-restrictive integration — where components can evolve independently because they interact through well-defined, minimal interfaces.
Why the others fail:
weakly integrated — "weak" in computing usually refers to weak references (memory management); not used for integration style
lightly integrated — informal; not a standard architectural term
softly integrated — not used in technical English
The architecture vocabulary family:
loosely coupled (components)
loosely integrated (systems)
loosely coupled services (microservices)
Contrast with:tightly integrated — systems share internal state or implementation details; hard to change independently.
4 / 5
A TypeScript team lead explains a configuration requirement:
"All new modules must be ___ typed — use explicit type annotations everywhere, and enable strict: true in tsconfig. No any."
Which adverb describes a type system used to its full, rigorous extent?
Strictly typed is the most precise collocation here. "Strictly" collocates with "typed" to describe rigorous type enforcement — no implicit conversions, no escape hatches, all values have explicit types. In TypeScript, enabling strict mode enforces this: noImplicitAny, strictNullChecks, etc.
Key distinctions:
strictly typed — rigorous enforcement, no exceptions; matches strict: true in tsconfig ✅
strongly typed — the language itself enforces type safety at compile/run time (e.g., Python is strongly typed; JavaScript is weakly typed); describes the language property, not the usage style
fully typed — all code has type annotations; correct but less idiomatic than "strictly typed" in the TypeScript community
completely typed — informal; not the standard phrasing
Common collocations:
strictly typed codebase
strict mode in TypeScript
dynamically typed vs statically typed
5 / 5
A code review comment reads:
"This callback is ___ nested — I count five levels of indentation. Extract these inner functions or use async/await."
Which degree adverb best captures the excessive, problematic nature of the nesting?
Deeply nested is the established collocation. "Deeply" is the natural adverb pair for "nested" in programming contexts. It is used consistently in code quality discussions, ESLint rules (max-depth), and refactoring guides. The collocation captures both the literal depth (many levels of indentation) and the metaphorical meaning of complexity that is hard to understand.
Why "deeply" is the right word:
deeply nested — the standard collocation; "deep" and "depth" relate naturally to hierarchical structures ✅
highly nested — not the natural collocate; "highly" works better with scalar qualities (highly available, highly skilled)
very nested — grammatically valid but informal; "very" is weak in technical writing
extremely nested — emphasises extremity but is not the standard phrase