Tagged articles
interface
69 articles · Page 1 of 1
This article breaks down the five Go interview questions interviewers love, explains the underlying concepts such as goroutine and channel mechanics, empty‑interface pitfalls, map concurrency, defer execution, and Go modules, provides high‑scoring code examples, and offers concrete preparation tips to showcase engineering thinking and practical skills.
ConcurrencyGoInterview
0 likes · 9 min read

The article explains why adding a method directly to an existing Java interface can break all classes that already implement it and demonstrates the correct approach of creating a new interface that extends the original, preserving compatibility.
InheritanceJavaOOP
0 likes · 3 min read

This note explains how Java interfaces define new data types, how variables of an interface type must reference objects implementing that interface, and demonstrates the concept with a concrete example that casts objects to a Compare interface to select the larger one.
CastingJavaOOP
0 likes · 3 min read

This tutorial walks through Java interface basics, showing how to declare an interface, implement it in classes, handle method and constant conflicts when implementing multiple interfaces, and demonstrates the concepts with concrete Rectangle and Circle examples.
Code ExampleJavaOOP
0 likes · 10 min read

This note explains how interfaces act as contracts in collaborative Java projects, covering everyday analogies, definition, syntax, implementation requirements, API role, and how multiple interfaces provide a form of multiple inheritance.
APIJavaMultiple Inheritance
0 likes · 5 min read

This article explains Go's interface type, covering its basic concept, syntax, simple and advanced examples—including empty interfaces, interface composition, standard library usage, sorting, error handling, and dependency injection—while also discussing implementation details like value vs. pointer receivers and summarizing key characteristics.
CompositionGoPolymorphism
0 likes · 13 min read

This article explains how Go interfaces define behavior contracts, how implicit implementation, empty interfaces, and type assertions work, demonstrates polymorphic patterns with payment and animal examples, and highlights common pitfalls such as nil interfaces, method‑signature mismatches, pointer vs. value receivers, and interface composition.
GoPolymorphismempty interface
0 likes · 16 min read

The article explains how Java 8 added default and static methods to interfaces—allowing method bodies, enabling backward‑compatible extensions, illustrating usage with code examples, handling multiple‑interface conflicts, and introducing Java 9 private methods, while summarizing common pitfalls and best‑practice guidelines.
JavaJava 8default method
0 likes · 9 min read

The article examines Go’s long‑standing boilerplate adapter pattern, explains the newly accepted Issue #47487 that enables explicit conversion of functions to single‑method interfaces, compares it with the rejected implicit assignability approach, and shows how the compiler generates hidden types to preserve safety and reduce code.
BoilerplateCompilerGo
0 likes · 11 min read

This article shows how Go developers can achieve Java‑style method overriding by combining interfaces, struct embedding, and the functional‑options pattern, providing a flexible, decoupled way to customize behavior at compile‑time and run‑time without inheritance.
GoIdiomatic Gofunctional options
0 likes · 7 min read

The article shows how Go, which lacks inheritance and the @Override keyword, can achieve a clean override-like behavior by defining interfaces, using struct embedding to reuse functionality, and applying functional options for runtime customization, illustrated with a Dog‑Husky example.
CompositionGofunctional options
0 likes · 7 min read

This comprehensive guide covers the core Go concepts most frequently asked in interviews—including goroutine scheduling, channel communication, interface internals, garbage‑collection mechanics, toolchain utilities, error handling patterns, and struct memory layout—providing clear explanations, code examples, and practical tips to help candidates transition from writing Go code to truly understanding the language.
ConcurrencyGoerror handling
0 likes · 12 min read

This article explains the different types of laptop storage devices—including movable and fixed hard drives, mechanical HDDs, solid‑state SSDs, and hybrid SSHDs—detailing their classifications, internal structures, performance characteristics, interface standards, and the underlying principles of how they store and retrieve data.
HDDHard DriveSSD
0 likes · 33 min read

This article explains how Go interfaces enable decoupling, polymorphism, easier testing with mocks, extensibility, and contract‑driven design, using a concrete ClientDetailsService example with in‑memory and Postgres implementations.
Mockingdependency-injectioninterface
0 likes · 7 min read

This article explains how C++ uses abstract classes and pure virtual functions to define interfaces, compares abstract classes with simulated interfaces, provides concrete code examples, and outlines common real‑world scenarios such as game objects, GUI widgets, and plugin systems.
Abstract ClassC++OOP
0 likes · 5 min read

While many developers add interfaces to every Service and DAO class, this article argues that with Spring’s dependency injection you can often omit them, examines common reasons for using interfaces, and proposes practical project structures and workflows for both single and multiple implementation scenarios.
Service LayerSpringbackend development
0 likes · 9 min read

Abstract classes and interfaces are core object‑oriented concepts that enable reusable, extensible, and maintainable code; this article explains their definitions, design considerations, and real‑world applications, illustrated with Java examples of a Control hierarchy and a Shape interface implementation.
Abstract ClassInheritanceJava
0 likes · 5 min read

This article demonstrates how to create and apply custom Spring annotations for AOP logging, implements the corresponding aspect, and discusses the strategic use of abstract classes and interfaces to separate business logic from data access in both MongoDB and MySQL contexts.
AOPAbstract ClassBackend
0 likes · 8 min read

This article explains Go’s empty interface, showing how it can hold values of any type, how to declare and use it in functions and data structures, and why copying between concrete slices and empty‑interface slices requires element‑wise assignment due to its two‑word memory layout.
GoMemory LayoutType System
0 likes · 5 min read

This article examines the three classic reasons for defining interfaces on Service and DAO layers, explains why they often fall short when using Spring's dependency injection, and offers practical structuring and workflow tips for projects that may or may not require multiple implementations.
BackendService LayerSpring
0 likes · 8 min read

This article explains how Python's Abstract Base Classes provide interface‑like contracts for OOP, demonstrates their use with a payment‑gateway example, shows how to build a plugin system, and highlights the benefits of early error detection, clear conventions, and extensibility.
Abstract Base Classinterfaceplugin system
0 likes · 9 min read

The article explains why declaring business data structures with TypeScript's interface or type is discouraged, illustrates practical problems such as property name changes and type mismatches, and advocates using classes to gain decorator support, combined behavior and data, and better extensibility.
TypeTypeScriptclass
0 likes · 8 min read

This article explains how Go treats nil pointers within interfaces, why an interface containing a nil pointer is still non-nil, demonstrates the behavior with code examples, compares it to Java, and discusses practical implications for writing robust Go programs.
fundamentalsinterfacenil pointer
0 likes · 13 min read

This guide explains Go's empty interface, how any value can be stored in it, demonstrates declaring variables and functions with interface{}, shows practical slice examples, discusses memory layout, and provides the correct way to copy data into an empty‑interface slice.
Type Conversionempty interfacegolang
0 likes · 5 min read

This article examines whether a Service layer in a Spring‑based backend should use interfaces, critiques the common justifications, proposes a top‑down coding workflow, explores AOP proxy options, and presents modular project structures for single or multiple implementations.
Service Layerbackend architectureinterface
0 likes · 10 min read

This article examines whether defining interfaces for Service and DAO layers is necessary in Spring projects, debunks common arguments for interfaces, proposes a top‑down coding workflow, and outlines strategies for handling multiple implementations without adding unnecessary abstraction.
DAOService LayerSpring
0 likes · 9 min read

This article explains the zero‑size nature of Go's empty struct, demonstrates how its memory address behaves, shows its impact on struct alignment, and presents multiple practical patterns such as set implementation, large arrays, signal channels, no‑op methods, interface stubs, and the noCopy identifier.
Memorychannelempty struct
0 likes · 17 min read

This article explains PHP enums, showing how they improve code readability and safety, and demonstrates their integration with interfaces, traits, attributes, validation rules, casting, and matching mechanisms, providing practical examples and best‑practice recommendations for backend developers.
EnumPHPattribute
0 likes · 7 min read

This article explains how Go's native structs and interfaces can replace traditional Data Transfer Objects, offering a more concise, performant, and maintainable way to move data across application layers while highlighting best‑practice patterns and potential pitfalls.
BackendDTOData Transfer
0 likes · 8 min read

An empty interface in Go, defined as interface{}, can hold values of any type because it has no methods, enabling flexible data structures like slices, maps, and structs, and is commonly used in functions such as fmt.Println, though copying between typed and empty interface slices requires careful handling.
GoType Systemempty interface
0 likes · 5 min read

This article examines whether every Service and DAO class in a Spring‑based backend should implement an interface, discusses the three traditional reasons for using interfaces, explains why they often do not hold up, and proposes practical structuring alternatives for single‑ and multi‑implementation scenarios.
DAOJavaService Layer
0 likes · 8 min read

This article examines whether a Service layer in Java Spring projects truly requires interfaces, debunking common arguments, exploring development workflows without interfaces, discussing project structuring for single and multiple implementations, and concluding when interfaces are beneficial or unnecessary.
JavaService LayerSpring
0 likes · 7 min read

This article examines common TypeScript type‑reuse issues in a component library, compares type aliases and interfaces, demonstrates using utility types like Omit and Pick, introduces unified base props, shows tuple usage for hooks, and explains function overloads to improve code maintainability and type safety.
TypeScriptUtility Typesfrontend
0 likes · 10 min read

The article explains why Go does not support traditional monkey patching, then demonstrates two practical approaches—using interfaces with wrapper types and employing reflection—to extend a SimpleLogger with log levels without modifying its source, while discussing trade‑offs such as readability and performance.
GoMonkey PatchingReflection
0 likes · 6 min read

This article traces the evolution of the PCI Express (PCIe) standard from its 1.0 inception to the latest 6.0 specification, highlighting key differences in data rates, encoding schemes, equalization techniques, and test requirements that enable higher bandwidth and reliability for modern data‑center and AI workloads.
PCIeencodingequalization
0 likes · 11 min read

This article introduces PHP 8’s new Stringable interface, explains its purpose, shows how to implement it with example code, and demonstrates its seamless integration with common string functions such as str_replace, strlen, and substr for more concise string handling.
BackendPHPString Operations
0 likes · 5 min read

When joining a new project, understanding its software design by first examining the model, then the interface, and finally the implementation helps avoid getting lost in code, clarifies design decisions, and builds a clear mental map of the system.
ImplementationModelarchitecture
0 likes · 10 min read

This article presents a comprehensive set of front‑back end collaboration standards, covering why a coordination protocol is needed, detailed workflow steps, interface design rules, common pitfalls with concrete code examples, and the measurable benefits of adopting a unified development contract.
APICollaborationfrontend
0 likes · 16 min read

This article explains the role of Java interfaces as communication protocols between modules, demonstrates their use with a computer‑assembly analogy, and covers Java 8 features such as default and static methods, method‑conflict resolution, and best practices for interface design.
OOPdefault methodinterface
0 likes · 15 min read

This article provides a comprehensive overview of the PCIe interface evolution, detailing the specifications, version milestones, bandwidth improvements, encoding and signaling changes from PCIe 3.0 through PCIe 7.0, and their impact on data‑center, AI/ML, and consumer hardware.
DataCenterPAM4PCIe
0 likes · 9 min read

The article discusses how abstraction and decoupling through Java interfaces—such as service layers, RPC APIs, and middleware adapters—can improve code maintainability, enable flexible implementation swaps, and clarify responsibilities, while also warning against over‑engineering in most business scenarios.
Javaabstractioninterface
0 likes · 8 min read

This article explains why and how to separate front‑end and back‑end responsibilities, introduces the SPA‑based architecture, outlines development processes, and provides a detailed API specification (including request/response formats, pagination, and special field rules) to improve collaboration and reduce integration effort.
APIBackendSPA
0 likes · 13 min read

This article explains how designing domain objects, services, and repositories as interfaces in Java enables seamless switching between different persistence technologies and deployment models, improving modularity, testability, and adaptability for micro‑service architectures.
DDDJavaRepository
0 likes · 10 min read

This article explains why front‑end and back‑end should be separated, describes the evolution from MVC to SPA, outlines responsibilities, development workflow, and provides a detailed version‑1.0.0 API contract including request/response formats, pagination, special data types, and mock‑server usage.
AJAXSPAfrontend
0 likes · 12 min read

The article explains that DevOps should be viewed as an interdisciplinary interface rather than a specific job title, contrasts it with traditional roles like software developer or system administrator, and illustrates the concept with a Java‑style code example, while also including a brief promotional note about a DevOps training course.
Code ExampleDevOpsOperations
0 likes · 3 min read


ZhiKe AIMar 15, 2021 · Backend Development
This article explains how to create a simple single‑node in‑memory cache that supports per‑entry expiration by defining a generic cache interface and implementing it with Caffeine, using ConcurrentHashMap to store multiple caches keyed by expiration time.
CacheCaffeineIn-Memory
0 likes · 5 min read

This article explains the Chain of Responsibility design pattern, illustrates it with a company expense‑approval scenario, and provides complete Go code—including an interface, Staff, Manager, and CEO structs—showing how to build a flexible, extensible approval chain.
Chain of ResponsibilityDesign PatternExtensibility
0 likes · 6 min read

The article explains Google’s GKI transformation requirements—preserving a stable Kernel Module Interface, using only exported and whitelisted symbols, employing vendor hook mechanisms for custom SoC/OEM code, detecting interface mismatches, and offering alternatives such as padding macros and existing kernel event registration to avoid breaking KMI.
AndroidAndroid11GKI
0 likes · 11 min read

This article examines whether Service and DAO layers in Java Spring projects should always have interfaces, discusses the arguments for and against using interfaces, and proposes practical structuring and dependency‑injection techniques to decide when interfaces are truly necessary.
DAOJavaService Layer
0 likes · 8 min read

This article examines whether a Service layer in a Spring‑based backend project truly requires an interface, debunks common justifications, proposes practical development workflows, and outlines the advantages and drawbacks of using or omitting interfaces in various architectural scenarios.
Service LayerSpringbackend architecture
0 likes · 8 min read

The article explains the Adapter pattern by defining its purpose, illustrating the concept with mobile charging ports, and providing a complete Go code example that shows how to wrap incompatible interfaces so they can work together through adapters.
Code ExampleGoadapter pattern
0 likes · 3 min read

This article examines whether a Service layer in a Spring‑based application truly requires an interface, analyzes common arguments for and against using interfaces, explores project structuring options, and offers practical recommendations based on real‑world development experience.
AOPService LayerSpring
0 likes · 7 min read

This article examines whether every Service and DAO class in a Spring‑based backend should implement an interface, evaluates the common arguments for using interfaces, explains why they often do not hold up, and proposes practical structuring and development approaches for projects that may or may not need multiple implementations.
DAOJavaService Layer
0 likes · 9 min read

This article explores various ways to implement interfaces in C++, comparing virtual functions, the Pimpl idiom, hidden subclasses, callback mechanisms, function pointers, std::function, member function pointers, and non‑intrusive traits, highlighting their trade‑offs in performance, binary compatibility, and design flexibility.
C++Callbackinterface
0 likes · 13 min read

This article explores three common doubts about Java interfaces, demonstrates how interface references can point to implementing objects, compares abstract classes and interfaces for achieving polymorphism, and provides detailed animal‑hierarchy examples with code, generics, and best‑practice recommendations.
Abstract ClassGenericsOOP
0 likes · 19 min read

This article explains the purpose of Java's Comparable interface, demonstrates how built‑in classes like String use it for natural ordering, shows the failure when custom objects lack it, and provides a step‑by‑step guide to implementing Comparable with practical code samples.
Comparablecollectionsinterface
0 likes · 9 min read

This article explains how Go's sort package internally uses four algorithms, how to implement sort.Interface with Len, Less, and Swap methods, and provides code examples for sorting int slices and custom structs by different fields.
Algorithmsinterfaceslice
0 likes · 5 min read

This article explains Go's method sets, the relationship between method receivers and method sets, how interfaces work, and the role of embedding, providing code examples that illustrate value vs pointer receivers, interface implementation rules, and embedding differences for struct types.
EmbeddingStructinterface
0 likes · 10 min read

This article explains Go's method sets, the relationship between receivers and method sets, how interfaces work, and the nuances of embedding both value and pointer types, providing clear code examples and practical insights for Go developers.
BackendEmbeddingGo
0 likes · 12 min read

This article explains Java 8 interface default methods, demonstrates why the provided code fails to compile due to accessing a non‑existent instance field, and clarifies how adding fields to an interface affects compilation, concluding that option A is the correct answer.
Default MethodsJavaJava 8
0 likes · 5 min read

This article analyzes Go's duck typing and interface mechanisms, explaining how interfaces are defined, implemented, and converted at runtime, including details of underlying structures like iface and eface, method sets, pointer vs value receivers, and type assertions, supplemented with code examples and assembly insights.
GoRuntimeduck-typing
0 likes · 22 min read

This article explains how SSDs have transformed storage performance and details the characteristics, advantages, and use‑cases of the five main SSD interfaces—SATA, PCIe, M.2, mSATA, and U.2—helping readers choose the appropriate technology for their needs.
M.2NVMePCIe
0 likes · 14 min read

Go’s reflection, accessed via the reflect package’s TypeOf and ValueOf functions, lets programs inspect and modify runtime types and values—including fields, tags, and slices—while obeying settable rules, enabling generic utilities such as JSON serialization, deep equality checks, and dynamic ORM-like behavior.
@ValueDeepEqualGo
0 likes · 27 min read

This article explains how Java interfaces can be defined separately from classes, how interfaces can inherit from other interfaces (including multiple inheritance), and how abstract classes are declared and extended, providing clear code examples for each concept.
Abstract ClassInheritanceJava
0 likes · 4 min read

This article explains the concepts, syntax, and design differences between Java abstract classes and interfaces, illustrating how each is used for abstraction, inheritance, and behavior contracts with code examples.
Abstract ClassOOPinterface
0 likes · 9 min read


网易UEDCSep 27, 2017 · Fundamentals
This article explores how interaction designers can expand the concept of interfaces beyond traditional screens, examining the evolution from CUI to NUI and showcasing diverse examples such as elevator panels, smart bikes, conversational robots, shape‑changing metal, and tactile displays for the blind.
Human-Computer InteractionNUIUX
0 likes · 9 min read

The article explains how to use the 'display interface brief' command to view interface status, interpret various state symbols, read input/output utilization percentages, and calculate actual traffic rates for each interface on a network device.
Commandinterfacenetwork
0 likes · 3 min read

This guide demonstrates how to use the "clear configuration this" command in interface view to remove all configurations from a network interface, restore default settings, and handle the resulting shutdown state, including example CLI steps and expected output.
CLIConfigurationclear command
0 likes · 2 min read

This article outlines six fundamental UI design guidelines—clarity, simplicity, familiarity, responsiveness, consistency, and visual appeal—to help designers create interfaces that enhance user experience and improve the success of web projects.
Design PrinciplesUI designUser Experience
0 likes · 6 min read
