Tagged articles
Composition
41 articles · Page 1 of 1
This article explains the Java Adapter design pattern, covering its definition, roles (Target, Adapter, Adaptee), and two implementation approaches—class adapter using inheritance and object adapter using composition—with complete code examples for each.
Class AdapterCompositionInheritance
0 likes · 4 min read

The article explains the Decorator pattern, showing how it dynamically adds functionality to objects without modifying them or using inheritance, using an order pricing example and Java IO streams, compares it with inheritance and Proxy, and outlines when to apply decorators effectively.
CompositionDecoratorJava
0 likes · 16 min read

The article explains why the guideline “favor composition over inheritance” is useful but not absolute, illustrates a fixed‑workflow scenario where inheritance simplifies implementation, and provides concrete code examples and decision criteria for choosing between the two approaches.
CompositionInheritanceOOP
0 likes · 7 min read

The article argues that by 2027 enterprise AI will shift from monolithic, all‑purpose agents to a composition of many small, domain‑specific agents, reducing token waste, cutting costs up to 137×, and solving integration, security, and scalability challenges.
AI agentsAgent OrchestrationComposition
0 likes · 16 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


TonyBaiJun 11, 2026 · Backend Development
The article examines how Go's explicit error handling, minimalistic design, and implicit interfaces reshape developers' mindset, fostering disciplined error management, reducing over‑engineering, and improving code readability and predictability, ultimately making programmers more effective across any language.
CompositionGoIdiomatic Go
0 likes · 10 min read

This guide compiles high‑frequency style, lighting, lens, color, and layout keywords—each with English equivalents, typical effects, and suitable scenarios—into a ready‑to‑copy cheat sheet for crafting GPT‑Image 2 prompts efficiently.
AI image generationCompositionGPT-Image
0 likes · 22 min read

A C++ developer faces a mismatched logging API between an internal ILogger interface and a third‑party FastLogger library, and the article walks through class‑adapter inheritance, its limitations, and a more flexible object‑adapter composition solution that enables runtime switching across multiple logger implementations.
C++CompositionInheritance
0 likes · 9 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

The article dissects three masterful car renderings—McLaren Norris, Koenigsegg Aethera, and Polestar Precept—showing how strategic lighting, material treatment, composition, and color can transform a technical illustration into a compelling visual narrative that engages viewers emotionally.
Compositioncar renderingdesign analysis
0 likes · 8 min read

This article demonstrates how to achieve class‑inheritance‑like behavior in Go by combining generics, struct embedding, and interfaces, walking through a BaseJob generic base class, a ProductJob implementation, runtime polymorphism, and a unified task manager for scalable scheduling.
CompositionGenericsTask Scheduling
0 likes · 6 min read

This article explains how the Open‑Closed Principle applies to React development, demonstrating anti‑patterns and refactoring techniques—including base components, composition, higher‑order components, and custom hooks—to create extensible, maintainable UI elements while keeping tests simple.
CompositionCustom HooksHigher-Order Components
0 likes · 7 min read

This guide explores Python class fundamentals, covering inheritance versus composition, the use of super(), distinctions among instance, class, and static methods, dataclasses, the __dict__ attribute, name mangling, @property, dynamic class creation with type(), and __slots__ for attribute control.
ClassesCompositionInheritance
0 likes · 9 min read


政采云技术Dec 28, 2022 · Frontend Development
This article explains the concept of currying in JavaScript, demonstrates its benefits for reducing parameter repetition and improving code maintainability, and shows practical implementations including manual currying, utility functions, and applications in Redux middleware and function composition.
CompositionCurryingRedux
0 likes · 9 min read

This article explains how Java developers can reuse code without duplication by employing composition, inheritance, and delegation, details the syntax and initialization rules for each, and clarifies the use of the final keyword for data, methods, parameters, and classes.
CompositionDelegationFinal
0 likes · 11 min read

This article explains the Decorator design pattern, contrasting it with inheritance, and shows how to dynamically extend Java classes—especially I/O streams—using composition, complete with code examples, class diagrams, advantages, drawbacks, and practical usage scenarios.
CompositionDecorator PatternInheritance
0 likes · 15 min read

This article explains the principles of object‑oriented modeling, contrasting object and data models, illustrating with a simple account example, discussing composition versus aggregation, and providing Java code snippets for modeling processes such as eating, demonstrating how to design and implement domain objects and services.
CompositionJavaaggregation
0 likes · 12 min read

This article critiques the over‑idealization of object‑oriented programming, explaining how inheritance can create tight coupling and hidden bugs, why encapsulation may leak state, the limits of polymorphism, and how modern stateless service architectures favor composition and functional approaches.
CompositionEncapsulationInheritance
0 likes · 13 min read

The article discusses how to give each class object a unique identifier, compares inheritance and composition for associating objects, and examines the trade‑offs of each approach using C++ examples, ultimately suggesting that the choice should depend on hierarchy depth and maintenance cost.
C++CompositionInheritance
0 likes · 5 min read

This article explains the fundamentals of object‑oriented modeling, contrasting data‑model and object‑model designs, illustrating attribute‑method composition, composition versus aggregation, and providing concrete Java and SQL examples such as a simple Account domain, an eating‑process model, and an open‑source e‑commerce reference.
Compositionaggregationdatabase
0 likes · 14 min read

This article explains the fundamentals of object‑oriented modeling, contrasts data‑model and object‑model designs with Java code examples such as a simple Account entity and an eating‑process simulation, and clarifies the difference between composition and aggregation while also touching on application services and a Spring‑Boot e‑commerce project.
CompositionJavaaggregation
0 likes · 12 min read

This article explains object‑oriented fundamentals, contrasts object and data models with Java and SQL examples, discusses application services, and clarifies composition versus aggregation through real‑world analogies and code demonstrations.
CompositionJavaaggregation
0 likes · 11 min read

This article explains the philosophical basis of object‑oriented thinking, contrasts object models with data models using a simple account example, demonstrates how to design services and sequence diagrams, and clarifies the difference between composition and aggregation in software design.
CompositionJavaaggregation
0 likes · 13 min read

This article explains UML relationship types—including association, aggregation, composition, generalization and specialization—by describing their definitions, visual notations, multiplicity, role names, and real‑world examples, helping readers distinguish each concept and apply them in software modeling.
AssociationCompositionGeneralization
0 likes · 7 min read

This article explains the philosophical basis of object‑oriented thinking, distinguishes objects from things, discusses attributes and methods, compares object‑oriented and data‑model designs with Java and SQL examples, and clarifies composition and aggregation through real‑world and code illustrations.
CompositionJavaObject-Oriented Design
0 likes · 13 min read


ByteFEJul 5, 2021 · Fundamentals
This article explains core functional programming concepts in JavaScript—including pure functions, side effects, currying, composition, and pointfree style—detailing their definitions, advantages, practical code examples, and how they improve code clarity, testability, and reusability.
CompositionCurryingPure Functions
0 likes · 11 min read

The article explains the drawbacks of deep inheritance hierarchies in object‑oriented design, illustrates the problem with a bird example, and demonstrates how composition, interfaces, delegation, and Java 8 default methods can replace inheritance to improve code readability, maintainability, and flexibility.
CompositionInheritanceobject-oriented
0 likes · 12 min read

This article explains the three core class relationships in object‑oriented programming—dependency, composition, and inheritance—illustrates each with clear Python code, discusses inheritance advantages, single‑ and multiple‑inheritance types, and introduces the method‑resolution‑order (MRO) algorithm.
Class RelationshipsCompositionInheritance
0 likes · 11 min read


政采云技术Mar 16, 2021 · Fundamentals
This article explains core programming paradigms—imperative, declarative, functional, and object‑oriented—illustrating their concepts, differences, and practical JavaScript examples, while discussing features like first‑class functions, currying, composition, and OOP principles such as encapsulation, inheritance, and polymorphism.
CompositionCurryingDeclarative
0 likes · 14 min read

This article explains UML's six core relationship types—Dependency, Association, Aggregation, Composition, Generalization, and Realization—detailing their semantics, visual notations, and how they are expressed in Java or C++ code.
CompositionObject RelationshipsUML
0 likes · 10 min read

This article explains the six core UML relationship types—Dependency, Association, Aggregation, Composition, Generalization, and Realization—detailing their semantics, visual notations, code representations in Java/C++, and practical distinctions such as lifecycle ownership and usage contexts.
CompositionUMLaggregation
0 likes · 13 min read

This article explains the six fundamental UML relationship types—Dependency, Association, Aggregation, Composition, Generalization, and Realization—detailing their semantics, visual notations, code examples in Java/C++, and the distinctions among them, helping developers model object interactions accurately.
AssociationCompositionUML
0 likes · 11 min read

This article explores the origins of Gestalt psychology and explains its five core laws—figure‑ground, proximity, similarity, closure, and continuity—and shows how applying these principles can simplify, organize, and make visual designs more compelling and intuitive.
CompositionGestaltgraphic design
0 likes · 8 min read

This article explains how Go avoids traditional class inheritance by using implicit interfaces and composition, demonstrates the Template Method pattern in Go, explores orthogonal design principles, details Go Modules versioning and migration from GOPATH/vendor, and reviews Go's concurrency models including goroutine, channel and context.
CompositionContextGo
0 likes · 53 min read


政采云技术Aug 22, 2019 · Frontend Development
This article provides a comprehensive guide to JavaScript functions, covering their various forms, execution contexts, scope chains, arguments handling, return values, the dynamic this keyword, and advanced functional programming techniques such as currying, decoration, and function composition.
CompositionCurryingJavaScript
0 likes · 54 min read

UML class diagrams feature six primary relationships—Generalization, Realization, Dependency, Association, Aggregation, and Composition—each with distinct visual notations and semantics, and this guide explains their definitions, code representations in Java, and practical examples to help developers model system structures accurately.
AssociationCompositionInheritance
0 likes · 8 min read

This article explains Java class definition, interfaces, and composition, illustrating the has-a relationship through a Battery class used inside a Torch class, and discusses primitive types versus object types with complete code examples and execution results.
CompositionJavahas-a
0 likes · 6 min read


21CTOOct 22, 2017 · Frontend Development
This article walks front‑end developers through the author's deductive model of React, covering transformation, abstraction, composition, state handling, memoization, list management, continuations, state maps, and algebraic effects with clear code examples.
Component ArchitectureCompositionJavaScript
0 likes · 9 min read

By using abstraction to model common concepts and composition to build complex behavior from simple, pure‑function building blocks like map, filter, and reduce, the article shows how functional programming techniques underpin Redux and React, providing a systematic way to tame front‑end software complexity.
CompositionReactRedux
0 likes · 22 min read

This article explains the concept of higher‑order components (HOCs) in React, demonstrates basic and advanced implementations—including parameterized HOCs, display‑name handling, composition with compose, and practical examples such as loading and copy utilities—while comparing HOCs with parent components and recommending open‑source libraries.
CompositionDecoratorHigher-Order Component
0 likes · 10 min read

JavaScript functional programming, once a niche topic, has surged in popularity since ES6, and this article explores practical implementations—showcasing functional code versus traditional approaches, benefits like clearer semantics and reusability, common models such as closures, higher‑order functions, currying, and composition, plus optimization techniques.
CompositionCurryingJavaScript
0 likes · 12 min read
