This personal narrative follows a developer’s journey from a childhood fascination with computers to mastering frontend engineering, emphasizing the role of theory, professional depth, goal‑setting techniques, and altruistic teamwork in achieving lasting workplace happiness.
The article reflects on how rushed schedules, misguided management tools, inexperienced developers, and ego‑driven customizations create and perpetuate low‑quality code, urging developers to recognize technical debt, avoid reckless refactoring, and seek realistic project timelines and proper team practices.
The article outlines ten ethical principles for software developers—drawn from Robert C. Martin’s *The Art of Cleanliness*—that stress integrity, high-quality code, teamwork, continuous integration, frequent small releases, rigorous testing, proactive maintenance, and lifelong learning to prevent harmful failures in critical systems.
This article explains why traditional object‑oriented design patterns such as Strategy, Factory Method, Singleton, and Iterator often become unnecessary or overly complex in Python, illustrating with concise code examples how Python’s first‑class functions, dynamic typing, and built‑in constructs can replace them for clearer, more maintainable solutions.
Reliability and resilience are distinct yet complementary goals for cloud services; reliability is the outcome of consistently meeting performance expectations, while resilience describes a system’s ability to continue operating despite failures, and this article introduces the concepts and outlines a four‑part series exploring related threats and enhancement techniques.
This article explains how software architects use modeling techniques and UML diagrams to create clear, stakeholder‑focused design documents that capture domain problems, system structure, and implementation details across requirement analysis, conceptual design, and detailed design phases.
This article explains the basic concepts of software modeling, the role of UML diagrams, and how to organize those models into a coherent software design document that guides architects, developers, testers, and stakeholders throughout the development lifecycle.
This article explores four essential thinking modes—abstract, layered, inductive, and structured—illustrating how they help engineers quickly grasp new domains, simplify complex problems, and improve collaboration, with real‑world analogies from cooking, system design, and daily work routines.
This article uses humorous everyday scenarios to illustrate 21 classic software design patterns, explaining each pattern's intent, structure, advantages, and drawbacks, helping readers grasp abstract concepts through relatable analogies.
This article introduces the concept of software architectural patterns, explains why they are essential, and details five popular patterns—layered, microkernel, event‑driven, microservices, and space‑based—along with guidance on when and where to apply each.
This article details how Industrial and Commercial Bank of China (ICBC) tackled rapid product demand and limited R&D resources by designing a unified, enterprise‑level DevOps platform that streamlines continuous integration, delivery, and deployment, improves collaboration, and supports future digital transformation initiatives.
Since 2019 low‑code has surged as a disruptive development model that lets enterprises, especially SMEs, rapidly configure and publish applications with minimal coding, dramatically cutting delivery time, costs, and technical barriers while boosting productivity and business value.
Drawing on more than two decades of programming experience, the author shares ten practical lessons about continuous learning, teamwork, readable code, patience, consistency, mentorship, networking, regular breaks, relationship building, and realistic expectations of companies, offering actionable guidance for developers at any stage of their career.
This article summarizes Professor Niu Xiaoling’s GNSEC 2022 keynote, outlining the XOps framework and its five pillars—XOps, DevOps research and operational efficiency metrics, AIOps, BizDevOps, and FinOps—while detailing their drivers, maturity models, implementation examples, and the role of standards in guiding enterprises toward intelligent, cost‑effective, and business‑value‑focused software delivery.
The article lists ten common detrimental habits of software developers—such as insufficient rest, refusing help, stopping learning, messy code, work‑life imbalance, office politics, not learning from mistakes, quitting too early, acting omniscient, and rejecting constructive criticism—and offers practical advice on how to recognize and overcome each one.
This tongue‑in‑cheek article lists a series of deliberately bad coding practices—ranging from confusing naming conventions and deceptive comments to abusive design choices and omitted testing—intended to illustrate how developers can make their software virtually impossible to maintain.
Baidu Technical Salon on June 11 will host a forum on engineer development in the AI era, featuring senior engineer Zhang Miao and academic and industry experts discussing education, professional qualities, career paths, and talent cultivation to improve cost efficiency amid AI‑driven transformation.
This article explains the evolution of programming—from machine code, assembly, and high‑level languages—to the software crises that led to structured programming, object‑oriented design, and ultimately the emergence of software architecture as a solution for managing system complexity.
This article explores how abstract, layered, inductive, and structured thinking empower engineers to quickly grasp new domains, solve problems efficiently, and design robust systems, illustrated with real‑world analogies, workflow examples, and practical frameworks for everyday technical work.
This article traces the evolution of software development—from machine language and assembly to high‑level languages—explores the two software crises, explains why software architecture emerged, and clarifies core concepts such as systems, subsystems, modules, components, frameworks, and architecture itself.
The article explores the concept of digitalization, its benefits, real‑world wartime applications in Ukraine such as Air Alert and Diya, and parallels these innovations with China’s pandemic‑era tools and government mini‑programs, ultimately urging programmers to drive the next wave of digital transformation.
This article explores the evolution of software development from machine code to high‑level languages, explains the two software crises and their solutions, defines system, subsystem, module, component, framework and architecture, and concludes that software architecture is a strategic response to system complexity requiring careful judgment and trade‑offs.
This article outlines practical steps for developers aspiring to become CTOs, covering expanded skill sets, community building, leadership preparation, and learning to let go, while highlighting real‑world examples from industry leaders and offering actionable strategies for career growth.
The article explores why learning abstract models, fundamental computer concepts, and philosophical methodologies is more valuable than merely acquiring transient knowledge, emphasizing mathematics, binary logic, Von Neumann architecture, compilation, distributed systems, and independent critical thinking.
In this article, a tech leader shares ten concrete practices—from delegating authority to group leads and building personal trust, to handling on‑call releases and protecting subordinates—that have helped him effectively manage a diverse 100‑plus‑person engineering organization.
This article explains how technical architecture transforms product requirements into concrete systems, tackles uncertainty in technology choices, and presents strategic principles—fit, simplicity, evolution—alongside tactical guidelines for high concurrency, high availability, and business design, supported by logical and physical diagram examples.
This article outlines eight practical recommendations for boosting R&D efficiency, from tackling pain points and adopting a global perspective to ensuring continuous improvement, avoiding vanity metrics, and embracing a service mindset, emphasizing measurable outcomes and the importance of using the platform yourself.
The article explains that dynamic programming boils down to two core ideas—treating problems as a set of independent sub‑problems via divide‑and‑conquer and using memoization to avoid redundant calculations—illustrated with analogies to business management and contrasted with plain recursion.
This article explains why proper logging is essential for software maintenance, outlines the purposes of logs, details best‑practice requirements such as readability, performance impact, disk usage and timeliness, and provides a comprehensive guide to Log4j components, log levels, their hierarchy, and practical code examples for each level.
Retool’s 2022 survey of 600 engineers reveals that open‑source code is now essential, developers copy hundreds of lines weekly, and major frustrations include testing, slow SQL, and lengthy code‑review delays, leaving engineers with only about ten hours of deep work each week.
This article provides a comprehensive guide to continuous delivery, covering its definition, consensus and management mechanisms, required infrastructure, configuration and testing strategies, trunk and local development practices, six‑step commit workflow, code review, metrics, DevOps concepts, and information traceability.
A former software engineer shares a candid, side‑by‑side comparison of age distribution, overtime expectations, code quality practices, workplace atmosphere, and life outside work between US and Chinese tech firms, revealing cultural contrasts and their impact on daily professional life.
This article explains software design patterns, their origins, key examples, and how MITRE system engineers can apply them to manage coupling and interface design in large enterprise service environments, emphasizing loose coupling, best‑practice guidelines, and practical lessons learned.
This article humorously illustrates 23 classic software design patterns—such as Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—using everyday relationship scenarios to make each pattern’s intent and structure easy to grasp.
The article analyzes the massive, heterogeneous, and frequently changing information‑display features in Meituan's local‑service platform, proposes a standardized, component‑based, assembly‑oriented BFF architecture with series‑based function classification, pre‑assembly, and variability modeling, and reports over 50% efficiency gains and reduced interface complexity.
Softtone Power’s iPaaS technology platform successfully passed the third‑level DevOps continuous‑delivery assessment conducted by the China Academy of Information and Communications Technology, with its CTO and chief architect discussing the project’s architecture, the motivations for joining the evaluation, the tangible efficiency gains, and future DevOps initiatives.
The April 2022 survey of 164,126 programmer salary records across China reveals an average monthly pay of 16,019 CNY, a median of 13,000 CNY, and a 90% range of 5,250 CNY to 37,500 CNY, while detailed city and career tables show regional and functional variations in wages and job demand.
The article reflects on a developer's sharing session about design patterns, examines why they are often ignored in complex business scenarios, discusses performance and class‑explosion concerns, team and agile constraints, and offers practical steps to sustain code standards and pattern usage.
This satirical guide enumerates absurd techniques—from confusing naming conventions and deceptive comments to overloaded functions and excessive nesting—that deliberately make code hard to read, test, and maintain, offering a tongue‑in‑cheek look at worst‑case software engineering practices.
In this interview, Shopee backend engineer Draven discusses how his early blogging evolved into authoring a comprehensive Go language design book, compares book‑writing to blog series, shares his research‑driven learning methods for new technologies, outlines his current focus on OS, networking and C++, and invites readers to suggest technical books for a World Book Day giveaway.
Microsoft's Jigsaw tool leverages post‑processing and user feedback to improve large language model code synthesis, especially for Python Pandas, achieving up to 80% accuracy and aiming to automate code verification and debugging for developers.
The article reflects on a team sharing session about design patterns, examining why they often aren’t applied in complex business scenarios, discussing performance, class explosion, team skill gaps, project constraints, and offering practical recommendations to balance code standards with real‑world development pressures.
The article discusses the importance of proper application layering in backend development, critiques common misuse of controller and service layers, outlines Alibaba's recommended multi‑layer architecture—including open API, presentation, web, service, manager, and DAO layers—offers optimization suggestions, and highlights domain model conversions.
Mob CR, short for Mob Code Review, is a team‑oriented, five‑step process that uses collective code inspection to establish shared quality standards, educate newcomers, and align developers on better design and implementation practices.
This article examines the nature of design patterns, their relationship to code standards, and the practical challenges of applying them in business development, discussing performance, class explosion, team skill levels, project environment, agile timing, and strategies for maintaining sustainable code quality.
This article outlines ten key attributes of high‑quality code—robustness, efficiency, simplicity, brevity, testability, reusability, portability, observability, operational readiness, and scalability—while contrasting them with common bad‑code patterns and explaining how solid requirement analysis, system design, testing, and continuous iteration produce truly good software.
This article outlines ten key characteristics of high‑quality code, illustrates common bad‑code pitfalls, and explains how thorough requirement analysis, system design, testing, and operational practices together produce maintainable, efficient, and scalable software.
Software bugs can cause massive financial losses, from the Y2K scare to NASA's Mars Climate Orbiter mishap, illustrating how seemingly small coding errors can lead to downtime, data loss, reputation damage, and costs reaching billions of dollars.
The author recounts a decade‑long journey of reading open‑source Java frameworks—from Tomcat and Spring to Netty, Dubbo, and the Linux kernel—highlighting how systematic shortcut practice, debugging techniques, and focused inquiry transformed his development skills and offers guidance for others seeking a similar path.
In this interview, Ant Group frontend engineer Liu Kui shares when micro‑frontend is appropriate, how to split large applications, challenges faced, future trends, and upcoming features of the qiankun framework, offering practical guidance for teams considering micro‑frontend adoption.
This article shares ten practical principles—ranging from owner mindset and time awareness to design priority and a humble attitude—that help engineers avoid common pitfalls, improve personal and team efficiency, and continuously grow in their technical careers.
The article explains that, despite decades of research, developers still devote the majority of their work to comprehending legacy code and system architecture, highlighting studies that show roughly 58‑67% of effort is spent on program comprehension rather than building new features.
This article presents ten essential guidelines for technical documentation, covering clear subject‑verb‑object sentences, proper use of pronouns and transition words, strong verbs, correct terminology, effective paragraph structure, concise openings, appropriate length, visual aids, lists and tables, consistent style, and overall document architecture.
The 2022 Hired Software Engineer Report, based on over 366,000 market interactions and 2,000 survey responses, reveals soaring demand for engineers, highlights Go as the top‑requested skill, outlines salary growth across security and AI roles, and shows how remote‑work openness boosts interview opportunities.
This article examines why developers produce low‑quality code, describes typical symptoms such as unreadability and excessive nesting, outlines the long‑term costs and risks of bad code, and presents expert‑recommended practices—including code reviews, design documentation, technical debt repayment, and disciplined development processes—to improve code quality.
This article presents ten practical principles for technical documentation—including mastering subject‑verb‑object structure, avoiding overuse of pronouns and punctuation, using strong verbs, maintaining consistent terminology, and structuring paragraphs, lists, and tables—to help engineers write clear, concise, and reader‑friendly documents.
This article shares a front‑end engineer’s personal growth story, outlining four career stages—from initial workplace adaptation to leading low‑code platform development—while offering practical advice on teamwork, communication, continuous learning, and how to transition into senior technical and leadership roles.
The article outlines ten key characteristics of high‑quality code—robustness, efficiency, simplicity, brevity, testability, reusability, portability, observability, operability, and scalability—while contrasting them with common bad‑code examples and emphasizing the importance of thorough analysis, design, testing, and continuous improvement throughout the software development lifecycle.
A former computer science graduate shares a month‑long experience as a software engineer in a remote manufacturing hub, describing the modest salary, work environment, legacy tech stack, lack of documentation, and practical advice for anyone considering a similar role.
Tencent’s 2021 R&D Report details a 41% rise in engineering staff, 32 billion new code lines, Go becoming the top language, massive growth in open‑source contributions, breakthroughs in cloud OS, databases, AI, and a commitment to carbon‑neutral technology‑driven social impact.
After a month and a week as a software engineer in a remote high‑tech manufacturing zone, the author shares candid observations on the prevalent use of Java, .NET, legacy frameworks like SSH/SSM, limited documentation, occasional front‑end tasks, and practical tips for thriving in such environments.
This article provides an in‑depth analysis of Tencent Cloud WeDa low‑code platform, covering its definition, evolution, market adoption, core capabilities, architecture, backend practices, development workflow, high‑availability design, and future trends, while explaining why low‑code boosts efficiency and digital transformation.
The article explores the origin and purpose of the infamous deadbeef constant and other so‑called magic numbers in C/C++ code, explains why they appear, shows real examples, and advises developers to replace them with named constants for clearer, safer code.
Building a strong technical culture in engineering teams requires top‑down commitment to respect engineers, fostering knowledge sharing, automating tools, hiring curious innovators, and rewarding experimentation, so that contributions are valued, innovation thrives, talent is retained, and teams become more productive and satisfied.
The article outlines a comprehensive technical growth mindset for engineers, describing seven progressive thinking modes—problem, tool, product, data, risk, production‑relationship, and craftsmanship/evangelism—plus brand and team mindsets, emphasizing lifelong learning and systematic self‑development.
This article explains common Python code smells in an employee‑management example, demonstrates why practices such as using raw strings for roles, duplicated search methods, excessive isinstance checks, and vague boolean flags are problematic, and provides a step‑by‑step refactor using Enums, abstract base classes, list comprehensions, custom exceptions, and clearer method separation.
The article outlines eight essential thinking modes—problem, tool, product, data, risk, production‑relationship, craftsmanship/evangelism, brand, and team mindsets—that help engineers navigate complex business and technology challenges, accelerate personal growth, and achieve lasting impact.
This article explores layered thinking in architecture design, detailing decomposition and integration, cloud three‑layer models, SOA component‑service‑process layering, and how to combine these approaches into coherent technical and application architectures for balanced business‑technology solutions.
This article explores the origins of the Go programming language by examining its earliest code commits, the role of Brian Kernighan’s historic "hello world" snippet, the transition through multiple version‑control systems, and the eventual establishment of the official Go specification.
Despite relentless Russian attacks, Ukraine's vast community of software engineers continues to deliver code and support both civilian and military efforts, illustrating remarkable resilience and the critical role of remote tech teams in global supply chains.
The article presents thirty concise architectural principles—ranging from simplicity, YAGNI, iterative development, automated testing, ROI, user‑centric design, modularity, to distributed system concerns like statelessness, idempotency, CAP theory, and configuration best practices—offered as a practical guide for architects and development teams.
The team behind the open‑source ArchGuard platform recounts their migration from Maven to Gradle, library updates, and a surprising shift from a microservice‑based system to a monolithic architecture, explaining the challenges of legacy services, the principles guiding service granularity, and the practical benefits of a single‑code‑base deployment for a small open‑source project.
This article translates Mahesh Balakrishnan’s 42‑point guide on building production databases, covering customer focus, project management, design principles, code review practices, strategy, observability, and research, offering concrete advice for engineers and teams creating robust backend systems.
The article explores why individuals with similar backgrounds achieve different results, argues that systematic practice, deep understanding, and reflective learning—illustrated with examples like MySQL troubleshooting, TCP three‑way handshake, and SSH key management—can bridge knowledge gaps and enhance problem‑solving abilities.
This article explains the concept of layered thinking in architecture design, covering decomposition and integration, cloud three‑layer models, SOA component‑service‑process layering, application‑level layering, and how to combine these approaches into coherent, multi‑view architecture diagrams for both technical and functional perspectives.
This article examines design patterns as a form of code standard, discussing their definition, relevance in everyday business development, common pain points such as performance overhead, class explosion, team skill gaps, project constraints, and offers practical recommendations for balancing best practices with real‑world constraints.
This guide outlines a practical seven‑step methodology for mastering Redis source code, from mapping the project structure and preparing prerequisite knowledge to focusing on core execution paths, handling complex functions, exploring side modules, and iteratively filling knowledge gaps.
This article explores the core principles of clean code—including effective naming, purposeful comments, single‑responsibility functions, proper abstraction levels, and essential testing practices—illustrated with concrete code examples and actionable guidelines for writing more readable, maintainable software.
This article explains the importance of clear architecture diagrams, defines architecture and its visual representations, outlines common diagram types and pitfalls, and introduces the C4 modeling approach with practical guidance for creating self‑describing, audience‑focused system diagrams.
Four Xianyu engineers share how mastering core fundamentals, continuously exploring new domains, understanding business contexts, and building structured yet adaptable learning roadmaps—while leveraging open‑source tools, cross‑disciplinary knowledge, and practical experience—can help software developers transition between fields and sustain long‑term growth.
A 29‑year‑old programmer who left a Beijing IT firm on the day of a major sales event deleted the coupon, budgeting, and subsidy code he wrote for the JD.com delivery platform, was later sentenced to ten months in prison and fined, sparking widespread discussion about code‑ownership, permission management, and the criminal liability of destroying computer information systems.
The article shares a senior engineer’s practical experience on combining open‑source and self‑developed components, analysing their advantages, lifecycle stages, and concrete strategies—including problem definition, selection, source‑code control, and ten actionable tips—to help teams balance cost, innovation, and stability.
This article explains why API design is crucial for AI open-source software, outlines new challenges, presents basic design principles, and offers practical guidelines, examples, and best practices to create user-friendly, stable, and extensible interfaces that lower learning costs and foster ecosystem growth.
This article explores twenty common coding pitfalls—from poor formatting and meaningless naming to deep nesting, hard‑coding, and missing unit tests—offering practical refactoring tips, design‑pattern solutions, and best‑practice guidelines to improve code readability, maintainability, and performance.
The article explains layered architecture thinking, covering cloud three‑tier models, SOA layering, classic three‑layer application design, domain‑driven refinements, and practical guidance on constructing clear, maintainable system diagrams without mixing incompatible modeling approaches.
This article examines why many developers struggle with low productivity, revisits Brooks' 10x programmer insight, and introduces a simple three‑question thinking framework plus five practical principles to help programmers clarify goals, assess current status, and plan effective execution paths.
This article explains how layered thinking and layered models—covering decomposition, integration, cloud three‑layer architecture, SOA layering, and application architecture—provide a systematic approach to designing balanced, cohesive, and loosely‑coupled software systems.
This article examines what design patterns really are, why they are considered a form of intermediate‑level code standards, the performance and class‑explosion concerns in business development, and offers balanced recommendations for maintaining code quality and applying patterns effectively in real‑world projects.
This article outlines twenty common bad habits of programmers—from inconsistent terminology and poor documentation to neglecting official docs and inadequate testing—explaining why they hinder growth and offering concrete advice on how to develop professional coding, communication, and teamwork skills.
This article shares practical insights on balancing open‑source and self‑developed components in core platform projects, covering advantages, lifecycle stages, performance profiling, code‑base management, and engineering practices that help teams achieve sustainable growth and innovation.
The article explains that technical debt stems not from clumsy coding but from poor communication and inadequate domain modeling, leading to fragmented abstractions, excessive boolean flags, and ultimately software bankruptcy, and suggests collaborative, model‑driven practices to reduce it.
The article explains how software engineers apply engineering principles to design and manage complex systems, while software developers focus on writing functional code, detailing their distinct responsibilities, required skills, typical tasks, and how the two roles can overlap in practice.
The article outlines why many interview candidates fall short, categorizes three typical applicant types, and explains the key reasons interviewers decide to advance a candidate—strong communication, solid fundamentals like networking and databases, algorithm proficiency, and genuine learning attitude.
The article argues that every software developer should also act as an architect, outlining the differences and overlaps between developers and architects in terms of focus, leadership, experience, mindset, decision‑making, and career progression, and emphasizing the value of combining both perspectives.
The article humorously showcases a series of poorly written code examples—from magic numbers and overly long variable names to emoji variables and convoluted switch statements—offering developers reflective commentary on common pitfalls and encouraging better coding practices.
This article explains the three‑tier architecture pattern—its UI, business logic, and data access layers, the role of an entity layer, a practical restaurant analogy, and the advantages and drawbacks compared to two‑tier designs, highlighting high cohesion and low coupling.
The article introduces “Suffering‑Oriented Programming,” a risk‑averse development approach that prioritizes only truly painful problems, follows the three maxims “first make it possible, then make it beautiful, finally make it fast,” and illustrates its application in building Storm’s distributed stream‑processing system.
This article explains Data Flow Diagrams (DFD), their hierarchical structure, and provides a detailed customer service system example, covering context and level‑1 diagrams, data store types, design tips, and common pitfalls for effective system modeling.
To celebrate the 2022 New Year, Meituan’s technology team offers a curated gift of the 22 most‑read and most‑watched 2021 technical articles—spanning logging, knowledge graphs, GraphQL, data warehousing, performance, security, and more—while inviting readers to complete a survey for a chance to win a premium keyboard wrist rest.
The article examines common pain points of API management in agile, front‑back separation projects and evaluates Apifox as a comprehensive solution that offers visual design, powerful debugging, automatic code generation, real‑time updates, and fine‑grained project permissions.
