Tagged articles
abstraction
64 articles · Page 1 of 1
This article distinguishes architecture from architecture diagrams and outlines eight interconnected capabilities every architect needs: abstraction to identify key attributes, focus to prioritize constraints, decomposition by design decisions, boundaries to assign ownership, contracts to decouple implementations, trade-offs as explicit prioritization, adapting to constraints as design inputs, and evolvability as the compound result of the previous seven.
Contractsabstractionarchitect capabilities
0 likes · 22 min read

This article explores abstraction as the fundamental technique for managing complexity in computer science, covering its philosophical roots, computational abstraction via functions and higher-order functions, data abstraction with abstraction barriers, and metalinguistic abstraction through language design.
abstractionabstraction barrierscomplexity management
0 likes · 11 min read

The article explores naming as a fundamental abstraction mechanism in programming, drawing on SICP to show how naming enables modularity, controls complexity, creates vocabularies, and underpins environments, scope, and first-class functions, arguing naming is not mere labeling but a cognitive tool for building higher-level concepts.
EnvironmentSICPabstraction
0 likes · 15 min read

The article explains that beyond a rich ecosystem and job market, Java's enduring popularity stems from its core design principle of abstraction—embodied in bytecode—that isolates software from underlying hardware and platform changes.
JVMJavaPlatform Independence
0 likes · 4 min read

The article traces how low‑level programming harnesses—from ENIAC wiring and punch‑card code to assembly, compilers, operating systems, database optimizers, and memory‑management techniques—have been progressively abstracted away by tools, type systems, and language semantics, highlighting what has been "eaten" and what still requires manual expertise.
CompilerRustabstraction
0 likes · 12 min read

A great system architect must go beyond solid technical skills, mastering trade‑off analysis, true abstraction, complexity simplification, time‑dimension thinking, and systemic thinking to design high‑performance, maintainable solutions that align with business value.
DDDabstractioncomplexity reduction
0 likes · 7 min read

The article explains why many engineers struggle to become architects, compares the roles, and outlines three critical capabilities—abstraction, trade‑off reasoning, and communication—along with concrete methods and a staged roadmap for developing each skill.
Trade‑offabstractioncareer development
0 likes · 10 min read

The article explains that mastering programming thinking—decomposition, abstraction, and pattern recognition—is essential for solving real problems, using everyday examples and concrete code snippets to show how thought processes precede and guide actual code.
abstractioncoding fundamentalsdecomposition
0 likes · 6 min read

The reviewer argues that software design is fundamentally conceptual modeling, where naming concepts constitutes abstraction—a highly difficult process—and praises the book 'Semantic Software Design' for focusing on this core challenge.
Semantic Software Designabstractionbook review
0 likes · 3 min read


21CTOFeb 15, 2026 · Fundamentals
The article examines how recurring predictions of software engineering’s demise have been reshaped by AI, tracing three golden ages—from algorithmic to object‑oriented to platform abstraction—and argues that AI is a catalyst for a new era rather than an industry terminator.
AIabstractiongolden age
0 likes · 12 min read

The article explains that operating systems act as resource allocators, isolators, and abstraction layers, enabling multiple programs to share limited CPU, memory, and disk resources safely and efficiently through scheduling, memory partitioning, and hiding hardware complexities.
Process Schedulingabstractionfundamentals
0 likes · 6 min read

This article explains how modeling—by abstracting key variables, defining boundaries, ensuring logical consistency, and testing against reality—helps us simplify complexity, make better decisions, and gain certainty in an uncertain, information‑overloaded world.
abstractioncritical thinkingdecision making
0 likes · 9 min read

Effective problem solving relies on a four‑stage modeling process—phenomenon, logical analysis, concrete model, and abstract model—guiding the transition from real‑world observation to generalized mathematical structures, enabling systematic abstraction and broader applicability across diverse domains.
abstractionlogical analysismathematical modeling
0 likes · 10 min read

This article explores the true nature of modeling as a way of abstracting, structuring, computing, and validating complex systems, outlines its four essential stages, discusses philosophical foundations, domain variations, and common pitfalls, and emphasizes its role as both a tool for understanding and shaping the world.
SimulationSystemsabstraction
0 likes · 9 min read

The article argues that complexity in software cannot be eliminated, only shifted to well‑defined places, explains why abstractions leak, explores the limits of local consequence, and shows how eliminating duplication and thoughtful layering can still reduce overall complexity.
abstractioncode organizationlocal consequence
0 likes · 9 min read

The article explores how stories function as simplified, abstract models of reality, comparing narrative structures to formal modeling, showing how extracting assumptions from tales enhances critical thinking, and arguing that giving models a story-like context makes them more relatable and persuasive.
abstractioncognitivecritical thinking
0 likes · 8 min read

The article argues that software engineering is fundamentally a discipline for managing complexity, entropy, and information flow, and that understanding its first‑principles—trade‑offs, abstraction, process, feedback, and automation—is essential to avoid ritualistic practices and deliver sustainable value.
ComplexityFeedbackabstraction
0 likes · 10 min read

The article explains that while encapsulation, inheritance, and polymorphism are often highlighted, true software craftsmanship hinges on the ability to abstract—identifying essential features, discarding irrelevant details, and modeling problem domains through steps like analysis, concept extraction, and system design, supported by principles such as low coupling, high cohesion, sufficiency, and completeness.
CohesionDesign Principlesabstraction
0 likes · 10 min read

This article explains Go 1.16’s io/fs package, its purpose as a unified file‑system abstraction, the core and extended interfaces it defines, practical use‑cases such as testing, embedded resources, memory and cloud storage, and provides multiple runnable code examples.
Filesystemabstractioncloud storage
0 likes · 15 min read


DevOpsOct 31, 2024 · Backend Development
This article explores the core competencies of backend engineers, emphasizing accurate problem abstraction, discusses Go's ServerCodec and I/O interfaces, demonstrates algorithmic solutions to the Word Search II problem, and offers practical advice on improving coding skills through studying language features, system design, and effective learning habits.
AlgorithmBackendabstraction
0 likes · 19 min read

This article explains Joel Spolsky's law of leaky abstractions, illustrating with TCP/IP, database queries, file systems, and language design how seemingly simple abstractions can expose underlying complexities that affect performance, reliability, and developer effort.
abstractionleaky abstractionprogramming
0 likes · 12 min read

The author reflects on learning to draw a cheerful cartoon sheep and draws insightful parallels to mathematical modeling, showing how abstraction, overall layout, detailed refinement, and iterative optimization in art mirror the steps of building and improving models for real‑world problems.
Analogyabstractioncartoon drawing
0 likes · 6 min read

The article reflects on the difficulties of turning abstract design concepts such as GOF patterns and DDD into practical, reusable middle‑platform services for an e‑commerce business, discussing when to abstract, the trade‑offs between thin and thick services, and how to balance efficiency with evolving business needs.
abstractionbackend developmentmiddle platform
0 likes · 16 min read


DevOpsJul 18, 2024 · Fundamentals
The article explains architectural thinking as a systematic approach to decompose problems, highlighting five core principles—abstraction, global perspective, layered design, evolutionary mindset, and standardization—that help engineers manage complexity, improve design quality, and adapt software systems over time.
Design Principlesabstractioncomplexity management
0 likes · 10 min read

The article argues that in early development stages, a small amount of code duplication should be tolerated, warning against premature DRY abstractions that can lead to over‑engineered designs, and advises waiting for genuine common patterns before introducing shared abstractions.
DRYYAGNIabstraction
0 likes · 3 min read

The article reflects on the insights from Zhang Xiaolong's WeChat product philosophy, emphasizing that overly complex solutions indicate flawed problems, that engineers should help shape product requirements, that abstraction simplifies systems, and that a strong desire to change the status quo drives innovation and effective technical management.
R&D managementabstractioninnovation
0 likes · 11 min read

This article explains three core abstraction techniques—simplifying, generalising, and layered abstraction—illustrates each with clear Go code examples, discusses their benefits and trade‑offs, and shows how to apply them effectively to improve maintainability and reuse in software projects.
Goabstraction
0 likes · 8 min read


21CTOMay 19, 2024 · Fundamentals
This article explores the power of abstraction in software design, explaining its hierarchical levels, the role of interfaces, and practical questions to ask when modeling real‑world problems, guiding developers to create more maintainable, scalable, and communicative systems.
SOLIDabstractioninterfaces
0 likes · 7 min read

This article explains the core concept of abstraction in software engineering, illustrating how using interfaces and abstract methods in PHP can simplify code, improve maintainability, and reduce developer focus on low‑level details, demonstrated through concrete Shape examples for rectangles, circles, and triangles.
InheritancePHPabstraction
0 likes · 5 min read


21CTOFeb 7, 2024 · Fundamentals
This article explains how architects manage complexity through abstraction, offering practical induction and deduction techniques to identify commonalities, relationships, and characteristics, and illustrating these methods with real‑world examples like installment financing and Java technology.
abstractioncomplexity managementdeductive reasoning
0 likes · 9 min read

This article introduces the core concepts of object‑oriented programming—classes, objects, abstraction, encapsulation, inheritance, and polymorphism—using clear explanations and practical PHP code examples that demonstrate class definitions, object instantiation, method calls, and inheritance hierarchies.
ClassesEncapsulationInheritance
0 likes · 9 min read

The article explains that an operating system acts as a resource allocator, isolates processes to maintain system order, and abstracts hardware complexities, using examples of CPU scheduling, memory management, and networking to illustrate why OSes are essential for modern computing.
Process Schedulingabstractionmemory management
0 likes · 7 min read

The article examines how low‑code platforms and domain‑specific languages (DSL) can transform repetitive CRUD development in front‑end engineering into a more abstract, maintainable workflow, highlighting their benefits, limitations, and practical Vue‑based implementations.
CRUDDSLVue
0 likes · 17 min read

This article explains the essential characteristics, primary functions, and various classification schemes of mathematical models, highlighting their abstraction, accuracy, predictive power, and how they simplify, simulate, and apply to real‑world phenomena across deterministic, stochastic, fuzzy, and abrupt domains.
abstractionmathematical modelingmodel characteristics
0 likes · 8 min read

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.
CachingDesign PrinciplesMoore's Law
0 likes · 11 min read

The article explains how abstract thinking—extracting common traits, ignoring irrelevant details, and managing hierarchical levels—empowers programmers to write more reusable, maintainable code, illustrated with philosophical analogies, OOP examples, and concrete refactoring of type‑casting logic.
abstractioncode qualityobject-oriented programming
0 likes · 10 min read


phodalApr 18, 2022 · Fundamentals
The article explores the true meaning of a technical expert by examining how abstract modeling of real‑world locations, hierarchical administrative divisions, and domain‑specific type systems—illustrated with OpenHAB examples—can transform a programmer’s understanding into expert‑level conceptual and communicative abilities.
OpenHABType Systemabstraction
0 likes · 12 min read

This article examines the intricate data processing challenges of a mobile message client, outlines seven key complexities, proposes a unified abstraction layer to reduce code by 60%, and details a modular solution—including MergeDispatcher, Calculator, and DataStructure—that separates computation from data fetching for improved consistency and scalability.
abstractionarchitecturedata processing
0 likes · 12 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 explores the essence of computing by tracing how basic circuits, binary encoding, and layered abstractions from hardware to software enable modern digital devices, illustrating concepts with bicycle analogies, circuit diagrams, and historical insights into binary's development.
Softwareabstractionbinary encoding
0 likes · 15 min read

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.
Design PrinciplesProgramming ParadigmsSOLID
0 likes · 21 min read


ITPUBSep 7, 2021 · Fundamentals
This article compiles practical guidelines and personal experiences on writing clean, maintainable code, covering principles such as eliminating duplication, separating concerns, unifying abstraction levels, function design, naming, unit testing, and broader software‑engineering concepts to reduce mental load and improve code quality.
Clean CodeCoding Best Practicesabstraction
0 likes · 24 min read

This article explores the concept of abstraction leaks in software design, especially within front‑end development and low‑code platforms, explains why they occur, illustrates common symptoms, and offers practical strategies for developers to manage, redesign, or mitigate such leaks.
abstractionarchitectureleaky abstractions
0 likes · 25 min read

The article introduces the concept of business architecture, explaining how abstract architectural design must be grounded in concrete business needs, and discusses the difficulty of bridging design patterns with real‑world value creation, illustrated through a series of explanatory diagrams.
Business ArchitectureImplementationabstraction
0 likes · 2 min read


21CTOApr 14, 2021 · Fundamentals
This article explains how abstract thinking underpins software design, illustrates abstraction with visual and code examples, shows the pitfalls of duplicated code and forced casts, and offers practical habits—reading, summarizing, naming, and domain modeling—to strengthen a developer's abstraction skills.
abstractioncode refactoringdomain modeling
0 likes · 24 min read

This article explains how abstract thinking underpins software engineering, covering definitions, the relationship between language and abstraction, levels of abstraction, layered design, the pitfalls of duplicate code and forced casts, and practical ways to strengthen one’s abstract reasoning skills.
Coding Practicesabstractionmodeling
0 likes · 22 min read


政采云技术Dec 1, 2020 · Frontend Development
This article explains how to write high-quality, maintainable frontend code by exploring component abstraction, granularity, design principles, and classification—from atomic to page-level components—illustrated with React and Vue examples, code snippets, and practical guidelines for balancing reuse and complexity.
Code MaintainabilityVueabstraction
0 likes · 15 min read

The article explores how abstract thinking and complexity influence a product manager's abilities, explains the purpose and timing of creating product architecture diagrams, and provides detailed guidance on different diagram types, their design methods, and practical steps for visualizing product, service, and ecosystem structures.
ComplexityDesign ThinkingProduct Architecture
0 likes · 11 min read

This article explains the basic concepts of operating systems, covering their role as a hardware abstraction layer, the distinction between kernel and user modes, and how OS resource management (time‑sharing and space‑sharing) enables multiple programs to run safely and efficiently.
abstractionfundamentalskernel-mode
0 likes · 10 min read

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.
Design PrinciplesJavaSpring
0 likes · 9 min read

This article explains what an architecture diagram is, why it matters, and provides a step‑by‑step methodology—including business and system modeling, abstraction techniques, and evaluation criteria—to help engineers create clear, purposeful diagrams for diverse stakeholders.
Software Modelingabstractionarchitecture
0 likes · 29 min read

This article explains what an architecture diagram is, why it matters, and provides a step‑by‑step methodology—including business and system modeling, abstraction techniques, diagram classification, drawing guidelines, and quality evaluation—to help engineers produce clear, purposeful diagrams that improve communication and collaboration.
abstractiondiagram-designmodeling
0 likes · 28 min read


ITPUBJun 15, 2020 · Fundamentals
This article explains what an architecture diagram is, why it matters, and provides a step‑by‑step methodology—including business and system modeling, abstraction techniques, and quality criteria—to create clear, purposeful diagrams for software projects.
Design Principlesabstractiondiagram
0 likes · 30 min read

This article explains what an architecture diagram is, why it’s essential for communication and efficiency, and provides practical guidance on defining architecture, modeling processes, abstraction techniques, drawing methods, evaluation criteria, and the role of an architect in software development.
abstractionarchitecture diagramsmodeling
0 likes · 29 min read

The article explains programming fundamentals by likening code to cooking, defining programming as algorithms plus data structures, illustrating basic concepts such as conditionals, loops, and abstraction through simple code examples, and emphasizing the difference between novice and expert approaches.
Algorithmsabstractionbasics
0 likes · 8 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

The article explains what business architecture is, outlines its key characteristics, describes a four‑step method (systematic thinking, decomposition, abstraction, pattern), and demonstrates the approach with a detailed coupon‑service case study, illustrating how to model goals, processes, and elements into a clear architecture diagram.
Business ArchitectureCoupon SystemProcess Modeling
0 likes · 11 min read


21CTOMay 20, 2019 · Fundamentals
This article explains how abstract, layered, divide‑and‑conquer, and evolutionary thinking form the four essential mental tools that enable software architects to manage complexity, design scalable systems, and continuously evolve architectures in response to changing requirements.
Divide and Conquerabstractionarchitectural mindset
0 likes · 17 min read

The article explains how abstraction, layered design, divide‑and‑conquer, and evolutionary thinking form the four essential mental tools for architects to manage complexity, illustrating each concept with real‑world examples, diagrams, and practical advice for cultivating these skills.
Divide and Conquerabstractionarchitectural thinking
0 likes · 14 min read


21CTOJul 16, 2018 · Fundamentals
The article explains how mastering abstraction, layering, divide‑and‑conquer, and evolutionary thinking equips software architects to manage complexity, design modular systems, and continuously evolve architectures—from simple modules to large‑scale platforms—highlighting practical examples, interview questions, and learning pathways.
Divide and Conquerabstractionevolutionary design
0 likes · 14 min read

This article explains how abstraction, layered thinking, divide‑and‑conquer, and evolutionary design serve as the four fundamental mental tools that architects use to manage complexity in software systems, illustrated with everyday analogies, diagrams, and practical interview examples.
Divide and Conquerabstractionevolutionary design
0 likes · 15 min read

This article explores the seven core competencies—technical expertise, abstraction, design foresight, systematic thinking, problem‑solving depth, cross‑domain knowledge, and communication—that distinguish a successful software architect and guide how to develop them.
abstractioncommunicationcross-domain knowledge
0 likes · 13 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

Programming is inherently complex, requiring deep business understanding, systematic abstraction, indirection, early architectural planning, layered design, and cultivated intuition to produce clean, maintainable code that adapts to evolving requirements and reduces technical debt.
Frameworksabstractiondesign patterns
0 likes · 6 min read
