This article re-examines Dieter Rams' ten principles of good design through 28 comparative images of classic Braun and Vitsœ products alongside contemporary devices like the TP-7 recorder, Light Phone III, and Framework Laptop 12, exploring how innovation, usability, aesthetics, honesty, and repairability intersect in long-lasting design.
This article demonstrates how to simplify a deployment environment selector by removing redundant borders from containers and options, using background colors, spacing, and shadows to maintain clear grouping and selection states while preserving keyboard focus visibility.
This article teaches how to tailor screenshot scope and detail density to the target display size, using a pipeline-results card case study to show why full-page thumbnails fail and how to select, crop, and verify key fields so they remain legible at small dimensions.
This article demonstrates how to improve release checklist scannability by replacing generic bullet points with distinct status symbols (✓, ◷, ×) that match actual verification results, preserving semantic HTML structure and accessibility while avoiding false completion indicators.
This article demonstrates how adding a subtle left border to notification components improves visual hierarchy without changing content, comparing before/after designs and providing CSS implementation with usage principles for consistent emphasis.
This tutorial demonstrates why photography material quality must be verified before adjusting UI card decorations, showing how dark or compressed images lose critical detail that no border, shadow, or rounded corner can restore, and provides a practical checklist for photo selection and export.
This article details a methodology for organizing UI color systems by distinguishing structural, action, and status colors, covering role assignment, state mapping, scene calibration, and validation checklists to ensure clarity, accessibility, and scalable design consistency across platforms.
This article demonstrates how to create a reusable primary color scale by selecting a base color from actual UI components, defining light and dark endpoints, filling intermediate stops, and implementing them via CSS custom properties to ensure consistency across buttons, prompts, and text.
CSS custom propertiesDesign PrinciplesFrontend Development
This article demonstrates how adjusting internal and external spacing in deployment parameter forms clarifies field ownership, showing CSS grid implementation with 8px intra-field and 30px inter-field gaps, and validates the approach with long labels, multi-line errors, and lengthy inputs to ensure feedback stays associated with correct fields.
This tutorial demonstrates how to adjust headline size independently from body text and controls on narrow screens, using a release-notes component as a case study. It shows why uniform scaling fails, presents a design principle that larger elements have more reduction room, and provides CSS implementation with a before/after comparison and acceptance checklist.
This article demonstrates how to reduce redundant field labels in a service overview UI by grouping related data, using semantic formatting (e.g., '3 replicas' instead of 'Replicas: 3'), and preserving labels only where ambiguity exists, with a before/after case study and validation checklist.
This article demonstrates how to create effective visual hierarchy in UI design by combining font size, weight, and color instead of relying solely on size differences, using a release card case study with CSS implementation and validation checks.
This article analyzes a flight refund case where users lost money due to unclear UI, then derives three reusable principles for amount-sensitive interfaces: match user loss/gain mindsets, require effective confirmation before loss-making actions, and use neutral, specific language with clear action buttons.
The article analyzes Tendril Studio's visual designs for IBM's z17 and LinuxONE 5 servers, showing how they translate abstract computing power into tangible, rhythmic mechanical aesthetics—using color as state indicators, exploded views as causal explanations, and choreographed component movements as metaphors for openness—offering three reusable design principles for credible tech visualization.
The article demonstrates that although List.of, Arrays.asList, and unmodifiableList implement the List interface, they violate the Liskov Substitution Principle because their optional add/remove operations throw UnsupportedOperationException, revealing a hidden contract mismatch between interface documentation and runtime behavior.
This article uses a milk‑tea shop analogy and Java code examples to clearly illustrate the three core OOP concepts—encapsulation, inheritance, and polymorphism—showing how they solve data safety, code reuse, and flexible extension while highlighting common pitfalls.
This article explains the five SOLID object‑oriented design principles with everyday Java scenarios, showing bad implementations, proper refactorings, practical criteria for each rule, and common pitfalls to help developers write more maintainable and extensible code.
The article explains that design patterns rely on solid design principles—SRP, OCP, LSP, DIP, ISP, LoD, and CARP—using a flawed order‑processing example to show each principle, how to refactor the code, and why over‑engineering must be avoided.
AI can produce multi‑page prototypes in minutes, but this speed pushes product managers to focus on rigorous evaluation—assessing business logic, user flow, visual clarity, and interaction efficiency—using design principles like proximity, alignment, repetition, contrast, and a nine‑point checklist to ensure quality.
The article introduces the open‑source apple‑design Skill from the emilkowalski/skills repository (over 10.5 K stars), explains its 17 Apple‑inspired design principles covering animation, tactile feedback, material, layering and typography, and shows how AI agents can use the Skill to generate or audit UI interactions with concrete command‑line examples.
This article presents 50 concise statements that cover core software architecture concepts, including fundamentals, types, views, design principles, practical practices, distributed architecture basics, and the mindset needed for architects, providing a quick reference for beginners.
The Feadship F80 demonstrates that true luxury in a 24‑meter yacht comes from preserving iconic hull silhouettes, employing low‑profile and slender glazing, and re‑defining space order, rather than simply scaling down the features of larger vessels.
The article breaks down how car renderings can move from merely attractive to truly memorable by examining four visual steps—form, lighting, mechanical detail, and memory hook—through detailed comparisons of Pagani Utopia and the Batmobile, and offers a practical design checklist.
This article dissects Claude Code’s architecture—its atomic toolset, three built‑in subagents, hook system, skill structure, MCP integration, and CLAUDE.md contract—using an eight‑point checklist to show how Anthropic translates five design principles into concrete, observable engineering decisions.
This lesson distills five design principles, five over‑engineering signals, a decision‑matrix, and a ten‑point checklist for building effective Harness agents, illustrating each with concrete examples, trade‑offs, and practical guidance on when to use or avoid specific components.
The article explains the Development View— the "code floor plan" in the 4+1 view model—by detailing how code is organized, directory structures, module dependencies, build and packaging configurations, common architectural patterns, design principles, and practical solutions to typical problems such as circular dependencies and package chaos.
This article explains the difference between traditional object creation and Spring's IoC container, clarifies how IOC and DI relate, compares three injection methods, debunks common misconceptions, and shows how to swap implementations seamlessly, all with concrete Java code examples.
This article expands the SOLID principles into a three‑layer framework—class, pattern, and component levels—clarifying common misinterpretations, presenting correct definitions with concrete examples, and showing how GRASP and design patterns operationalize these principles for stable, low‑coupling software.
The article explores how Conway's Law—"organizations design systems that mirror their structure"—extends to large‑model agent architectures, offering concrete examples, role‑alignment strategies, concise communication patterns, and cautions against over‑engineering to improve multi‑agent collaboration.
The article dissects a failed Alibaba second‑round interview where the candidate answered only “vector‑search‑enhanced” for a RAG design, and then presents a systematic, four‑module RAG architecture together with six design principles, detailed indexing, query understanding, multi‑path recall, and context generation techniques to help candidates demonstrate comprehensive technical depth.
This article summarizes key insights from a design book covering design definition (Idea, Implementation, Interaction), conceptual integrity, design process models (Rational, Co-Evolution, Bazaar, Spiral), collaboration challenges, cognitive aspects (rationalism vs empiricism, user models, constraints, elegance), and practices for cultivating great designers through critique, varied experience, and protecting focus.
This article outlines seven practical design principles for building agentic AI experiences that operate invisibly within existing workflows, emphasizing systemic thinking, seamless integration, proactive collaboration, contextual continuity, reuse of familiar patterns, timely data collection, and transparent human control.
The article explains why returning a generic Result wrapper from a Java service layer breaks responsibility separation, harms reusability, complicates exception handling and testing, and obscures transaction boundaries, advocating for returning pure domain objects instead.
The article explores how chat‑style AI interactions create a comfortable experience by aligning user intent density with AI understanding, introduces the concept of intent‑information density matching, compares chat with one‑click generation, examines successful patterns like cursor tab completion and Granola notes, and offers design guidelines for appropriate interaction densities.
Most programmers never become architects because the role only fits a small fraction of teams, requires a system‑level mindset distinct from coding, and is limited by lack of real‑world architectural opportunities and the need for broader design thinking.
This article explains what constitutes a complex system, defines software architecture, explores various architecture types, outlines key design factors, presents analysis methods like DDD, and reviews typical solutions such as microservices, cloud‑native, DevOps, and big‑data architectures for building robust, scalable systems.
Complex systems are composed of many interacting components, and understanding their architecture—from business and application layers to technical, data, microservice, cloud‑native, and DevOps designs—requires grasping core principles, requirements, and design patterns that ensure reliability, scalability, and long‑term value.
This article explains why timely, clear, and appropriate feedback is essential for user interfaces, outlines a systematic process for identifying feedback nodes, classifying feedback types, and designing feedback expressions, and illustrates the approach with real‑world case studies from an AI voice‑cloning project.
The article argues that software architecture must be grounded in current conditions, not copied from past successes, and offers four practical recommendations on aligning design with implementation, market dynamics, team resources, and ecosystem considerations to ensure effective, adaptable product strategies.
This article demonstrates how to replace cumbersome if‑else chains in payment processing with Java enums that encapsulate behavior, leveraging functional interfaces, the strategy pattern, and Spring integration to achieve cleaner, extensible, and testable code while adhering to the Open/Closed principle.
Loose coupling, a design principle that minimizes inter-component dependencies, enables scalable, testable, and flexible systems by using clear interfaces, event-driven architectures, API gateways, and service meshes, while also presenting trade‑offs such as added complexity, performance overhead, and consistency challenges in distributed environments.
This article explains why developers should first grasp the seven SOLID principles before diving into design patterns, illustrating each principle with clear Java examples, before‑and‑after code, and practical benefits such as reduced risk, easier testing, looser coupling, and greater extensibility.
This article explains the essential components of software architecture—elements, structure, and connections—while presenting fifteen universal design principles, practical guidelines for monolithic, distributed, and microservice systems, and six common architectural mistakes to avoid, helping teams build scalable, reliable, and maintainable solutions.
This article explains the core concept of software architecture as elements, structure, and connections, distinguishes systems, subsystems, modules, components and frameworks, compares architecture classifications, describes the evolution from monolithic to distributed and microservice designs, presents fifteen practical design principles, and warns about six typical architectural pitfalls.
This article examines how software architecture can be made more efficient by focusing on three core dimensions—stability, performance, and code quality—offering practical insights, orthogonal design principles, and layered coding practices to achieve a robust, fast, and maintainable system.
This article explores the fundamental nature of software architecture by examining core models, the role of immutable and mutable elements, extension points, and how embracing simplicity can transform complex systems into elegant, adaptable solutions.
This article explores the essence of software architecture, tracing its definition, its role in solving division‑of‑labor challenges, and how a pragmatic, balanced design that treats architecture as software design itself can deliver sustainable value while navigating business complexity, team coordination, and evolving requirements.
In this talk, Lenovo HCI researcher Sun Jingwei explores how the rapid rise of large language models is shifting human‑computer interaction toward multi‑agent systems, presents two practical case studies—one enhancing cognitive diversity and another fostering emotional connection for seniors—and distills design principles and future AI‑for‑good directions.
This article guides engineers on evolving from merely executing requirements to creating business value by understanding the entire product lifecycle—covering requirement discovery, collaborative design, safe release, data‑driven operation, and continuous personal growth—offering practical questions and actionable principles for each stage.
This article outlines the definition, key design principles, and step‑by‑step process for creating robust application architecture, illustrated with a series of diagrams that guide developers through essential architectural decisions.
The article explores the broad, evolving nature of software architecture, emphasizing the need for contextual thinking, continuous learning, and understanding of architecture styles, characteristics, decisions, and design principles, illustrated with diagrams and key laws that guide architects in balancing trade‑offs and focusing on why over how.
This guide walks through enterprise data architecture fundamentals, covering core principles, design methods, step‑by‑step workflow, asset cataloging, conceptual and logical model creation, distribution blueprints, and cross‑domain theme modeling, ending with a concise summary.
This article examines the core design principles, modern best practices, and common hidden pitfalls of PHP interfaces in the 2025 ecosystem, providing concrete code examples and guidance on contract‑first design, single responsibility, interface segregation, dependency injection, versioning, testing, and advanced patterns such as adapters and plugin systems.
This article explains the five SOLID object‑oriented design principles, illustrates each with Python code examples, discusses their benefits, and offers practical advice for applying them effectively in Python development to build maintainable and scalable software.
The article explains that while encapsulation, inheritance, and polymorphism are often highlighted, true software craftsmanship hinges on the ability to abstract—identifying essential features, discarding irrelevant details, and modeling problem domains through steps like analysis, concept extraction, and system design, supported by principles such as low coupling, high cohesion, sufficiency, and completeness.
This article explains the role of the DWS layer in data warehouses, outlines design principles, step‑by‑step modeling, naming conventions, field design, provides concrete DDL/ETL examples, common pitfalls, and how to build reusable, performant summary tables for analytics.
The article explains that programming is fundamentally the combination of algorithms and data structures, breaks algorithms into control and logic, and argues that separating logic, control, and data—along with mastering essential design principles and data structures—is key to writing high‑quality, maintainable code.
This article explains how to design a modular Spring Boot backend management system called XiaoLe, covering essential design principles such as single responsibility, high cohesion, low coupling, reusability, clear interfaces, layered architecture, and testability, and provides detailed Maven module structures and POM configurations for each component.
The article outlines 38 actionable practices—ranging from treating technical debt like a loan and emphasizing simple, well‑named code to rigorous code reviews, systematic refactoring, comprehensive testing, automation, clear documentation, continuous learning, professional conduct, and solid design principles—to help teams reduce debt, improve quality, and sustain long‑term software health.
The article explains why architectural consistency—across style, implementation solutions, and formal design—is essential for preventing decay in evolving enterprise systems, and provides concrete practices such as unified patterns, standardized tech stacks, documentation, code reviews, and toolchain standardization to maintain flexibility and maintainability.
Understanding and applying the six core Java design principles—SRP, OCP, LSP, ISP, DIP, and LoD—helps developers write clearer, more extensible code, reduce complexity, lower maintenance costs, boost development speed, and improve team collaboration, forming a solid foundation for robust software.
This article explains what software architecture means, breaks down its constituent elements such as systems, modules, components and subsystems, and then details vertical layered architectures (including three‑layer and four‑layer models), horizontal modular architectures, complexity evaluation, design principles, and cross‑platform considerations for modern mobile applications.
This article explains the fundamentals of software architecture, covering its definition, key components such as systems, modules, components, and subsystems, and explores vertical (layered) and horizontal (modular) architectures, design principles, complexity evaluation, cross‑platform considerations, and practical guidelines for building maintainable applications.
This article examines the common benefits, drawbacks, and design principles of layered architecture across micro‑service, data‑warehouse, and protocol designs, illustrating each point with real‑world examples and offering practical guidance on when and how to apply layering effectively.
This comprehensive guide explains the value, classifications, styles, principles, and step‑by‑step workflow of icon design, offering practical standards and tips for creating consistent, recognizable, and brand‑aligned icons in contemporary user interfaces.
The article explains architectural thinking as a systematic approach to decompose problems, highlighting five core principles—abstraction, global perspective, layered design, evolutionary mindset, and standardization—that help engineers manage complexity, improve design quality, and adapt software systems over time.
This article introduces the key AI design principles from Google’s People + AI Guidebook and Microsoft’s Human‑Centred AI guidelines, covering explainability, privacy, user‑focused value, scenario‑based services, easy activation, and clear communication to help create intelligent, humane user experiences.
The article outlines ten design philosophies for operating systems—covering correctness, functionality, efficiency, fairness, layered architecture, the relativity of right and wrong, lazy copying, burden allocation, reserved space, illusion of infinite memory, space‑time trade‑offs, policy‑mechanism separation, simplicity, and moderation—illustrated with real‑world software architecture examples.
This article explains the five SOLID design principles—SRP, OCP, LSP, ISP, and DIP—detailing their definitions, common violations, and Java code examples that demonstrate how to refactor classes for better modularity, extensibility, and maintainability.
This article explores the definition, core characteristics, design principles, and emerging trends of tool‑type products—especially productivity software—highlighting how clear purpose, stable frameworks, efficient interaction phases, AI integration, PLG strategies, and cloud collaboration shape their success.
This article explores how a systematic, high‑dimensional view of software systems—covering system theory, architectural models like 4+1, C4 and TOGAF, micro‑service design, and the Cynefin complexity framework—helps developers move from code‑writing to strategic architecture while managing complexity.
This article outlines six core design principles—responsibility, mental‑model support, trustworthiness, diversity, co‑creation, and handling imperfection—each with practical strategies to help designers build safe, effective, and user‑centered generative AI experiences.
The article explains that data model design interview questions are open‑ended and lack a single correct answer, then outlines a structured approach covering model layering, domain division, naming conventions, and detailed design principles for dimension, detail, and summary layers, emphasizing real‑world scenarios and clear thinking.
This article explores the core concepts of software architecture, presenting various definitions from IEEE, Martin Fowler, Ralph Johnson and Neil Ford, and discusses architecture boundaries, the relationship between architecture and detailed design, patterns versus styles, and the knowledge models needed for architects and developers.
This article explains how entropy, the broken‑window effect, and accumulated complexity erode software systems, compares behavior and architecture value dimensions, and presents fundamental principles such as Ockham's razor, SOLID, layering, and anti‑corruption layers to build maintainable, low‑cost architectures.
This article explains essential software architecture concepts such as entropy and broken‑window effects, the sources and symptoms of complexity, the importance of orthogonality and consistency, and classic design principles like SOLID, DRY, and layered abstraction to guide architects in building maintainable, flexible systems.
This article explains the fundamental concepts of software architecture, distinguishes between systems, subsystems, modules, components, frameworks and architectures, outlines the evolution from monolithic to distributed and micro‑service designs, presents fifteen universal design principles, and highlights typical mistakes architects should avoid.
This article explains what layout design is, why it matters, and walks you through the four fundamental principles—contrast, alignment, grouping, and repetition—illustrated with real UI examples to help designers create clear, engaging, and visually balanced interfaces.
This article explains why user experience is crucial for middle‑platform systems, outlines the unique challenges they face, and provides a practical four‑step framework—including presentation, framework, structure, scope, and strategy layers—to design, implement, and measure effective UX improvements.
This guide shares practical methods for creating clear, attractive, and complete diagrams—covering code, architecture, business process, flow, and sequence charts—by applying four design principles, color‑wheel techniques, golden‑ratio composition, and an end‑to‑start mindset to improve developers’ visual communication.
This article explores the fundamentals of software architecture, discussing entropy, the dual value of behavior and structure, core design principles such as SOLID, DRY, layering, orthogonality, component coupling, boundary definition, communication patterns, and modeling tools, while also offering practical guidance for building maintainable systems.
The article explains that good software architecture must be deliberately designed and continuously refactored to combat entropy and the broken‑window effect, balancing behavior and architecture value while managing complexity through principles like Ockham’s razor, orthogonality, DRY, stable dependencies, layered abstractions, and clear boundaries, supported by UML visualizations.
This article explains the concept of layered architecture in software systems, covering common patterns like MVC and three‑tier designs, illustrating examples from networking and operating systems, and discussing the advantages, design considerations, potential drawbacks, and practical guidelines for implementing effective layer separation.
This article provides an extensive overview of software architecture, covering its definition, history, core concepts, design principles, complexity sources, design process, performance, high availability, scalability, and practical implementation techniques for large‑scale web systems.
This article presents a comprehensive guide to software engineering fundamentals, covering code review, documentation, SOLID, dependency inversion, error handling, logging, and many practical design principles that help developers write maintainable, testable, and adaptable code.
This article explains how to use the SOLID design principles—SRP, OCP, LSP, ISP, and DIP—in PHP, providing clear bad and good code examples for each principle to help developers write more reliable, extensible, and maintainable backend applications.
This article explains the logical framework of software analysis and design, outlines practical methods and principles, introduces essential UML tools, and demonstrates the concepts with two concrete case studies—a logging framework and a task‑scheduling framework—providing a complete guide for developers.
This article examines a Java settlement calculation method, identifies duplicated code and divergent change code smells, and demonstrates a refactoring using maps and enum‑based calculators to improve readability, maintainability, and adhere to object‑oriented principles.
The author revisits two concise yet powerful books—‘Microservice Design’ and ‘Systems Thinking’—explaining how the former guides architects through microservice boundaries, deployment, and scaling, while the latter offers a systematic mindset for designing and governing complex software systems, making both indispensable for modern architects.
The article likens blind adoption of Domain‑Driven Design to Forrest Gump’s run, explains how tangled business logic and over‑abstracted layers increase maintenance, shows DDD’s role in clarifying domains and mapping SOLID principles, offers practical tips for splitting responsibilities and building reusable capabilities, and concludes DDD is a valuable—not magical—lens for sustainable, extensible software.
Systems Theory, originating in the 1940s, provides a holistic framework for understanding and designing complex software architectures, emphasizing component interaction, feedback, and adaptability, with practical examples ranging from microservices and Kubernetes to chaos engineering, illustrating its impact on scalability, resilience, and modular design.
The article systematically defines software architecture, distinguishes systems, subsystems, modules, and components, compares frameworks with architectures, explores TOGAF and RUP classifications, traces the evolution from monoliths to micro‑services, and presents concrete design principles and common pitfalls for building scalable, maintainable systems.
This article translates the "16 Little UI Design Rules" into practical guidelines, showing how applying spacing, consistency, contrast, typography, and accessibility principles can dramatically improve the usability and visual hierarchy of a short‑term rental property detail page.
This article explains Jakob Nielsen’s ten usability principles—covering visibility, real‑world relevance, user control, consistency, error tolerance, easy access, flexibility, simplicity, problem‑solving help, and human‑centered assistance—to guide designers in creating intuitive, efficient user interfaces.
The article explains what constitutes a complex system, defines software architecture, outlines its essential elements, categorizes various architecture types, discusses key factors such as functional and non‑functional requirements, and presents design principles and typical solutions for building robust, scalable systems.
This article explains what complex systems and software architecture are, outlines various architectural categories, discusses essential functional and non‑functional requirements, and presents design principles and typical solutions such as domain‑driven design, microservices, cloud‑native, DevOps, and big‑data architectures for building stable, scalable, and maintainable systems.
This article explains the five SOLID design principles—Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion—using clear TypeScript examples to show how each principle improves code maintainability and extensibility.
This article outlines four foundational design principles—user‑intent‑driven design, context awareness, atomic capability mapping, and language‑API integration—for building LLM‑centric software architectures, illustrating each with DSL examples, Kotlin implementations, and practical insights on prompt engineering, dynamic context layering, and API evolution.
This article explains what complex systems are, defines software architecture, explores its essence and classifications, outlines key architectural factors, and presents design principles and typical solutions such as domain‑driven design, microservices, cloud‑native, and big‑data architectures.