The article argues that complexity in software systems is unavoidable and must be consciously placed, managed, and reduced through thoughtful architectural decisions, prioritizing high‑frequency changes, eliminating duplication, and accepting that perfect local consequences are impossible.
The article argues that complexity is an unavoidable aspect of software development and architecture, urging engineers to acknowledge, manage, and strategically place it rather than trying to eliminate it, while illustrating the trade‑offs in tooling, abstractions, and micro‑service design.
The article examines the common belief that reuse improves productivity, explains the logical fallacies behind it, highlights the hidden costs of over‑generalization, and proposes autonomy and consistency metrics as practical guidelines for evaluating when reuse truly adds value.
This article outlines eight enduring ideas—from designing for Moore's Law and using abstraction to speeding up common cases, leveraging parallelism, pipelining, prediction, memory hierarchy, and redundancy—that have shaped computer architecture over the past six decades.
This article provides a comprehensive overview of software architecture, defining core concepts such as system, subsystem, module, component, framework, and architecture itself, and detailing the various layers—including business, application, data, code, technical, and deployment architectures—along with their design principles and practical considerations.
This article outlines six key software architecture principles—including reuse before build, cloud‑first design, scalability, simplicity, API‑first strategy, and frequent small releases—to help teams create cost‑effective, maintainable, and future‑proof applications.
The article explains how understanding user psychology—such as perception, reading, and memory—can guide industrial design to create more satisfying experiences, improve retention, and increase software activity by aligning design elements with users' mental expectations.
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.
The article presents thirty concise architectural principles covering simplicity, iterative development, automation, ROI, user focus, concurrency, distributed system design, configuration management, and practical guidance, aiming to help architects and developers build maintainable, scalable, and user‑centric software systems.
This article explains the origins and principles of modular design, outlines its four key attributes—agility, flexibility, richness, and extensibility—and demonstrates how applying a modular approach can accelerate product updates and improve user experiences across online and offline scenarios through real‑world case studies.
This extensive article discusses essential software engineering concepts such as code review value, architectural principles, SOLID, dependency inversion, documentation practices, testing strategies, and practical guidelines for writing maintainable, decoupled, and self‑explanatory code across various programming languages.
This article translates Mahesh Balakrishnan’s 42 practical lessons on building a production database, covering customer focus, project management, design principles, code review, strategy, observability, and research, offering actionable guidance for infrastructure engineers and architects.
This article explains the concept of software‑architecture tradeoffs, why they are inevitable, the key system attributes involved, and how architects can consciously balance scalability, simplicity, interoperability and other “‑ilities” to make informed design decisions.
This article explains the importance of solid software design principles—covering readability, reusability, extensibility, maintainability, cohesion, coupling, and the seven SOLID rules—to help developers create flexible, robust, and easy‑to‑maintain systems.
This article traces the rise, fall, and resurgence of skeuomorphic design—from its decorative origins in ancient artifacts and early automobiles to its pivotal role in early graphical user interfaces, the flat‑design backlash, and its renewed relevance in modern mobile, AR, and VR experiences.
This article explores the concept of software architecture, its relationship to business, key design principles such as SOLID and Ockham's razor, various architectural styles like layered, hexagonal, and onion, and illustrates how a real‑world navigation engine team applied domain‑driven design to restructure their codebase.
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.
This article explains how to design robust technical architectures by applying strategic principles of suitability, simplicity, and evolution, alongside tactical guidelines for high concurrency, high availability, and business design, and illustrates the concepts with logical and physical architecture diagrams.
Design principles can be flexibly applied alone or in combination, guiding designers toward better solutions and improved user experience, while learning them requires continual practice, reflection on personal projects, and competitive analysis to internalize and effectively employ these fundamentals.
This article traces the evolution of software development—from machine language and assembly to high‑level languages—explores the two software crises, explains why software architecture emerged, and clarifies core concepts such as systems, subsystems, modules, components, frameworks, and architecture itself.
This article explains the importance of inclusive design for B2B products, outlines core design principles, and provides practical strategies based on user research and persona analysis to ensure accessibility for diverse users ranging from young professionals to senior shoppers.
This article explains how technical architecture transforms product requirements into concrete systems, tackles uncertainty in technology choices, and presents strategic principles—fit, simplicity, evolution—alongside tactical guidelines for high concurrency, high availability, and business design, supported by logical and physical diagram examples.
This article explains how to design robust technical architectures by addressing strategic principles such as suitability, simplicity, and evolution, and tactical guidelines covering high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams for real‑world systems.
This article describes how a mobile development team refactored a card‑creation feature by applying the Open/Closed and Single‑Responsibility principles, introduced a factory pattern with reflection, and ultimately built a fully automated dynamic injection framework using Java Annotation Processing (APT) to eliminate manual code updates.
This article presents thirty practical software‑architecture principles—from keeping designs simple and avoiding unnecessary features to mastering concurrency, distributed systems, and user experience—providing a comprehensive guide that helps architects make informed, ROI‑driven decisions while fostering scalable, maintainable solutions.
This article presents thirty concise architectural principles covering simplicity, YAGNI, iterative development, testing, ROI, user focus, modular design, configuration, server concurrency, distributed system challenges, and user experience, offering practical guidance for engineers to build scalable, maintainable software systems.
This article explains why interaction animation is crucial for large‑screen mobile UX, outlines ten animation design principles, showcases common animation patterns such as progressive, scaling, overlay, transition, loading, and guide effects, and recommends tools like Bézier‑based editors and Principle for creating polished motion designs.
This comprehensive guide explains the definition of software architecture, its essential concepts, layered classifications, various architecture levels, evolution from monolith to microservices, common pitfalls, and metrics for evaluating architectural soundness, providing practical insights for architects and developers alike.
The article examines the practical difficulties of integrating services within a microservice architecture—such as circular dependencies, third‑party system coupling, and non‑idempotent APIs—and proposes concrete design principles like one‑way dependencies, minimal redundant data, façade services, idempotency, and contract testing to preserve system health.
The article presents thirty practical architectural principles—ranging from simplicity, YAGNI, iterative development, automated testing, and ROI to server concurrency, distributed system design, user experience, and configuration management—aimed at guiding engineers and teams toward robust, scalable, and maintainable software solutions.
This article presents thirty practical software architecture principles—ranging from simplicity and YAGNI to distributed system design, user experience, and configuration management—offered by architect Srinath to guide teams in making better technical decisions and fostering collaborative, high‑quality product development.
Senior architect Srinath presents thirty practical software architecture principles covering simplicity, YAGNI, iterative development, automated testing, ROI, user focus, modular design, concurrency, distributed systems, and user experience, offering a comprehensive guide for developers and teams to build robust, maintainable systems.
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.
This article presents thirty practical software architecture principles—from simplicity and YAGNI to distributed system design and user experience—offering actionable guidance for engineers to shape robust, maintainable, and user‑centric systems.
The article presents thirty concise architectural principles—ranging from simplicity, YAGNI, iterative development, automated testing, ROI, user‑centric design, modularity, to distributed system concerns like statelessness, idempotency, CAP theory, and configuration best practices—offered as a practical guide for architects and development teams.
This article explains the essential concepts of software architecture, differentiates systems, subsystems, modules, components, frameworks and various architecture layers—including business, application, data, code, technical, and deployment—while describing design principles, evolution from monoliths to micro‑services, and how to evaluate a good architecture.
This article explores user experience from a front‑end perspective, defining UX, examining the many factors that influence it—including user state, environment, and product features—and outlining practical design considerations such as performance, interaction details, and accessibility to create truly engaging digital products.
This article explains the essence of software architecture, covering definitions, system vs. subsystem, module vs. component, framework vs. architecture, various architectural layers, classifications, evolution from monolith to microservices, and how to evaluate a design’s suitability for business and non‑functional requirements.
This article presents thirty concise software architecture principles—ranging from KISS and YAGNI to distributed system consistency and user‑experience guidelines—offered by architect Srinath to help teams adopt a gardener‑like, iterative, and pragmatic approach to building scalable, maintainable, and user‑centric systems.
This article explains how technical architecture transforms product requirements into implementation by addressing layering, language choices, and non‑functional concerns, and introduces strategic principles of suitability, simplicity, and evolution along with tactical guidelines for high concurrency, high availability, and business design.
The article details how a business‑oriented company built an architecture committee, secured leadership support, defined clear design principles, restructured a monolithic common package into modular base projects, and used concrete case studies and team‑wide promotion to successfully evolve its technical architecture.
This article explains how to design robust backend technical architectures by addressing strategic principles such as suitability, simplicity, and evolution, and tactical guidelines covering high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams and practical implementation tips.
This article explores the concept of visual subtext in UI design, explaining why designers should consider hidden cues, defining subtext, and illustrating its three main functions—conveying hidden information, building emotional connections, and reducing cognitive load—through real game‑interface case studies.
This article explains the essence of software architecture, its core principles, the distinction between development and architecture design, and presents a methodology based on TOGAF and the ADM cycle, covering business, data, application, and technology architecture domains.
This article explains how to transform product requirements into robust technical architectures by addressing uncertainty through strategic principles—suitability, simplicity, evolution—and tactical guidelines covering high concurrency, high availability, and business design, illustrated with logical and physical diagrams.
This article explores how to transform product requirements into robust technical architectures by addressing uncertainty, outlining strategic principles—appropriateness, simplicity, evolution—and tactical guidelines for high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams.
This article explains how to design a stable and high‑performing software architecture by addressing uncertainty through strategic principles—fit, simplicity, evolution—and tactical guidelines covering high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams.
The talk demonstrates how to apply Domain‑Driven Design and microservice architecture to an e‑commerce voucher platform by defining problem spaces and bounded contexts, prioritizing boundaries over aggregates, using layered‑on‑demand infrastructure, and following SOLID principles to achieve clear, maintainable services.
This article explains why quickly delivering key information—through visual focal points, pre‑thinking structures, and Miller's Law—significantly improves user experience and conversion rates in service‑type apps, illustrated with real‑world design case studies.
This article traces the evolution of programming paradigms—from low‑level machine code through procedural and object‑oriented approaches—explains the pitfalls of poor abstraction, introduces domain‑driven design, and reviews key software design principles such as SOLID, OCP, DIP, PLOA and KISS.
This article explains why developers and leaders must practice thorough code reviews, outlines common pitfalls such as duplicated code and premature optimization, and shares concrete Go examples and timeless engineering principles—like KISS, composition over inheritance, and transparent design—to help teams build maintainable, high‑quality software.
This article explains architecture design, covering its definition, core principles, goals, the 4+1 view method, classifications of monolithic and distributed architectures, common system architecture patterns, business analysis techniques, domain‑driven design, DSL concepts, and organizational structures for development teams.
This article explores how to transform product requirements into robust technical architectures by outlining strategic principles—appropriateness, simplicity, evolution—and tactical guidelines such as high concurrency, high availability, and business design, while addressing uncertainty, component complexity, and practical implementation with Java‑centric examples.
This article explains how to design robust technical architectures by applying strategic principles of suitability, simplicity, and evolution, and tactical principles covering high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams and offering practical implementation advice.
This article outlines strategic and tactical design principles for technical architecture, covering suitability, simplicity, evolution, high concurrency, high availability, and business design, and explains how to create logical and physical architecture diagrams to guide robust system construction.
This article presents a comprehensive set of strategic and tactical design principles for technical architecture, covering suitability, simplicity, evolution, high‑concurrency, high‑availability, and business design, and illustrates their application through logical and physical architecture diagrams.
This article outlines essential strategic and tactical principles for technical architecture, addressing uncertainty in technology choices, and detailing the suitability, simplicity, and evolution principles, as well as high‑concurrency, high‑availability, and business design guidelines to build stable, scalable systems.
This article explores how to transform product requirements into robust technical architectures by addressing uncertainty, outlining strategic principles—appropriateness, simplicity, evolution—and tactical guidelines for high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams and offering practical design recommendations.
This article presents 30 widely‑accepted software architecture principles—grouped into basics, feature selection, server design, distributed systems, user experience, and challenges—to help architects act as gardeners who shape, refine, and sustain robust, maintainable systems.
This article explains how a well‑designed workbench for a B2B customer service system can standardise workflows, improve task completion for both frontline agents and supervisors, and enhance overall service quality through user‑centred research, flexible architecture, and thoughtful visual communication.
This article explains how to design a stable and high‑performing software architecture by addressing strategic principles—suitability, simplicity, evolution—and tactical guidelines for high concurrency, high availability, and business‑oriented design, while illustrating logical and physical architecture diagrams.
This article explains how B‑side (enterprise) product design differs from C‑side (consumer) design in target users, design thinking, scenarios, core value and principles, and provides a step‑by‑step guide for designers to quickly grasp complex B‑side business requirements.
This article analyzes the root causes of low‑quality code—such as poor naming, tangled structure, and weak scalability—then presents practical ways to improve code quality through domain modeling, SOLID design principles, and design patterns, illustrated with real‑world case studies.
The article explains how the thermodynamic entropy principle inspires software architecture design, emphasizes abstract thinking and domain‑driven design, compares monolithic and microservice approaches, outlines microservice benefits and distributed‑system design principles, and discusses the complementary role of middle‑platform architecture in modern backend development.
This article explains why Spotify needed new design principles, how the team collaboratively created the concise rules of relevance, humanity, and consistency, and the impact these principles have on design quality, evaluation standards, and cross‑platform brand unity.
The article explains how software degradation occurs as systems evolve, why domain‑driven design combined with a two‑step refactoring approach can maintain high‑quality design, and demonstrates these concepts through an e‑commerce payment case study, covering principles like OCP, SRP, and micro‑services.
This article explains software architecture design by defining its essence, contrasting it with ordinary software development, outlining three core principles—appropriateness, simplicity, and evolution—and detailing the TOGAF/ADM methodology and its business, data, application, and technology domains for building robust, adaptable systems.
This article explains the five architectural views—logical, development, runtime, physical, and data—clarifies the distinction between software and system architecture, discusses tier versus layer concepts, outlines the benefits of logical and physical layering, and describes the various kinds of architects and their responsibilities.
This article presents a comprehensive overview of essential software architecture principles—including Single Responsibility, Open‑Closed, Liskov Substitution, Interface Segregation, Dependency Inversion, KISS, and others—illustrated with Java code examples and practical advice for building maintainable, extensible backend systems.
The article examines three levels of packaging tear‑experience design—basic, intermediate and advanced—and extracts three key principles—natural, smooth, and realistic—that can be applied to improve VR product interfaces, illustrating each with concrete examples and visual illustrations.
This article introduces the core concepts of algorithms, covering their definition, five essential properties, design principles such as correctness and readability, methods for analyzing time and space complexity, common complexity classes, and a variety of algorithmic strategies including recursion, dynamic programming, greedy and divide‑and‑conquer techniques.
This article provides a comprehensive overview of algorithms, covering their definition, five essential characteristics, design principles, time and space complexity analysis, common complexity classes, and a variety of algorithmic strategies such as recursion, greedy, divide‑and‑conquer, and dynamic programming.
This article shares a senior backend engineer's insights on why code review is essential, common pitfalls that degrade code quality, and a set of concrete principles—ranging from simplicity and composition to transparency and error handling—to guide developers in writing maintainable, scalable Go code and robust system designs.
This article provides a comprehensive overview of behavioral design patterns—including Chain of Responsibility, Command, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—explaining their motivations, class diagrams, advantages, disadvantages, and typical scenarios for applying each pattern in software development.
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.
The article explains Gaode Maps’ AR navigation design, detailing how environmental factors, spatial experience, color hierarchy, safety considerations, and competitor insights shape a six‑point design framework, and describes prototype testing, implementation strategies for overlapping alerts, and future prospects such as virtual road barriers and multimodal travel.
The article explains why engineers and leaders must perform code reviews, outlines common pitfalls such as duplicated code, premature optimization, and poor design, and presents concrete principles—KISS, composition, transparency, and error handling—backed by Go examples and Unix philosophy to help teams produce maintainable, high‑quality software.
This article explores the essence of layered architecture, explaining why layering is used, its advantages and disadvantages, core design principles, and practical ways to apply logical and physical layers in real‑world software projects.
This article explores why highlighting key information matters, outlines four main goals, presents five practical design methods such as layout, contrast, radiation effect, visual guidance and prompts, and offers validation techniques like 5‑second tests, click tests, A/B testing and eye‑tracking to ensure effectiveness.
This article shares a senior engineer's practical philosophy on code review, covering why reviews matter, common pitfalls like duplicated code and premature optimization, and twelve concrete principles—such as simplicity, composition, transparency, and early returns—to help developers write clearer, more maintainable Go programs.
This guide explains how B‑end designers can create a unified icon library by defining enterprise, client, and user personas, applying design principles such as readability, simplicity, and consistency, and leveraging open‑source icon sets to boost productivity and visual harmony.
This article examines the four minimalist interaction‑design tactics—delete, organize, hide, and transfer—through a case study of the CoolJiaLe excellent design detail page, showing how each principle can streamline information, improve usability, and guide redesign decisions.
This article shares practical insights and principles—from the importance of code review to concrete guidelines like KISS, composition, and transparency—helping developers write higher‑quality, easier‑to‑maintain software while avoiding common pitfalls such as duplication, premature optimization, and over‑engineered designs.
This article explores the essential reasons why engineers and leaders must practice code review, outlines common pitfalls such as duplicated code and premature optimization, and presents concrete design principles, model‑driven thinking, and Unix‑inspired guidelines to improve code quality and maintainability in large‑scale backend systems.
This article explains service design as a holistic, user‑centered approach, outlines its six core principles, showcases real‑world cases like Fudoloop, school lunch redesign, and Uber, and demonstrates how service blueprints map front‑stage and back‑stage activities to improve overall user experience.
The article outlines the evolution of microservice architecture, its advantages, four concrete design principles—including AKF splitting, front‑end/back‑end separation, stateless services, and RESTful communication—while also discussing common challenges and practical mitigation strategies.
This article explains the core principles of information design—proximity, dynamics, adaptation, emphasis, pre‑placement, direct access, minimal folding, and default guidance—and shows how applying them in backend interfaces improves visibility, efficiency, and user satisfaction.
This article examines common misconceptions about software architecture, explains that its core purpose is to manage system complexity, offers practical guidance for identifying complexity hotspots, and presents a concrete university student‑management system case study to illustrate effective architectural decision‑making.
This article explains how designers can give UI motion effects texture and realism by mastering time, speed, space, motion tone, and method, while aligning animations with brand identity and using appropriate curves and elastic expressions for natural, engaging user experiences.
This article explains core object‑oriented design principles—including DRY, YAGNI, Rule of Three, GRASP, SOLID and other fundamental guidelines—illustrated with real‑world examples and diagrams to help developers write cleaner, more maintainable code.
This article explains the rules and design principles behind Java's hashCode() and equals() methods, illustrates their implementations in String, and provides concrete Person class examples showing how proper overriding affects Set and Map behavior.
This article outlines essential B2B product design principles—including clear system boundaries, disciplined interaction governance, and abstracted rule‑engine architectures—illustrated with real‑world examples from NetEase Yanxuan, to help teams build scalable, maintainable systems and foster a methodology grounded in underlying logic.
The article presents a comprehensive set of fifteen universal software architecture principles—ranging from redundancy and rollback to automation and non‑intrusive design—along with essential design guidelines such as separation of concerns, single responsibility, and low coupling to help architects build scalable, reliable, and maintainable systems.
This article explains the Dependency Inversion Principle, shows why traditional layered architectures suffer from maintenance and reuse problems, provides concrete Java and web examples, and demonstrates how refactoring to abstract interfaces resolves these issues for more flexible, decoupled software design.
This article explains what makes good code, introduces SOLID and other design principles, defines unit testing, outlines its benefits, provides before‑and‑after Java refactoring examples, and reviews essential testing tools like Fast‑tester, JUnit and Mockito along with coverage metrics.
This article explains how the six STEPPS principles—Social Currency, Triggers, Emotion, Public, Practical Value, and Stories—can be applied to product design to create compelling, memorable experiences that drive user engagement, word‑of‑mouth promotion, and stronger brand influence.
This article shares the author's insights on why engineers and leaders must conduct code reviews, identifies common causes of poor code such as duplication and premature decisions, and presents a set of design principles, model‑driven thinking, and concrete Go code examples to help improve software quality and maintainability.
This article explores why massive distributed applications quickly become complex, identifies cognitive load and collaboration cost as the two main dimensions of software complexity, and offers practical design, naming, testing, and documentation strategies to keep systems maintainable over time.
This article traces the history and development of pandemic data visualization—from 19th‑century cholera maps and early 2000s SARS charts to sophisticated COVID‑19 dashboards—while outlining five essential design principles that make such visualizations clear, engaging, and impactful.
The article explains why having constructors perform excessive work is a design flaw, describes how to spot this problem through code symptoms, discusses its impact on testability and maintainability, and provides concrete refactoring strategies such as dependency injection, factories, and builder patterns.
