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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
