Tagged articles
interface design
36 articles · Page 1 of 1

We-DesignJul 31, 2026 · User Experience Design
The article argues that a series of design decisions—from early internet’s spatial metaphors to smartphone‑driven endless feeds, blank‑canvas platforms, and Twitter’s character limits—have transformed digital products into environments that encourage shallow, fragmented cognition, and it calls on designers to rethink these choices to foster deeper thought.
DesignUser Experienceattention economy
0 likes · 12 min read

The article explains why complex intelligent decisions—such as those in autonomous driving—must be decomposed, outlines five key challenges, presents four classic decomposition paradigms, discusses interface design principles, and identifies scenarios where splitting may be counterproductive.
AI decision decompositionAutonomous Drivingfunctional modularization
0 likes · 10 min read

The article reviews Mat Ryer’s *Go Programming Blueprints*, revealing why many Go projects become heavyweight, and presents three architectural truths—behavior‑oriented interfaces, Lego‑style CLI components, and an onion‑layered microservice model—illustrated with concrete code snippets and practical design guidelines for clean, maintainable backend systems.
GoGo-KitUnix Philosophy
0 likes · 6 min read

This guide outlines comprehensive API interface design best practices, covering design principles, naming conventions, parameter structures, return code standards, security measures, and a reusable documentation template to ensure flexible, efficient, and secure service development.
API DesignSecurityinterface design
0 likes · 16 min read

The article explains why designing RPC interfaces with generic Result objects that contain errorCode, errorMessage and data defeats RPC's purpose, and demonstrates how returning plain business objects and leveraging Java exceptions leads to cleaner, more maintainable backend code.
BackendException HandlingJava
0 likes · 8 min read

This article explains why designing RPC (JSF) interfaces to return HTTP‑like result objects with errorCode, errorMessage, and data defeats the purpose of RPC, and it offers concrete guidelines and Java examples for building clean, exception‑driven RPC APIs.
Exception HandlingJavaRPC
0 likes · 10 min read

This article explores the concepts of Service Provider Interface (SPI) and Application Programming Interface (API), examines three possible package locations for interfaces, compares their rules, advantages, and trade‑offs, and provides guidance on selecting the appropriate approach for modular and extensible software design.
APISPIinterface design
0 likes · 8 min read

The article explains the distinction between Service Provider Interfaces (SPI) and Application Programming Interfaces (API), discusses three possible package placements for interfaces, outlines rules and advantages of each, and provides guidance on choosing between SPI and API based on extensibility, interaction, and stability.
APIBackendSPI
0 likes · 9 min read

This article explains the distinction between Service Provider Interfaces (SPI) and Application Programming Interfaces (API), examines where interfaces can be placed in a codebase, outlines their respective rules, compares their trade‑offs, and offers guidance on choosing the appropriate approach in software architecture.
APIDDDJava
0 likes · 6 min read

This article examines whether defining separate interfaces for Service and DAO layers is necessary in Spring projects, debunks common justifications, proposes a bottom‑up development workflow, and outlines project structures for single and multiple implementations, highlighting both benefits and drawbacks.
DAOService LayerSpring
0 likes · 8 min read

This article explores Go's naming conventions, focusing on the logical use of the “er” and “able” suffixes in interfaces and types, and explains how following these guidelines improves code readability, consistency, and expressive power.
Code ReadabilityGointerface design
0 likes · 4 min read

This article explains the fundamentals of Aspect‑Oriented Programming in Java, covering the motivation behind AOP, the three main steps of defining join points, the design of Joinpoint interfaces, code examples, and the static and dynamic weaving techniques used by frameworks such as Spring.
Aspect-Oriented ProgrammingJavaWeaving
0 likes · 10 min read

This article presents a series of concrete, experience‑driven recommendations—such as embedding documentation links in code comments, publishing source to private repositories, defining constants in parameter classes, handling Map payloads with typed objects, simplifying dependencies, and logging raw request/response data—to enhance the maintainability of backend interfaces throughout the software lifecycle.
API DocumentationJavaLogging
0 likes · 15 min read

This article discusses the evolution from MVC‑based backend‑centric development to modern frontend‑backend separation, explains the benefits of clear responsibility division, outlines the SPA era with Ajax, and provides a detailed V1.0.0 API specification including request/response formats, pagination, and special field conventions.
APIBackendSPA
0 likes · 11 min read

The article explains why front‑back end separation is needed, describes the evolution from MVC to SPA, outlines responsibility separation, development workflow, and presents a detailed API specification including request/response formats, pagination, and special data handling rules.
APIBackendMVC
0 likes · 10 min read

This article introduces the Maximum‑Minimum Principle, explaining how maximizing output guarantees while minimizing input constraints leads to stable, extensible designs that inherently fulfill SOLID principles without extra effort.
SOLID principlesduck-typinginterface design
0 likes · 9 min read

This article explains software design patterns, their origins, key examples, and how MITRE system engineers can apply them to manage coupling and interface design in large enterprise service environments, emphasizing loose coupling, best‑practice guidelines, and practical lessons learned.
couplingdesign patternsinterface design
0 likes · 13 min read

This article explores the concept of fully interface‑based domain modeling, demonstrates how to design domain objects as interfaces, shows repository implementations for JPA, MyBatis and Elasticsearch, discusses association handling, and explains how such designs enable seamless switching between monolithic, clustered and microservice deployments.
JavaSpringbackend development
0 likes · 11 min read

The talk explains how Tubi's Multimedia Processing Platform uses an interface‑driven architecture, Elixir protocols, and composable movers and comparators to migrate petabyte‑scale video files across cloud storage while balancing performance, cost, and testability, offering practical insights for Ruby and backend engineers.
ElixirFile MigrationRuby
0 likes · 13 min read

This article examines whether Service and DAO layers in Java Spring applications must always have interfaces, explains why dependency‑injection frameworks make interfaces optional, discusses development workflows, multiple‑implementation scenarios, project structuring options, and outlines the trade‑offs of using or not using interfaces.
DAOJavaService Layer
0 likes · 9 min read

The article explains how designing domain models as interfaces, rather than concrete classes, improves flexibility in backend architectures by simplifying data exchange, supporting multiple persistence technologies, and enabling seamless deployment across standalone, clustered, and micro‑service environments.
BackendJPAinterface design
0 likes · 9 min read

This article explores comprehensive domain interface design in Java backend development, showing how to model domain objects as interfaces, implement repositories for JPA, MyBatis, and Elasticsearch, handle associations with JPA annotations, and apply these patterns in the open‑source Mallfoundry e‑commerce platform.
ElasticsearchJPAJava
0 likes · 8 min read

This article examines whether Service and DAO layers in Java backend projects require interfaces, arguing that with dependency‑injection frameworks like Spring the interfaces are often unnecessary, while outlining development workflows, project structures, and scenarios where interfaces remain useful.
JavaService LayerSpring
0 likes · 8 min read


58UXDDec 30, 2020 · Product Management
This article explains how a lightweight, intuitive design language and an AI‑driven asynchronous interview feature were created to ease candidate anxiety, streamline recruiter workflows, and achieve high user satisfaction across millions of interview sessions.
AI InterviewRecruitmentUX design
0 likes · 5 min read

This article examines whether Service and DAO layers in Spring projects truly require interfaces, debunks common justifications, explores alternative project structures for single and multiple implementations, and offers practical guidelines on when to use or omit interfaces.
DAOService LayerSpring
0 likes · 8 min read

This article examines common pitfalls in API design, argues that the consumer of an interface should drive its design, and presents concrete examples and best‑practice recommendations for structuring endpoints, meta data, and choosing appropriate communication protocols.
API DesignBest PracticesREST
0 likes · 15 min read

The article outlines Google’s philosophy on code health, emphasizing readable, maintainable, stable, and simple code, and provides practical guidance on writing understandable code, designing robust interfaces, and avoiding primitive obsession to improve developer productivity and software quality.
Best PracticesCode Readabilityinterface design
0 likes · 9 min read


21CTODec 24, 2019 · Backend Development
This article examines five frequent problems in API design—missing or incomplete documentation, lack of parameter validation, non‑atomic operations, and recurring interface issues—explaining why they frustrate front‑end developers and offering practical solutions such as proper documentation practices, enriched response structures, and rigorous validation.
API DocumentationRESTinterface design
0 likes · 7 min read

This article explains the strategic benefits of using interfaces in software design—standardization, abstraction, and decoupling—illustrates when and why to apply them, and shows how the Dependency Inversion Principle enables flexible, testable, and maintainable architectures.
API standardsabstractiondependency inversion
0 likes · 11 min read

This article provides comprehensive guidelines for GUI testing, covering usability principles, conformity standards, help facility requirements, and rational layout rules to improve software interface design and user experience.
GUI testingUsabilityhelp documentation
0 likes · 8 min read

The article explains how fast iteration, thorough business domain modeling, layered module design, minimal‑responsibility interfaces, and automated exception feedback can together boost backend development productivity and reduce maintenance costs in modern software projects.
backend architecturebusiness domain modelinginterface design
0 likes · 9 min read

This article examines common pain points of traditional RPC interfaces—excessive query methods, poor extensibility, difficult upgrades, testing challenges, and flawed exception handling—and presents practical solutions such as single‑parameter designs, Specification pattern, proper exception contracts, version‑by‑module evolution, and automated testing integration.
JavaRPCSpecification pattern
0 likes · 19 min read

This article outlines essential principles for building extensible, high‑performance online services, covering interface design, coding standards, caching strategies, and logging practices to reduce bugs and simplify development and maintenance.
BackendBest PracticesLogging
0 likes · 9 min read

This article discusses the challenges of building large distributed systems, emphasizing the need for a unified internal language, model‑driven design, layered architecture, and clear interface design principles to improve communication, maintainability, and scalability.
Layered Architecturedomain-driven designinterface design
0 likes · 14 min read

The article outlines the essential traits of high‑quality interfaces, describes a step‑by‑step process for designing and implementing them, and presents fundamental principles for interface, class, and method design to ensure usability, maintainability, and robustness in software development.
API DesignBest Practicesinterface design
0 likes · 4 min read

The article argues that true innovation lies in eliminating digital interfaces, using natural human actions and context‑aware technology to create products that work without forcing users through cumbersome screens, illustrated by examples from cars, fridges, payments and smart home devices.
No Interfacehuman-centered designinterface design
0 likes · 11 min read
