Design Principles Mid

Violations compound as coupling and duplication accumulate, making later changes slower, riskier, and more costly.

Violations improve short-term speed and reduce debt because skipping structure lets teams ship features faster.

Violations are isolated defects that linter tools remove automatically, so they rarely affect long-term maintenance.

Violations only slow initial delivery, but well-tested code afterward pays the debt back with no interest.

They ultimately exist to eliminate all bugs so systems never require testing or review after they ship.

They ultimately exist to standardize syntax so teams write identical-looking code across every project they build.

They ultimately exist to enforce performance so systems run faster and consume fewer resources as they grow.

They ultimately exist to manage complexity so systems stay understandable and changeable as they grow.

It has many public methods and global state, exposing internals so callers can tune behavior directly.

It has minimal comments and short names, hiding intent so only original authors can safely modify it.

It has high cohesion and low coupling, exposing a clear interface that hides its implementation details.

It has low cohesion and tight coupling, sharing data widely so other modules integrate with it faster.

Add new behavior through global configuration flags, since branching on flags avoids writing any new classes.

Add new behavior by copying whole modules, since duplicating existing source avoids breaking any current callers.

Add new behavior by directly editing existing classes, since modifying source keeps all logic in one place.

Add new behavior through new abstractions or subclasses rather than editing existing, tested source code.

Subclasses must always call the parent's constructor to ensure the base state is properly initialized first.

Subclasses must not add any new methods beyond those already declared in the parent class's interface.

Subclasses must override every method of the parent so that behavior is fully replaced and stays consistent.

Subtypes must be substitutable for their base types without breaking the program's expected correctness.

Interfaces expose private data fields; ISP hides them behind getters so clients cannot break encapsulation.

Classes implement too many interfaces; ISP merges them into one so clients keep a single clean dependency.

Interfaces grow too large in memory; ISP reduces runtime overhead by loading only the needed method tables.

Clients depend on methods they don't use; ISP splits interfaces so unrelated changes don't affect them.

Following SOLID removes the need for tests by guaranteeing correctness through strict type-safe contracts.

Combining responsibilities into large classes reduces the number of test files you must write and maintain.

Depending on abstractions lets you swap real dependencies for mocks, isolating the units under test.

Injecting concrete classes directly makes tests faster because no abstraction layer must be resolved first.

SRP and ISP both mean one method per type, so a single interface would end up violating each principle equally.

SRP applies to interfaces while ISP applies to classes; both aim to reduce the number of methods per file.

SRP limits a class's responsibilities; ISP keeps interfaces small so clients avoid unused method dependencies.

SRP splits large interfaces; ISP splits large classes, together ensuring every module has exactly one caller.

Prefer inheritance over composition so subclasses always inherit the parent's concrete behavior.

Expose every internal method publicly so callers can reach the implementation details directly.

Depend on abstractions describing behavior so any implementation can be substituted freely.

Write concrete classes first, then extract interfaces only after the code has fully stabilized.

Fewer interfaces mean fewer files, which makes the overall codebase simpler to navigate.

One large interface guarantees consistency, so every client shares the same set of methods.

Clients depend only on the methods they actually use, which lowers coupling between them.

Specific interfaces let a single class implement them all, increasing reuse across modules.

Each class holds a single responsibility, making the code easy to extend but slow to compile fully.

Duplicated logic appears across files, yet every module can still be deployed independently of others.

Modules communicate only through clean interfaces, so refactoring one rarely affects the others at all.

A small change ripples through many modules, and classes cannot be tested or reused in isolation.

A focused single-purpose module has fewer dependencies, so its tests are simpler and changes stay local.

A module split across many files hides complexity, so maintainers can change one part without reading others.

A module doing many tasks shares more code, so fewer test cases are needed and refactoring is much faster.

A module with global state exposes internals, making integration tests easier and unit tests less important.

Fragility is slow build times after edits; immobility is code that can never be deleted safely; loose coupling is the shared root cause.

Fragility is breakage in unexpected places after a change; immobility is the inability to reuse code elsewhere; high coupling drives both.

Fragility is the inability to reuse code elsewhere; immobility is breakage in unexpected places after a change; low cohesion drives both.

Fragility is many bugs shipped at release; immobility is a team's reluctance to refactor code; poor naming conventions cause both issues.

A module receives a whole object but uses one field, so it needlessly depends on the full structure and breaks when unrelated parts change.

A module shares a global object with others, so it silently reads stale values and produces wrong results when another module edits them.

A module copies an object before using it, so it wastes memory on duplicates and diverges when the original is later mutated elsewhere.

A module receives one field but needs the whole object, so it repeatedly re-queries the source and slows down when the data set grows large.

An object should only talk to objects of the same class; chaining through others hides internal structure and duplicates code in callers.

An object should only talk to its immediate collaborators; chaining through them exposes internal structure and couples callers to it.

An object should never hold references to others; storing them creates cycles and prevents the garbage collector from freeing the callers.

An object should minimise the number of its methods; calling too many of them wastes memory and slows down the callers at runtime badly.

Notify observers whenever state changes so dependent objects can pull the latest values on demand

Instruct an object to perform an action itself rather than querying its state and deciding externally

Expose public getters and setters for every field so collaborators can read and mutate state freely

Query an object for all its fields first, then let the caller apply the business rules on those values

An object should minimize the total number of public methods it exposes to keep its overall interface as small as possible

An object should never hold references to other objects and must obtain every collaborator through a global registry

An object should call only its own, its parameters', and its direct collaborators' methods, avoiding long chains

An object should communicate with distant modules only through events, never by calling methods on them directly at all

Split the object into a data holder and a service so the logic stays in a dedicated stateless helper

Read the object's data into the caller so the shared logic can be reused across many different callers

Cache the object's fields locally so repeated questions about its state avoid extra round trips each time

Send commands to the object owning the data so the decision logic lives beside the state it uses

Duplicate shared state across modules so each keeps its own copy and remains isolated from other edits

Conceal volatile decisions behind stable interfaces so changes stay local and don't propagate to clients

Encrypt internal data so unauthorized modules cannot read it, which prevents malicious changes from spreading

Publish every internal detail up front so clients adapt early and no surprises ripple through later

Abstraction is only for interfaces and base classes; hiding applies exclusively to concrete implementation classes

Abstraction models the essential idea to manage complexity; hiding conceals the details that realize it

Abstraction restricts access to private members; hiding groups related data and behavior into one unit

Abstraction improves runtime speed by removing indirection; hiding adds layers that slow the whole system down

An abstraction that leaks implementation details callers must know, undermining the hiding encapsulation promises.

An interface that hides too much behavior, so callers cannot access any of the useful underlying details.

A design where private fields are exposed via getters, letting external code freely modify their state.

A memory leak caused when an object retains references and prevents the garbage collector from reclaiming it.

A method with far too many parameters; the Single Responsibility principle splits it into separate concerns.

A class with too many public methods; the Interface Segregation principle splits it into smaller focused roles.

A method that duplicates logic elsewhere; the Don't Repeat Yourself principle extracts it into a shared helper.

A method obsessed with another class's data; the Information Expert principle moves behavior to that data.

Freeze stable core logic into constants; find them by locating code that has never once been modified before.

Hide all internal fields behind getters and setters; find them by checking which variables are declared private.

Duplicate volatile code across modules for safety; find them by measuring which functions get called most often.

Isolate the parts likely to change behind stable interfaces; find them by spotting requirements and details that shift.

Each function should operate at one level of abstraction; mixing high- and low-level steps hurts readability.

Each function should have a single return point; mixing multiple exits scattered through the body hurts readability.

Each module should depend on one other layer; mixing calls across many layers in one place hurts readability.

Each class should expose only one public method; mixing several unrelated operations in one type hurts readability.

Inheritance runs faster at runtime; deep composition chains add indirection that slowly degrades overall performance.

Inheritance hides implementation better; deep composition exposes internal helper objects to unrelated calling code.

Composition gives flexible runtime behavior; deep inheritance couples subclasses so base changes silently break them.

Composition avoids all code reuse; deep inheritance forces subclasses to reimplement every inherited method again.

Changes to a base class can unexpectedly break distant subclasses that depend on its internal behavior.

Adding a new subclass forces recompiling every unrelated class living in the same package hierarchy.

Subclasses always run slower because each method call must traverse the entire chain of parent classes.

Base classes cannot define abstract methods, so subclasses are forced to duplicate shared logic everywhere.

Compose objects for flexibility; inheritance fits a true is-a relationship with stable, substitutable base behavior.

Compose objects for speed reasons; inheritance fits any deep hierarchy where subclasses override most parent methods.

Compose objects to save memory; inheritance fits any case where two classes happen to share a few methods.

Compose objects to hide fields; inheritance fits whenever you want to reuse code without writing wrapper types.

Abstract only after three developers have independently written the same code, because that proves the logic is genuinely reusable across separate teams.

Refactor duplication the very first time it appears, since delaying until a third copy exists makes the eventual abstraction far harder to extract.

Wait until code repeats a third time before abstracting, because two occurrences may be coincidental and the true shared pattern isn't yet clear.

Always split shared logic into exactly three separate layers, since fewer layers leave code coupled and more than three adds needless indirection cost.

Keep designs as simple as possible; needless abstraction layers add indirection that raises cognitive load and slows the team's understanding.

Keep dependencies few; abstraction layers violate this by importing libraries, and the cost is a larger deployment artifact and slower startup time.

Keep interfaces stable; abstraction layers violate this by changing method signatures, and the cost is that dependent modules break during releases.

Keep every class small; abstraction layers violate this by growing file sizes, and the cost is that builds and automated test suites run slower.

It requires that all performance work be delegated to compilers rather than any manual effort

It says you should optimize every hot path up front so later refactoring becomes unnecessary

It means optimization should be avoided entirely because clean code always outperforms tuned code

It warns against tuning before knowing bottlenecks; optimize once profiling proves a real need

Both are identical rules requiring that code and data never be repeated anywhere in a system

Each piece of data has one authoritative home; DRY targets duplicated logic rather than data

It centralizes all business logic in one class; DRY concerns only naming conventions used

Each module owns its own data copy; DRY instead mandates copying logic across every layer

SoC partitions a system into distinct concerns; SRP says a class has one reason to change

They are interchangeable names for the same rule that every function should do one thing

SoC applies only to classes while SRP governs how whole subsystems are split into layers

SoC forbids any shared state whereas SRP simply requires methods to be kept short overall

It reduces the total line count so developers simply have fewer characters left to read overall

It isolates concerns so a developer reasons about one module without holding the whole system

It forces every developer to memorize all module interactions before any change can be made

It merges related concerns into one large module so all context lives in a single readable file

A framework controls flow and calls your code back, which is what the Hollywood Principle states

It means inverting class hierarchies, and the Hollywood Principle is about avoiding deep subclassing

It is another name for dependency injection only, unrelated to any callback or framework flow

Your code drives the framework by polling it, and the Hollywood Principle describes that polling

Assign the responsibility to the class nearest the user interface receiving the initial request

Assign the responsibility to the class that already holds the data needed to carry it out

Assign the responsibility to a dedicated manager class that coordinates all the other classes

Assign the responsibility to whichever class currently has the fewest methods defined on it

Every public method should combine a read and a write so callers make only one round trip to it

Queries change state and return data, while commands merely read state without altering anything at all

Commands and queries must both return a status code so callers can verify the operation succeeded

Commands change state and return nothing; queries return data and cause no side effects

Detect invalid conditions and stop immediately, preventing corrupted state and making the bug visible

Retry invalid conditions repeatedly and hope they resolve, keeping the service available to end users

Route invalid conditions to a backup instance, so the primary process can keep serving traffic normally

Suppress invalid conditions and keep running, deferring the failure until a scheduled maintenance window

It is identical to Design by Contract, since both require every method to verify its own postconditions before returning any result to the caller.

It codes only the happy path and trusts all callers; Design by Contract adds the runtime checks that defensive programming deliberately leaves out.

It codes against invalid states and misuse; Design by Contract instead assumes preconditions hold, shifting that duty explicitly to the caller.

It replaces contracts entirely by throwing exceptions, whereas Design by Contract forbids exceptions and relies purely on validated return codes.

Using dependency injection makes wiring implicit; the DIP fixes this by requiring classes to construct their own collaborators directly.

Pure functions with no side effects resist testing; the ISP fixes this by adding shared global state that assertions can then read.

Hard-coded concrete dependencies block substitution; the DIP fixes this by depending on abstractions injectable in tests.

Small focused interfaces block mocking; the ISP fixes this by merging them into one broad interface that tests can stub in a single place.

It violates the Liskov Substitution Principle; make it a base class others can freely substitute for, preserving all inherited behavior.

It violates the Single Responsibility Principle; extract its distinct responsibilities into smaller focused, collaborating classes.

It violates the Dependency Inversion Principle; introduce an interface it implements so callers depend only on that shared abstraction.

It violates the Open/Closed Principle; add subclasses that override its methods so behavior can be extended without any modification.

Callers depend on a concrete class, so the compiler inlines calls, and tests run faster by exercising the real production object each time.

Callers share one global implementation, reducing object count, and tests verify behavior directly against that single shared instance's state.

Callers know the exact type, enabling private fields to be read in assertions, so tests need no mocks and cover more real internal paths.

Callers depend on an abstraction, so implementations swap freely and tests inject mocks or fakes for the real collaborator.

Feature Envy means duplicated code across modules, and Shotgun Surgery means one method grows too long and must be broken into helper functions.

Feature Envy means a class hides too much data, and Shotgun Surgery means a single class absorbs every responsibility that should be split up.

Feature Envy means an interface has too many methods, and Shotgun Surgery means a subclass cannot substitute cleanly for its declared base type.

Feature Envy shows misplaced responsibility, and Shotgun Surgery shows scattered concerns that one change forces across many classes.

Duplicated code forces the same edit in many places; it violates DRY throughout the whole codebase repeatedly.

A single change forces many small edits across many classes; it violates cohesion because one responsibility is scattered.

One class doing many things forces edits when any concern changes; it violates SRP by concentrating responsibilities.

One change makes many classes change for differing reasons; it violates the Open/Closed Principle very broadly.

Needless complexity is deep inheritance (favor composition); opacity is dead code removed by regular refactoring passes.

Needless complexity is unused over-engineered abstraction (YAGNI/KISS); opacity is unclear code fixed by clarity.

Needless complexity is duplicated logic (DRY); opacity is tight coupling addressed by dependency inversion between modules.

Needless complexity is premature optimization (KISS); opacity is global state fixed by encapsulation and scoping.

APIs should expose every internal option so users can configure any behavior.

APIs should behave as users reasonably expect, so results never surprise them.

APIs should minimize the number of methods to keep the surface area small.

APIs should hide implementation by throwing exceptions on unexpected input.

Restrict privileges only at network boundaries where external attackers can reach.

Give each component only the access it needs, limiting coupling and impact of errors.

Give each component full access early so refactoring later becomes easier to manage.

Grant privileges based on developer seniority to keep codebase changes controlled.

It slows the program because global variables are stored far from the CPU cache.

It duplicates data across modules, breaking DRY and increasing binary size at runtime.

It hides dependencies and shared state, breaking encapsulation and hurting testability.

It prevents inheritance because globals cannot be overridden by derived subclasses.

Immutable objects can't change after creation, so they're safe to share and reason about.

Immutable objects run faster since the CPU can skip all bounds and null checks.

Immutable objects enforce inheritance so subclasses always keep the parent behavior.

Immutable objects use less memory because the compiler stores only a single copy.