This article presents a series of downloadable system architecture templates covering DMP, blockchain, data quality governance, enterprise technology, data architecture, Xelerator, alarm platform, microservices, front‑back separation, and a generic architecture, each illustrated with descriptive diagrams and brief explanations.
China Post Savings Bank’s three core systems passed the Level 3 DevOps Continuous Delivery assessment, showcasing leading domestic capabilities, while senior leaders discuss the bank’s DevOps evolution, measurable improvements, future DevSecOps plans, and the broader industry standards driving these results.
Effective naming in software development, illustrated with real code examples and visual metaphors, transforms ambiguous code into clear, self‑documenting logic, improves readability, reduces errors, and aligns with best practices such as modeling, meaningful differentiation, and consistent style, ultimately enhancing maintainability.
Xinwang Bank’s distributed consumer loan core system passed the CAICT DevOps Level‑3 continuous delivery assessment, showcasing how standardized DevOps practices, toolchain integration, and agile development boosted code commits, build frequency, test coverage, and delivery speed, while providing insights into challenges, metrics, and future plans.
Ningbo Bank’s scenario payment system passed the Level 3 DevOps continuous‑delivery assessment, showcasing how standardization, tool empowerment, and agile practices transformed a traditionally waterfall project into a high‑speed, reliable platform, while the bank shares lessons, challenges, and future DevOps plans.
The China Academy of Information and Communications Technology unveiled its DevOps efficiency measurement model, with Baidu’s iReport platform becoming the first to achieve industry‑promotion level certification, and detailed the model’s modules, maturity levels, and practical insights for improving software development performance.
This article presents a step‑by‑step methodology for converting business domain models into robust data models, illustrated with a community group‑buying pre‑scheduling case, and discusses object identification, relationship definition, model refinement, and mapping to database structures to improve scalability and maintainability.
Silicon Valley’s tech workers, from a 48‑year‑old programmer to veteran engineers, increasingly resort to fitness, grooming, and costly cosmetic procedures to appear younger, driven by a pervasive “35‑year‑old” culture and implicit age discrimination that affects hiring, promotion, and career longevity.
This article examines the challenges of improving research and development efficiency in digital-era enterprises, presents real-world success and failure cases, outlines the roles of business, tool, coaching, and organizational teams, and offers practical do's and don'ts to achieve sustainable, business‑driven efficiency gains.
WeChat Pay’s team adopted lean, value‑driven development—using TAPD‑enabled value‑stream and agile kanban, small‑batch work, automation, and transparent metrics—to reconcile rapid growth with high‑quality delivery, build consensus across multiple teams, and continuously improve through retrospectives, visual OKR dashboards, and risk‑aware demand decomposition.
This article explains why front‑end technical design documents are essential, illustrates common pitfalls through a developer story, outlines the differences between front‑end and back‑end design, and provides a step‑by‑step template—including chapters, diagrams, and tool recommendations—to help teams produce clear, maintainable specifications.
The article explains why a solid code structure is essential, outlines the principles of single responsibility, reusability and clear definitions, and details the roles of Model, Util, Service, DAO and Controller, while discussing their relevance to Web, Android and iOS development.
In this extensive interview, industry veterans Zhao Haiping and Zhang Hongbo discuss the evolution of programming languages, compiler development, language design trade‑offs, and practical experiences across companies like Facebook, Alibaba, and ByteDance, offering valuable guidance for developers and researchers alike.
The article explains why high‑quality code boosts product and developer success, lists practical practices such as style standards, meaningful naming, testing, CI, reviews and pair programming, and recommends tackling improvements in three stages—first delivering business functionality, then enhancing readability, and finally reducing complexity.
This article recounts the complete redesign of a 2500‑person factory's Delphi‑based supply‑chain system, detailing the shift to a front‑end/back‑end separated architecture using React, Ant Design, and .NET Core 3.1, while addressing data consistency, rounding issues, UI habits, printing, and deployment challenges.
This article compiles a series of visual skill maps covering DevOps, cloud computing, big data, security, architecture, and development practices, offering engineers a comprehensive roadmap to build and expand their technical knowledge across multiple domains.
This article introduces the basic features of three popular Java IDEs—NetBeans, Eclipse, and IntelliJ IDEA—examines their strengths and limitations, and provides a concise comparison to help developers choose the most suitable development environment for their projects.
After the golden era of rapid growth, Chinese software engineers reaching age 35 face a career crossroads marked by age bias, shrinking opportunities, and a shift toward stability, prompting many to reconsider management roles, alternative careers, or further education to secure their future.
The article explores how Tarn Adams has single‑handedly maintained and expanded the indie game Dwarf Fortress for two decades, growing its C/C++ codebase to over 700,000 lines, funding development through donations, and continuously adding new gameplay modes and AI features without major refactoring.
This tutorial explains how bare Git repositories differ from non‑bare ones, shows how to create and configure a bare repo, and demonstrates an advanced Git worktree workflow that keeps all branch worktrees organized within a single project directory for seamless multi‑branch development.
This article analyses the current front‑end development landscape, the talent shortage, reasons behind it, and proposes a systematic learning roadmap—including understanding the technology stack, assessing personal stage, and continuous skill growth—to help both newcomers and experienced developers advance their careers.
The article shares ten practical principles—owner mindset, time awareness, start with the end, closed‑loop thinking, respect for standards, avoiding repeated mistakes, design first, balancing output and capacity, asking good questions, and maintaining an empty‑cup mindset—to help engineers improve personal growth, team efficiency, and overall work quality.
This article surveys the most popular software development laws and principles—such as the Pareto, Broken Window, Occam's Razor, Dunning‑Kruger, Peter, Parkinson, Hofstadter, Conway, Murphy, Brook, Postel, Kerckhoffs, Linus, Wirth, and Knuth principles—explaining each rule and offering practical ways to apply or avoid them in real‑world development work.
The article examines why programmers over 40 face age bias in the tech job market, explains that compensation reflects replaceability rather than value, and proposes three actionable mindsets—choosing an expert or management track, building an ABZ plan, and becoming a team’s indispensable resource—to revive career prospects.
This article provides a comprehensive, practical guide to applying Domain‑Driven Design (DDD) in enterprise Java projects, covering architectural principles, project management steps, design patterns, code generation, testing, deployment, and a detailed loan‑processing example that demonstrates how to model, implement, and evolve a rich domain model using Spring, DI, AOP, and related technologies.
This article recounts a disastrous 12‑year software project with over 6 million lines of C++ code, outdated CORBA middleware, chaotic version control, and absurd management practices, illustrating how technical debt and bureaucratic mismanagement can doom even the most ambitious engineering efforts.
This article explains what technical debt is, why it matters, and provides practical guidance on avoiding blame, discussing risks, prioritizing work with techniques like delay cost and ICE/RICE, and implementing concrete strategies to allocate effort and reduce debt in software projects.
This article shares practical strategies for reading technical books—classifying them into language, algorithm, and specialized topics—and proposes a three‑pass reading method that emphasizes hands‑on coding, deep understanding, and repeated review to maximize knowledge retention.
This article explains why developers and leaders must practice thorough code reviews, outlines common pitfalls such as duplicated code and premature optimization, and shares concrete Go examples and timeless engineering principles—like KISS, composition over inheritance, and transparent design—to help teams build maintainable, high‑quality software.
This article compiles the most frequently used programmer abbreviations, explaining their meanings and contexts, and presents them visually so both newcomers and seasoned developers can quickly decode the shorthand that permeates modern software development discussions.
This article shares ten practical principles—ranging from ownership and time management to continuous learning and balanced output—that help engineers avoid common pitfalls, improve team efficiency, and foster personal and professional growth.
This article introduces six recommended API documentation platforms—EOLINKER, RAP, EasyAPI, apizza, ShowDoc, and 胖胖羊—highlighting their key features, URLs, and visual screenshots to help developers choose the best tool for collaborative and efficient API design.
This article explains the concept of layered architecture, covering decomposition and integration, cloud three‑layer models, SOA layering, database and service layers, application and domain layers, and provides guidance on constructing clear, multi‑view architecture diagrams for complex systems.
The author shares a decade‑long progression from junior developer to technical director, offering practical advice on mentorship, continuous learning, agile practices, and leadership that can help developers at any stage navigate their own career growth.
This article lists twenty common bad habits of programmers—from inconsistent terminology and poor documentation to neglecting testing and teamwork—explaining why each harms productivity and offering concrete advice on how to develop professional coding practices.
The article outlines twenty common bad habits of programmers—from inconsistent terminology and poor documentation to neglecting official resources and teamwork—explaining why each is detrimental and offering practical advice for cultivating professional competence and collaborative success.
This tongue‑in‑cheek guide enumerates a series of deliberately bad programming techniques—ranging from confusing naming conventions and deceptive comments to absurd design choices and hidden macros—aimed at making code virtually impossible to understand, maintain, or test.
The article explains how Google transformed its long‑standing Test Certified program into a broader Project Health system that uses automatically collected engineering metrics to improve consistency, efficiency, and overall productivity across development, testing, release, and deployment processes.
Reflecting on China’s Programmer’s Day, the author argues that moving from mere developers to true software engineers—by mastering engineering principles, design, project management, and open‑source culture—is essential for upgrading the nation’s 4 million‑strong software workforce and overcoming low‑quality, involutionary development.
Zhengzhou Bank’s new retail loan system passed the third‑level DevOps continuous‑delivery assessment, leading to a 2.31‑fold increase in annual delivery demand, an 18‑day reduction in cycle time, and a shift to automated, seconds‑level environment delivery, illustrating the transformative power of standardized DevOps practices.
This article presents a practical seven‑step methodology for efficiently reading Redis's source code—starting with project mapping, preparing prerequisite knowledge, tackling basic modules, following the core execution flow, using a whole‑before‑detail approach, exploring side features, and finally filling knowledge gaps—applicable to other large codebases as well.
The article examines ByteDance’s terminal technology team, outlining current front‑end trends, the challenges of complex processes, component chaos, and massive architecture, and presents their veMARS solutions for DevOps, component management, and application frameworks to improve platform development efficiency.
This article explains what a full‑stack engineer is, outlines the various classifications such as technical, product‑oriented, and product‑operations roles, reviews the industry’s evolution and demand, and provides practical guidance on positioning, learning plans, and career development for aspiring full‑stack professionals.
The author, a seasoned Java backend developer, shares personal experiences and insights on evaluating efficiency, ecosystem, and team dynamics when selecting technologies—from legacy frameworks and databases to modern big‑data tools like Spark and Flink—offering practical guidance for developers and teams navigating today’s rapidly evolving tech landscape.
This article explains the Strategy Design Pattern, a behavioral design pattern that enables defining a family of algorithms, encapsulating each one, and making them interchangeable to improve code maintainability and flexibility in software development.
This article examines why failure is inevitable in software systems, proposes a mindset of failure‑oriented design, outlines organizational roles and processes to mitigate incidents, and presents concrete technical techniques such as distributed locking and traffic shaping to build resilient, high‑availability services.
The article examines the three‑year evolution of Alibaba's DEF front‑end engineering platform, highlighting its shift toward a monolithic architecture, the resulting complexity and cost issues, and the multi‑layered solution—including infrastructure upgrades, SAAS/PAAS/IAAS separation, and micro‑frontend strategies—to improve efficiency, quality, and developer experience.
Baidu’s massive information‑flow recommendation platform employs an intelligent delivery pipeline—spanning micro‑service R&D, automated white‑box testing, performance monitoring, and optimized deployment—that supports nearly a hundred daily releases, cuts QA effort, delivers over half of requests within a day, and enables near‑zero‑touch, high‑frequency rollouts.
This article explores the evolution of software development from machine code to high‑level languages, explains the two software crises, and clarifies key concepts such as systems, subsystems, modules, components, frameworks, and ultimately defines software architecture as the top‑level structure for managing complexity.
This article introduces ten fundamental software architecture patterns—including layered, client‑server, master‑slave, pipe‑filter, proxy, P2P, event‑bus, MVC, blackboard, and interpreter—explaining their structures, typical use cases, advantages, and drawbacks to help developers choose the right design for large‑scale systems.
This article explores the evolution of software development from machine code to high‑level languages, explains the two software crises, and defines key architectural concepts such as systems, subsystems, modules, components, frameworks, and the role of software architecture in managing complexity.
This article explains how deliberate practice, a structured and goal‑oriented training method, can transform ordinary programmers into experts by identifying specific skills, breaking them into sub‑tasks, setting realistic goals, using immediate feedback, and maintaining motivation through effective planning and incentives.
The article explains why years of experience alone rarely produce expertise, introduces the concept of deliberate practice as the proven method to become a top programmer, and provides concrete steps, motivation techniques, and planning tips to accelerate skill mastery in the fast‑changing software industry.
This tongue‑in‑cheek article lists a series of deliberately bad programming practices—from confusing variable names and deceptive comments to over‑engineered designs and zero testing—to show how to make code virtually impossible to maintain.
The article analyzes common obstacles that prevent effective use of design patterns and code standards in everyday software development—such as performance overhead, class explosion, team skill gaps, project constraints, agile timelines, and staff turnover—and offers practical strategies to balance quality with productivity.
The article explains how Google’s continuous delivery practices—such as modular architecture, feature flags, gray‑scale deployments, rapid feedback loops, and a culture of always‑ready‑to‑deploy—enable faster, safer software releases while reducing risk and cost.
The article explains how Google treats development speed as a team sport, using modular architecture, continuous integration, feature flags, gray deployments, production‑like testing, and data‑driven decisions to enable frequent, small releases that improve quality, reduce risk, and lower costs.
This article examines common pitfalls in code reviews, outlines clear goals and principles, and provides actionable strategies for designing, reading, and sharing code to boost quality, speed, and team learning while avoiding time‑wasting habits.
The JD Frontend Technology Salon held on September 18, 2021 gathered internal and external experts to discuss cross‑platform development, open‑source initiatives, and HarmonyOS, presenting a series of technical talks, round‑table discussions, and Q&A sessions that highlighted current practices, challenges, and future directions in front‑end engineering.
Keeping change lists (CLs) small improves review speed, thoroughness, reduces bugs, eases merging and rollback, and helps maintain continuous workflow, with practical guidelines on size limits, splitting techniques, and testing requirements for effective code review.
The article presents a unified error‑handling strategy for Go backend services that combines idiomatic internal checks, Go 1.13’s %w wrapping with errors.Is/As, and a compact 4‑character base‑36 hash code system to deliver consistent machine‑readable codes and user‑friendly messages while preserving full log details.
This article presents a set of coding "military rules" covering topics such as avoiding magic numbers, limiting method parameters, proper resource release, specific exception handling, and precise arithmetic, followed by practical development efficiency tips and resource links for further learning.
This tongue‑in‑cheek guide enumerates a series of anti‑patterns—from confusing naming and deceptive comments to absurd design choices and neglect of testing—intended to illustrate how developers can deliberately produce code that is extremely hard to maintain.
This article surveys the fifteen most celebrated programmers, highlighting their groundbreaking contributions—from Apollo flight‑control software and the TeX typesetting system to Linux, Hadoop, and modern game engines—while sharing community opinions that illustrate why they are revered in the tech world.
This tongue‑in‑cheek article enumerates a series of deliberately harmful programming practices—from confusing naming conventions and deceptive comments to excessive abstraction, misuse of inheritance, and avoidance of testing—intended to make code virtually impossible to understand, maintain, or debug.
This article explains how software architects can conduct effective software design by building abstract models and textual specifications, using UML diagrams such as class, sequence, component, deployment, use‑case, state, and activity diagrams to communicate functional and non‑functional requirements throughout requirement analysis, conceptual design, and detailed design phases.
This comprehensive guide explains why code reviews are essential, outlines their benefits and challenges, describes review formats, participants, focus areas, step‑by‑step processes, key operations, principles, and common pitfalls, providing practical advice and examples to help teams improve code quality and collaboration.
This article explains how software architects can use UML modeling and design documentation to capture both functional and non‑functional requirements, communicate with stakeholders, and guide developers through requirement analysis, high‑level design, and detailed design phases.
The article recounts LinkedIn’s rapid 2011 growth, the mounting technical debt that forced a two‑month feature freeze, and how the InVersion project rebuilt the development platform, offering lessons on disciplined debt repayment and engineering process improvement.
This article explores the fundamental difficulties of quantifying software development efficiency, outlines common measurement pitfalls and anti‑patterns, and offers practical guidance for building a systematic, data‑driven R&D performance framework that truly drives improvement.
This article surveys notorious software bugs—from payroll overpayments and Excel data corruption to rocket launch failures and medical device overdoses—showing how a single coding error can trigger massive financial loss, safety hazards, and even geopolitical crises.
This article shares a 985 graduate's personal background, systematic interview preparation for C++ and Go backend positions, detailed interview question collections from major tech companies, and practical advice on study resources, project presentation, and coding practice to help candidates succeed in technical interviews.
This article explains why high‑quality code review is vital for software teams, outlines the responsibilities of submitters and reviewers, emphasizes clear commit messages and test plans, and offers practical guidance for giving constructive and appreciative feedback to improve code quality and team collaboration.
The article explains the problems caused by overly long classes—poor readability, difficult extension, redundant code, and violated design principles—and provides a step‑by‑step guide using IntelliJ IDEA to extract redundant code, rename methods, move members, and split responsibilities into new classes for cleaner, maintainable software.
The article examines why design patterns and code standards matter, analyzes common pain points such as performance overhead, class explosion, team skill gaps, and rapid iteration, and offers practical recommendations for balancing maintainability and productivity in everyday software projects.
The article explains the drawbacks of overly long classes—poor readability, difficult extension, redundant code, and violation of the Single Responsibility Principle—and provides step‑by‑step refactoring techniques using IntelliJ IDEA such as extracting methods, moving members, and creating new classes.
This article outlines a four‑stage career roadmap for technology professionals, guiding them from the first years after graduation through independent contribution, team leadership, and finally strategic innovation, with practical advice on learning, problem‑solving, mentorship, and industry foresight.
In a detailed interview, Henan Zhongyuan Consumer Finance explains how its new generation consumer loan system achieved the industry‑first Level‑3 DevOps continuous delivery assessment, highlighting the standards, tools, performance metrics, challenges overcome, and future plans that together illustrate the transformative power of standardized DevOps practices.
China Everbright Bank’s interview reveals how adopting DevOps standards and a continuous delivery pipeline boosted development speed, quality, and efficiency, with measurable improvements such as 90% build success, 60 daily integrations, and faster release cycles, illustrating the strategic value of standardized, tool‑enabled software delivery.
This article details China Tower's adoption of DevOps standards and a continuous delivery pipeline, covering the assessment process, project specifics, challenges overcome, measurable benefits, future plans, and broader insights into the DevOps capability maturity model within the telecom industry.
CITIC Securities’ CIO Xiao Gang discusses how their outsourced service platform achieved Level‑3 DevOps continuous delivery assessment, detailing the motivations, implementation challenges, measurable improvements, and future plans, while highlighting the broader significance of the national DevOps maturity model for the financial sector.
This article explains what product thinking is, why technical professionals need it to bridge gaps with product teams, illustrates common misunderstandings with real warehouse‑management examples, and offers concrete mind‑set shifts and practical steps for engineers to develop stronger product sense.
This article outlines four practical steps—taking responsibility, creating value, working efficiently, and becoming replaceable—to help engineers shift from pure coding to delivering measurable business impact and expanding their influence within teams.
This tongue‑in‑cheek article enumerates a series of deliberately bad programming practices—from confusing naming conventions and deceptive comments to abusive design choices and anti‑testing habits—showing how to make code virtually impossible for colleagues to understand or maintain.
Seven university interns spent a summer at Alibaba's Taobao Front‑End Interactive team, gaining hands‑on experience with Eva.js, WebGL, React, engineering processes, and team collaboration while reflecting on personal growth, technical challenges, and the supportive workplace culture.
The talk introduces Volcano Engine's veMARS plugin framework, its low‑cost, high‑stability engineering transformation capabilities, and demonstrates how the Jinri Toutiao Lite app leveraged this framework to achieve significant package size reduction and robust plugin‑based development.
The article examines how Google and Microsoft have evolved their automated testing strategies, defining test sizes (small, medium, large) and Microsoft’s L0‑L3 test level taxonomy, and explains the benefits and cultural shifts that led to widespread adoption of unit‑focused testing in modern DevOps practices.
This article explores the essential naming conventions used in Java projects, presenting ten common class‑name patterns—such as Manager, Factory, Context, and Builder—illustrated with real open‑source examples and code snippets to help developers write clearer, more maintainable code.
The paper presents DeepDebug, a transformer‑based system that leverages large pretrained models and extensive synthetic and real‑world data to automatically localize and fix bugs in Python code, achieving significant improvements in patch generation success rates and reduction of false positives on benchmarks such as QuixBugs.
This article explains the design, implementation, and data‑driven evaluation of a staged code‑review workflow for large frontend changes, highlights limitations of the current system, and proposes an improved process that lets developers drive stage creation, reducing reviewer overload and enhancing code quality.
In this interview, Huawei Cloud MVP Yu Cheng shares his journey from a high‑school hacker fascination to a decade of full‑stack development across top tech firms, his transition to teaching, his philosophy of sparking curiosity, and practical advice for aspiring programmers seeking a full‑stack career.
After dedicating 10,000 hours to coding across diverse languages and platforms, Google Kubernetes engineer Matt Rickard shares 31 hard‑won reflections on reading source, tool mastery, code simplicity, abstraction, and the mindset that separates ten‑fold programmers from the rest.
This article provides a comprehensive overview of information system fundamentals, covering national information‑technology elements, emerging concepts such as cloud computing and IoT, e‑government models, ERP and CRM basics, service‑management challenges, qualification systems, software development lifecycles, testing methods, architecture patterns, and data‑warehouse concepts.
This article explains why high‑quality technical documentation is essential for teams and organizations, outlines common reasons engineers avoid writing docs, and provides practical methods—such as treating docs like code, defining the audience, clear classification, and systematic review—to create and maintain effective documentation.
This article explains why front‑end design documents are essential for reducing risk, improving quality and efficiency, outlines the key elements of a complete document, and provides a practical template and real‑world example to help teams create effective specifications before coding.
This article examines the evolution of code review, defines key quality metrics such as LOC, inspection time, defect count, and derived rates, analyzes data from CodeCollaborator and Alibaba’s DEF platform, and offers actionable insights to enhance front‑end code review effectiveness.
This guide explains how to adopt a multi‑project modular architecture for Android apps—distinguishing components from modules, outlining vertical and horizontal design layers, showing ARouter‑based navigation and communication, and detailing a top‑down, bottom‑up migration process used to refactor the vivo official app.
The article presents a practical approach to designing complex microservice systems by combining layered architecture with Domain‑Driven Design, outlining a five‑layer model, detailing each layer’s responsibilities, offering domain‑splitting guidelines, and illustrating implementation with code examples and development steps.
The article explores the ancient concepts of “Dao, Fa, Shu, Qi” and maps them to modern software development, showing how tools, techniques, architectural strategies, and market trends together shape a developer’s growth and career decisions.
This article examines the concept of R&D efficiency, why many enterprises struggle to improve it, the common pitfalls such as siloed tools and metric obsession, and offers practical practices—from unified platforms to DevSecOps—to help slow its degradation and sustain productivity.
