This article explains the core software design principles KISS, DRY, and SOLID, shows why they matter for readability and maintainability, provides concrete Java examples and step‑by‑step guidelines, and lists actionable rules developers can follow to write cleaner, more reusable code.
This article distills the classic "Effective Java" book into twenty‑seven practical programming principles covering object construction, static factory methods, builders, enums for singletons, resource management, equals/hashCode, generics, method design, exception handling, and general coding best practices, providing clear guidance for Java developers.
This article explores how developers can master coding skills by cultivating learning awareness, choosing good role models, applying knowledge in real projects, avoiding cognitive traps, and practicing systematic refactoring, all illustrated with practical examples and a RocketMQ case study.
This article explores how developers can master code quality by adopting a learning mindset, studying exemplary code, applying core programming principles, analyzing real‑world examples such as RocketMQ file‑warming, and finally refactoring code to improve maintainability and performance.
This article compiles essential programming principles such as KISS, DRY, YAGNI, and others, explaining their origins, practical advice, and additional design guidelines to help developers write simpler, more maintainable, and less error‑prone code.
This article explains essential software design principles such as KISS, DRY, YAGNI, and additional guidelines for writing maintainable, simple code, while also warning against over‑engineering and emphasizing the importance of testing, clear communication, and minimal coupling in everyday programming practice.
This article presents a concise collection of essential programming principles—including KISS, DRY, YAGNI, writing code for maintainers, lazy development, and testing discipline—explaining their origins, practical applications, and how they help developers produce simpler, more maintainable, and higher‑quality software.
This article outlines essential programming principles—including KISS, DRY, YAGNI, and Code for the Maintainer—explaining their origins, practical applications, and how they help developers write simpler, more maintainable, and less error‑prone software.
This article compiles essential programming principles such as KISS, DRY, YAGNI, and Code for the Maintainer, explains their origins, practical applications, and concrete guidelines to help developers write simple, maintainable, and efficient code while avoiding unnecessary complexity.
This article presents a comprehensive overview of essential programming principles—including KISS, YAGNI, separation of concerns, DRY, SOLID, inversion of control, and the scout rule—explaining why each matters and offering practical guidance on how to apply them to write clean, maintainable software.
This article compiles core programming principles such as KISS, YAGNI, Separation of Concerns, DRY, Inversion of Control and the SOLID rules, explaining why each matters, how to apply them, and providing reference links for deeper study.
This article explains the six core SOLID principles—Single Responsibility, Interface Segregation, Dependency Inversion, Liskov Substitution, Law of Demeter, and Open/Closed—detailing their definitions, benefits, practical examples, and how they improve code reusability, readability, maintainability, and system extensibility.
This article explores the most famous software development laws—from Murphy's Law to Moore's Law—explaining their meanings, origins, and practical implications for coding, project management, and system design.
This comprehensive guide covers essential software development principles, processes, daily tools, runtime environments, third‑party services, data handling, Java language and JVM intricacies, system architecture evolution, and a typical deployment stack for building robust backend applications.
This article identifies why most code remains low‑quality despite many guidelines and presents four practical principles—single abstraction level, minimized indentation, clear expressions, and effective use of helper classes—that dramatically improve a team's coding standards.
This article presents eighteen core programming principles—from DRY and KISS to the Open/Closed and Law of Demeter—that help developers write cleaner, more maintainable code, reduce bugs, and adapt to change effectively.
A humorous story about a graduate student’s unreadable code illustrates why naming is the toughest programming challenge, and the article then outlines six clear principles—avoiding metaphors, keeping names short, shortening expressions, using active voice, steering clear of jargon, and breaking rules when necessary—to improve code readability and maintainability.
The article distills 17 career‑tested principles for developers, urging them to prototype for real customer needs, treat security as inevitable and strategic, prioritize simple, well‑logged code, continuously learn, adapt to change, evaluate context‑specific solutions, deliver results that satisfy clients, and choose projects wisely.
