Tagged articles
Single Responsibility Principle
15 articles · Page 1 of 1
The article argues that in AI-native development, value lies not in generating more specification documents but in creating a traceable artifact chain linking business intent, requirements, design, plans, code, and evidence — with clear authoritative sources, state management, and dependency-based invalidation propagation to prevent agents from working on stale rules.
AI-native developmentArtifact ChainEntry-Exit Criteria
0 likes · 14 min read

The article walks through a real e‑commerce payment case, showing how Domain‑Driven Design models entities, uses two key questions to split responsibilities, and continuously evolves the model to accommodate discounts, VIP features, and new payment adapters, reducing code churn.
DDDSingle Responsibility Principledomain-driven design
0 likes · 6 min read

The article recounts a 12,000‑line UserService.java file, explains how the overly generic name masks multiple responsibilities, violates the single‑responsibility principle, and creates a distributed monolith, then shows how domain‑driven naming and bounded‑context splitting can restore clear architecture.
Single Responsibility Principledomain-driven designmicroservices
0 likes · 8 min read

This article explains how the Single Responsibility Principle applies to React components, shows a common anti‑pattern with a monolithic component, and demonstrates a cleaner architecture using custom hooks, presentation components, and container components for better maintainability.
Frontend ArchitectureReactSingle Responsibility Principle
0 likes · 6 min read

The article explains how applying the Single Responsibility Principle to break down interfaces and then recombining them through inheritance or aggregation creates higher‑level abstractions that keep code maintainable, extensible, and expressive in complex software systems.
GoInterface CompositionObject‑Oriented Design
0 likes · 6 min read

This article explains the Single Responsibility Principle, its core idea, why it should be followed, its three main benefits, and provides UML class diagrams and Java code examples that demonstrate how to split responsibilities into dedicated classes for clearer, more maintainable software.
Code ExampleJavaSRP
0 likes · 9 min read

The article explains the drawbacks of excessively long classes—poor readability, difficult extension, redundant code, and violated responsibilities—and provides step‑by‑step refactoring techniques using IntelliJ IDEA to extract methods, move members, and create new classes for cleaner, maintainable code.
IntelliJ IDEASingle Responsibility Principleclass design
0 likes · 8 min read

This article explains what Python descriptors are, why they help follow the Single Responsibility Principle, and demonstrates how to replace repetitive property setters with reusable descriptor classes such as a fuel‑capacity validator and a generic range‑checking descriptor.
PropertySingle Responsibility Principledescriptors
0 likes · 4 min read

The article explains the problems caused by overly long classes—poor readability, difficult extension, redundant code, and violated design principles—and provides a step‑by‑step guide using IntelliJ IDEA to extract redundant code, rename methods, move members, and split responsibilities into new classes for cleaner, maintainable software.
IDEASingle Responsibility Principleclass design
0 likes · 8 min read

The article explains the drawbacks of overly long classes—poor readability, difficult extension, redundant code, and violation of the Single Responsibility Principle—and provides step‑by‑step refactoring techniques using IntelliJ IDEA such as extracting methods, moving members, and creating new classes.
IDEAJavaSingle Responsibility Principle
0 likes · 7 min read

The article explains why excessively long classes hinder readability and extensibility, outlines the problems caused by redundant code and violated design principles, and provides a step‑by‑step guide using IntelliJ IDEA to extract methods, move members, and create new classes for cleaner, maintainable code.
IntelliJ IDEASingle Responsibility Principleclass design
0 likes · 9 min read

The article explains why excessively long classes with many responsibilities hinder readability and extensibility, outlines the problems of redundant code and SRP violations, and provides practical refactoring techniques—such as extracting methods, moving members, and creating new classes—using IntelliJ IDEA.
IntelliJ IDEASingle Responsibility Principleclass design
0 likes · 11 min read

This article explains why excessively long classes are hard to read and extend, outlines the problems caused by redundant code and multiple responsibilities, and provides step‑by‑step refactoring techniques using IntelliJ IDEA to extract methods, move members, and create new classes.
IDEAJavaSingle Responsibility Principle
0 likes · 8 min read

Long, monolithic Java classes with hundreds of methods become unreadable, hard to extend, and prone to redundant code, so this guide explains the drawbacks of oversized classes and provides step‑by‑step refactoring techniques using IntelliJ IDEA to extract methods, move members, and create new classes.
IDEAJavaSingle Responsibility Principle
0 likes · 8 min read

The article explains how over‑complex mental models, poor translation of semantic ideas into code, inadequate naming, missing design chunks, unclear usage patterns, and lack of smooth model transitions cause code to decay, and offers practical principles such as DDD, SRP, good naming, testing, and reusing existing algorithms to maintain readability.
Code ReadabilityMental ModelsSingle Responsibility Principle
0 likes · 10 min read
