Tagged articles
Single Responsibility
12 articles · Page 1 of 1
The article analyzes three harmful forms of improper encapsulation—over‑encapsulation, fake encapsulation, and chaotic encapsulation—illustrates each with Java code examples, explains the resulting development inefficiencies, extensibility issues, and debugging difficulties, and offers concrete principles to avoid these pitfalls.
EncapsulationJavaSingle Responsibility
0 likes · 12 min read

This article examines a Python function overloaded with flags, explains why such design harms readability, testability, and extensibility, and demonstrates step‑by‑step refactoring using descriptive helper functions, a pipeline approach, flexible step lists, and type annotations to produce clean, maintainable code.
PipelinePythonSingle Responsibility
0 likes · 5 min read

This article outlines six fundamental microservice splitting principles—including single responsibility, appropriate granularity, interface segregation, product impact avoidance, scalability, and fault tolerance—to help architects design maintainable, decoupled, and resilient services.
Single Responsibilityfault toleranceinterface segregation
0 likes · 5 min read

The article explains why maintaining clean code is essential, covering naming conventions, class design, function principles, and testing strategies, and provides concrete Java examples and refactoring techniques to help developers write readable, maintainable, and high‑quality software.
Clean CodeSingle Responsibilitynaming conventions
0 likes · 16 min read

This article explains why clean code matters, demonstrates how meaningful naming, single‑responsibility classes, well‑structured functions, and disciplined testing (TDD and the FIRST principles) improve readability, maintainability, and productivity, using concrete Java examples, refactorings, and step‑by‑step guidelines.
Clean CodeSingle ResponsibilityTDD
0 likes · 17 min read

The article presents a concise overview of core software architecture principles—including Dependency Inversion, Separation of Concerns, Inversion of Control, Dependency Injection, Single Responsibility, DRY, Open‑Closed, and many others—supplemented with Java code examples and references for deeper study.
Clean CodeDesign PrinciplesInversion of Control
0 likes · 12 min read

The article explains how breaking a monolith into microservices can introduce data consistency challenges, discusses the CAP theorem and Conway's law, and provides practical guidelines—such as single‑responsibility division, team‑aligned service boundaries, and appropriate use of BASE and distributed transactions—to split services responsibly.
CAP theoremConway's LawSingle Responsibility
0 likes · 11 min read

The article explains why excessively long classes violate design principles, cause readability and maintenance issues, and provides step‑by‑step refactoring techniques using IntelliJ IDEA to extract methods, move members, and split responsibilities for cleaner, more maintainable code.
IDEASingle Responsibilitycode quality
0 likes · 9 min read

This article explains three essential microservice design principles—single responsibility, high cohesion, and low coupling—along with practical guidelines such as hiding internal implementations, avoiding shared codebases, minimizing data exposure, and preferring asynchronous communication to ensure maintainable, scalable services.
Design PrinciplesSingle Responsibilityhigh cohesion
0 likes · 7 min read

This article walks through implementing Simple Factory and Factory Method patterns in Go, showing how to encapsulate object creation with a Food interface, concrete types, and factory structs, and explains the pointer vs value implementation rules and design‑principle benefits.
GoSimple FactorySingle Responsibility
0 likes · 7 min read

This article explains how to level up your CSS skills by using proper semantic markup, modular component structures, a unified naming system like BEM, and the single‑responsibility principle, providing practical code examples and visual illustrations for robust, maintainable front‑end styling.
BEMCSSSingle Responsibility
0 likes · 9 min read


21CTOAug 29, 2015 · Backend Development
An experienced backend engineer shares practical strategies to prevent service failures, covering third‑party distrust, user‑side safeguards, robust API design, traffic limiting, resource management, and architectural best practices such as single‑responsibility and avoiding single points of failure.
API DesignSingle Responsibilityfault tolerance
0 likes · 16 min read
