Tagged articles
KISS
28 articles · Page 1 of 1
The article uses a classic story of a diligent developer who over‑designed a system to illustrate the dangers of excessive architecture, then outlines agile principles such as YAGNI, KISS, MVP, just‑in‑time design, evolutionary practices, technical‑debt management, and a decision checklist to help teams build just‑enough, maintainable solutions.
AgileKISSMVP
0 likes · 10 min read

The article argues that merely knowing popular coding principles is insufficient, and it provides concrete decision frameworks, code examples, and trade‑off analyses for DRY, KISS, YAGNI, POLA, the Boy Scout Rule, Fail‑Fast, and Separation of Concerns so developers can choose when to abstract, simplify, defer implementation, ensure expected behavior, improve incrementally, expose errors early, and isolate change boundaries.
DRYKISSPOLA
0 likes · 14 min read

The article explains that developers often memorize dozens of rules such as DRY, KISS, YAGNI, SOLID, and CAP, yet still produce poor code because they misunderstand the original intent of these principles, illustrating the pitfalls with concrete examples, classic laws like Brooks' Law, and how mis‑interpretations cascade through design, architecture, and measurement practices.
CAP theoremDRYKISS
0 likes · 17 min read

The article explains the YAGNI principle, showing how focusing on current requirements, using simple solutions, and refactoring when real needs arise can prevent over‑engineering, reduce technical debt, and keep Java code clean and adaptable.
DRYJavaKISS
0 likes · 7 min read

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.
Clean CodeDRYKISS
0 likes · 19 min read

This article explores why simplicity is essential in software development, examines the distinction between essential and accidental complexity, presents real‑world case studies of product and code complexity, and offers practical guidelines such as KISS, single‑responsibility, API minimization, and automation to achieve more maintainable and understandable systems.
API DesignKISScode simplicity
0 likes · 24 min read

The article humorously chronicles a series of real‑world over‑design incidents—excessive microservice splitting, needless multi‑database sharding, ubiquitous message‑queue usage, over‑engineered caching, design‑pattern abuse, and bloated database schemas—highlighting why simplicity (KISS) remains the best practice for backend systems.
CachingDatabase DesignKISS
0 likes · 11 min read


DevOpsNov 23, 2023 · Fundamentals
This article explains the KISS (Keep It Simple, Stupid) principle, outlines its core ideas, presents best‑practice guidelines and common anti‑patterns, and demonstrates how to refactor an over‑engineered Java DAO into a concise, maintainable implementation.
Best PracticesCode SimplificationDAO
0 likes · 9 min read

The article explains why maintainable, human‑readable code matters for evolving software, outlines core concepts like high cohesion and low coupling, details the SOLID and other practical principles, and describes common refactoring techniques to improve readability and flexibility.
DRYKISSSOLID
0 likes · 6 min read

This article explains why maintainable, robust, and testable code is essential for front‑end development, shares insights from renowned programmers, defines key quality metrics, outlines SOLID and KISS design principles, identifies common code smells, and demonstrates practical refactoring patterns with real JavaScript examples.
Design PrinciplesKISSSOLID
0 likes · 35 min read

The article examines whether over‑designing code adds value by exploring core software design principles such as KISS, YAGNI, DRY, and Simple Design, illustrating each with concrete examples, refactoring snippets, and practical guidelines to help developers balance simplicity and functionality.
DRYKISSYAGNI
0 likes · 9 min read

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.
Code MaintainabilityDRYKISS
0 likes · 10 min read

This article compiles essential software development principles such as KISS, DRY, YAGNI, Code for the Maintainer, and related guidelines, explaining their origins, practical applications, and why adhering to them leads to simpler, more maintainable, and higher‑quality code.
Best PracticesDRYKISS
0 likes · 12 min read

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.
Code MaintainabilityDRYKISS
0 likes · 11 min read

Learn how to write readable, maintainable, and reusable methods by applying core design principles such as Single Responsibility, KISS, and DRY, along with practical naming conventions, parameter handling, method size guidelines, and code structuring techniques illustrated with Java examples.
Clean CodeDRYDesign Principles
0 likes · 17 min read

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.
Clean CodeDRYKISS
0 likes · 12 min read

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.
Clean CodeCode MaintainabilityDRY
0 likes · 11 min read

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.
Code MaintainabilityDRYKISS
0 likes · 12 min read

This article explains how to keep software architecture simple and appropriate by applying KISS principles, balancing completeness, flexibility, and lightness, outlines when pre‑design is sufficient or excessive, presents core design principles such as SOLID, N+1, statelessness, and details a six‑step C4‑based design and review process.
AgileC4Design Principles
0 likes · 14 min read

This article presents thirty concise architectural principles—ranging from KISS and YAGNI to distributed system design, user experience, and configuration management—explaining each rule, offering practical commentary, and showing how they guide architects to build simple, maintainable, and scalable software systems.
Design PrinciplesKISSMVP
0 likes · 12 min read

This article explains core software design principles—including KISS, DRY, high cohesion/low coupling, separation of concerns, YAGNI, the Boy‑Scout rule, and the SOLID rules—detailing their motivations, practical guidelines, benefits, and common pitfalls for creating maintainable, flexible code.
Clean CodeDRYKISS
0 likes · 27 min read

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.
Clean CodeKISSSOLID
0 likes · 17 min read


21CTODec 24, 2020 · Backend Development
The author reflects on returning to Java after three years, arguing that despite the rise of containers and micro‑services, Java’s performance, threading model, and mature ecosystem keep it relevant, while criticizing Spring’s complexity and advocating a simple, KISS‑driven approach.
JavaKISSSpring
0 likes · 8 min read

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.
Best PracticesKISSSOLID
0 likes · 25 min read

The article argues that code should primarily be written for human readers, emphasizing principles like KISS and DRY, thoughtful commenting, avoiding TODOs, and the necessity of unit tests, while acknowledging trade‑offs and offering practical guidance for producing maintainable, elegant software.
Clean CodeCode ReadabilityDRY
0 likes · 12 min read

This article explores why clean, readable code matters, explains key principles such as KISS and DRY, discusses the role of comments, unit tests, and avoiding TODOs, and offers practical advice for developers to improve code quality and long‑term maintainability.
Best PracticesClean CodeDRY
0 likes · 11 min read

The article explores the Unix philosophy, emphasizing the KISS "keep it simple" principle and detailing four practical guidelines—clarity, modularity, composition, and optimization—that help developers build clean, maintainable software.
KISSfundamentalsphilosophy
0 likes · 4 min read

This article summarizes key software design principles such as DRY, KISS, SOLID, New Jersey style, Separation of Concerns, and YAGNI, explaining their meanings, benefits, and practical code examples for writing cleaner, more maintainable code.
DRYDesign PrinciplesKISS
0 likes · 10 min read
