BestHub
Sign in
Tagged articles
34 articles
Page 1 of 1
Code Wrench
Code Wrench
Mar 2, 2026 · Backend Development

Why Go Code Gets Bloated and How Blueprint Patterns Can Simplify It

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-KitInterface Design
0 likes · 6 min read
Why Go Code Gets Bloated and How Blueprint Patterns Can Simplify It
Architect-Kip
Architect-Kip
Nov 25, 2025 · Backend Development

Mastering API Interface Design: Principles, Naming, Parameters, and Security

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.

Interface DesignSecurityapi-design
0 likes · 16 min read
Mastering API Interface Design: Principles, Naming, Parameters, and Security
JD Tech Talk
JD Tech Talk
Apr 10, 2025 · Backend Development

Proper RPC Interface Design: Avoiding Result Wrappers and Using Exceptions

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 HandlingInterface Design
0 likes · 8 min read
Proper RPC Interface Design: Avoiding Result Wrappers and Using Exceptions
JD Cloud Developers
JD Cloud Developers
Apr 10, 2025 · Backend Development

Why Your RPC Interfaces Should Avoid HTTP‑Style Responses

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 HandlingInterface DesignJava
0 likes · 10 min read
Why Your RPC Interfaces Should Avoid HTTP‑Style Responses
dbaplus Community
dbaplus Community
Oct 31, 2024 · Fundamentals

When to Choose SPI vs API? A Deep Dive into Interface Placement

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.

APIInterface DesignSPI
0 likes · 8 min read
When to Choose SPI vs API? A Deep Dive into Interface Placement
Top Architect
Top Architect
Sep 12, 2024 · Fundamentals

Understanding SPI vs API: Interface Placement and Design Principles

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.

APIBackendInterface Design
0 likes · 9 min read
Understanding SPI vs API: Interface Placement and Design Principles
Architect
Architect
Sep 10, 2024 · Fundamentals

Understanding SPI vs API: When to Use Service Provider Interfaces versus Application Programming Interfaces

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.

APIDDDInterface Design
0 likes · 6 min read
Understanding SPI vs API: When to Use Service Provider Interfaces versus Application Programming Interfaces
IT Architects Alliance
IT Architects Alliance
Jul 2, 2024 · Backend Development

Do You Really Need Interfaces for Service and DAO Layers in Spring?

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.

Backend ArchitectureInterface DesignService Layer
0 likes · 8 min read
Do You Really Need Interfaces for Service and DAO Layers in Spring?
Top Architect
Top Architect
Sep 4, 2023 · Backend Development

Understanding AOP: Interface Design, Joinpoint, and Weaving in Java

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 ProgrammingInterface DesignJava
0 likes · 10 min read
Understanding AOP: Interface Design, Joinpoint, and Weaving in Java
High Availability Architecture
High Availability Architecture
Aug 22, 2023 · Backend Development

Practical Tips for Improving Interface Maintainability in Software Development

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 documentationBackend DevelopmentInterface Design
0 likes · 15 min read
Practical Tips for Improving Interface Maintainability in Software Development
Selected Java Interview Questions
Selected Java Interview Questions
Jul 13, 2023 · Frontend Development

Guidelines for Frontend‑Backend Separation and API Specification (V1.0.0)

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.

APIBackendInterface Design
0 likes · 11 min read
Guidelines for Frontend‑Backend Separation and API Specification (V1.0.0)
Architecture Digest
Architecture Digest
Apr 28, 2022 · Backend Development

Comprehensive Domain Interface Design and Its Application in Backend Systems

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.

Backend DevelopmentDomain-Driven DesignInterface Design
0 likes · 11 min read
Comprehensive Domain Interface Design and Its Application in Backend Systems
Bitu Technology
Bitu Technology
Jan 11, 2022 · Backend Development

Interface‑Driven Design for Scalable Media File Migration in Elixir and Ruby

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.

Backend DevelopmentElixirFile Migration
0 likes · 13 min read
Interface‑Driven Design for Scalable Media File Migration in Elixir and Ruby
Selected Java Interview Questions
Selected Java Interview Questions
Nov 7, 2021 · Backend Development

Do Service and DAO Layers Need Interfaces? When to Omit Them in Spring Projects

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.

Backend DevelopmentInterface DesignJava
0 likes · 9 min read
Do Service and DAO Layers Need Interfaces? When to Omit Them in Spring Projects
IT Architects Alliance
IT Architects Alliance
Aug 22, 2021 · Backend Development

Domain Interface Design and Its Application in Backend Systems

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.

BackendInterface Designjpa
0 likes · 9 min read
Domain Interface Design and Its Application in Backend Systems
Top Architect
Top Architect
Aug 19, 2021 · Backend Development

Comprehensive Domain Interface Design and Implementation in Java Backend Systems

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.

Domain-Driven DesignElasticsearchInterface Design
0 likes · 8 min read
Comprehensive Domain Interface Design and Implementation in Java Backend Systems
Top Architect
Top Architect
May 31, 2021 · Backend Development

Do Service and DAO Layers Need Interfaces? A Practical Discussion for Java Backend Projects

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.

Backend ArchitectureInterface DesignJava
0 likes · 8 min read
Do Service and DAO Layers Need Interfaces? A Practical Discussion for Java Backend Projects
Java Backend Technology
Java Backend Technology
Dec 27, 2020 · Backend Development

Do You Really Need Interfaces for Service and DAO Layers in Spring?

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.

Interface DesignService Layerdao
0 likes · 8 min read
Do You Really Need Interfaces for Service and DAO Layers in Spring?
Programmer DD
Programmer DD
Jul 23, 2020 · Backend Development

Why Consumers Should Lead API Design: Lessons from Real-World Mistakes

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.

Backend DevelopmentInterface Designapi-design
0 likes · 15 min read
Why Consumers Should Lead API Design: Lessons from Real-World Mistakes
Continuous Delivery 2.0
Continuous Delivery 2.0
Apr 28, 2020 · Fundamentals

Google’s Approach to Code Health: Readable, Maintainable, and Simple Code Practices

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.

Interface DesignSoftware Engineeringbest practices
0 likes · 9 min read
Google’s Approach to Code Health: Readable, Maintainable, and Simple Code Practices
21CTO
21CTO
Dec 24, 2019 · Backend Development

Why API Documentation Matters: 5 Common Mistakes and How to Fix Them

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 documentationInterface DesignSoftware Engineering
0 likes · 7 min read
Why API Documentation Matters: 5 Common Mistakes and How to Fix Them
Programmer DD
Programmer DD
Aug 5, 2018 · Backend Development

How to Design Clean RPC Interfaces: Best Practices and Pitfalls

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.

Interface DesignJavaRPC
0 likes · 19 min read
How to Design Clean RPC Interfaces: Best Practices and Pitfalls
Qunar Tech Salon
Qunar Tech Salon
Nov 19, 2014 · Fundamentals

Characteristics of Good Interfaces and Core Design Principles

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.

Interface DesignObject-OrientedSoftware Architecture
0 likes · 4 min read
Characteristics of Good Interfaces and Core Design Principles
Suning Design
Suning Design
Mar 25, 2014 · Product Management

Why the Best Interface Is No Interface: Designing Seamless Experiences

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.

Interface DesignNo Interfacehuman-centered design
0 likes · 11 min read
Why the Best Interface Is No Interface: Designing Seamless Experiences