Software estimation is essential for making informed decisions on resource allocation, cost, and scheduling; this article explains why estimation matters, outlines effective estimation processes, highlights key factors such as granularity, shared assumptions, and collaboration, and provides practical questions to guide accurate and useful estimates.
This article explains why well‑designed software architecture diagrams are essential, enumerates typical mistakes such as ambiguous symbols, inconsistent legends, and over‑detail, and provides practical guidelines on choosing the right number of diagrams, maintaining consistency, using legends, and keeping diagrams up‑to‑date in modern micro‑service environments.
This guide explains why interview outcomes aren't solely determined by answering every question, and offers three practical strategies—staying calm and gathering information, speaking up thoughtfully, and skillfully navigating unknown topics—to turn difficult moments into opportunities to demonstrate your value.
When you join a new software development team, asking the right 20 questions about technical setup, collaboration practices, external constraints, and product strategy helps you integrate quickly, avoid pitfalls, and contribute effectively from day one.
This article introduces a practical three‑question thinking framework and five guiding principles that help developers and product teams clarify goals, assess current status, and design effective implementation paths, ultimately improving productivity and reducing wasted effort.
This article explains the evolution from monolithic applications to microservices, detailing their principles, benefits, drawbacks, design considerations, and the three-step implementation process, while highlighting the impact on agile development, DevOps culture, technology stacks, and organizational structure.
This article explains how software architects can use UML modeling—covering class, sequence, component, deployment, use‑case, state, and activity diagrams—to analyze domain problems, design abstract models, and produce clear documentation that guides development from requirements through detailed design.
This article provides a comprehensive overview of software architecture, explaining its definition, core components, classification into logical, physical, and system architectures, and describing various architectural views such as the 4+1 view model.
The article outlines ten typical detrimental habits that developers develop—such as insufficient rest, refusing help, stopping learning, messy code, work‑life imbalance, office politics, ignoring mistakes, giving up too early, pretending to know everything, and rejecting constructive criticism—and offers practical strategies to recognize and replace each habit with healthier practices.
This comprehensive guide explains the importance of code reviews, outlines their benefits, addresses common challenges, and provides practical steps, formats, participants, focus areas, processes, principles, and code examples to help teams implement effective review practices.
This article explains how software architects can conduct effective software design through modeling, documentation, and UML diagrams to satisfy functional, non‑functional, and cost requirements while ensuring clear communication among developers, testers, and operations teams.
The article maps the software development ecosystem into a pyramid, explains why most engineers sit at the bottom, how team, company, national and global influencers shape technology trends, and offers practical steps—such as building a technical blog, speaking at conferences, and helping peers—to climb the hierarchy and become a true industry leader.
Code refactoring—cleaning and restructuring existing code without changing its behavior—offers numerous benefits such as reduced complexity, improved readability, faster performance, lower technical debt, and better maintainability, and this guide explains its definition, advantages, metrics, techniques, tools, and management considerations.
This article outlines a three‑track roadmap for tackling software defects—starting with bug prediction using machine‑learning models, progressing through defect understanding and localization via static and dynamic analysis, and culminating in automated repair and program synthesis techniques, while highlighting key research directions and representative literature.
The article shares practical lessons from refactoring a ride‑hailing order system, explaining Martin Fowler’s definition of refactoring, distinguishing small (renaming, deduplication) and large (architectural redesign) efforts, outlining typical code smells, and detailing a structured pre‑, during‑, and post‑refactoring process to improve maintainability, reduce bugs, and accelerate development.
The article explains how feature teams—cross‑functional, long‑lived groups that own end‑to‑end customer features—can improve user experience, technical excellence, and operational efficiency, while outlining the cultural and organizational changes required for successful adoption.
The article discusses common pitfalls in application layering, presents Alibaba's clear multi‑layer architecture—including Open Interface, Terminal Display, Web, Service, Manager, and DAO layers—offers an optimized layering model with Thrift, explains domain model conversions, and provides practical recommendations for maintainable backend design.
This comprehensive article explains low-code development, its historical roots, core capabilities such as aPaaS, MADP and BPM, market growth forecasts from Forrester and Gartner, vendor evaluation criteria, strategic adoption guidelines, and practical development steps for digital transformation initiatives.
The article explains software architecture by distinguishing the business and computer problems it must solve, outlines the responsibilities of owners and engineers, and describes how increasing scale leads to layered deployment, code, and organizational structures.
This article explores the origins of software as a human‑simulation tool, examines how cost reductions and technological advances have driven its widespread adoption, and explains how increasing complexity led to the emergence of specialized roles and architectural practices in modern software development.
In this talk, former Amazon and Alibaba chief architect Chen Hao shares practical ideas on why high‑efficiency teams matter, how to create them through people selection, processes, leadership, and automation, and offers concrete management tactics such as clear goals, small‑team structures, and data‑driven decision making.
This article presents a practical methodology for handling complex business scenarios by combining top‑down process decomposition with bottom‑up object modeling, emphasizing simple pipelines over heavyweight tools, and demonstrates how to achieve clean, maintainable backend code through real‑world examples and diagrams.
By consolidating all Yanhuobao category settings into a single Mach‑managed configuration defined by a JSON schema and introducing a generic Guava LoadingCache with a ConfigValueParser, the service now adds new categories with just three fields, reduces parsing overhead, lowers maintenance costs, and improves consistency and QPS performance.
This article reviews ten popular low-code development platforms, detailing their key features, advantages, and deployment options, helping developers and businesses choose the right tool for rapid application creation across web, mobile, and cloud environments.
This article explains the concept of a mid‑platform (中台), its three core functions, its relationship with front‑ and back‑end systems, practical implementation challenges, and the strategic advantages it brings to modern enterprises seeking agile digital transformation.
This article offers practical engineering guidance on when and how to refactor client‑side code, emphasizing planning, incremental changes, systematic approaches, tooling, and team coordination to improve code quality while minimizing risk and maintaining system stability.
This article describes how the PC teacher desktop client adopts a layered MVL architecture, introduces unit testing with GoogleTest and GoogleMock, explains the underlying TEST and RUN_ALL_TESTS macro mechanisms, demonstrates mock view implementation, and shows how code coverage is measured to achieve targeted test coverage levels.
This article provides a comprehensive overview of UML, explaining its purpose, core elements, diagram classifications, static and dynamic models, and the typical modeling process, enabling readers to understand, create, and interpret UML diagrams across software development stages.
This article explains why code review is critical, outlines its benefits and common difficulties, describes the TDSQL‑C distributed database architecture, and presents a detailed code‑review workflow, author and reviewer responsibilities, commit conventions, and cultural practices to improve software quality and reliability.
This article presents Autohome's Cloud Platform (Home Cloud) technical debt governance framework, defining ideal technical states, outlining five systematic steps—from factor collection to project execution—and sharing practical outcomes that have enhanced the competitiveness of its applications and development teams.
The article shares a senior Amazon scientist’s five‑year career reflections, introducing a value‑formula that measures societal impact, advising engineers to align technology with product value, focus on long‑term high‑impact tasks, and cultivate leadership and management skills for sustainable growth.
This guide shares practical techniques for producing high‑quality technical articles, emphasizing the importance of solid content, clear structure, engaging narratives, and effective formatting to help engineers consistently create valuable and readable posts.
The author reflects on how studying the legacy Java Swing library and related university courses, despite being outdated, reinforced core programming thinking, design‑pattern knowledge, and problem‑solving skills that remain valuable throughout a software engineering career.
Discover the inspiring journey of John Washam, a self‑taught programmer who amassed over 171 k GitHub stars by compiling a comprehensive, open‑source learning roadmap covering fundamentals, algorithms, system design, security, and more, and learn his practical tips for effective self‑study and knowledge retention.
This article explains the fundamentals of version control, why it is essential for DevOps teams, and how it improves productivity, error detection, parallel development, and overall product reliability through better collaboration and traceability.
This article presents a comprehensive guide to designing external domain‑specific languages, covering presentation modes, terminology extraction, relationship and syntax design, data‑structure definition, parser implementation with generator tools, testing strategies, and evolution techniques, illustrated with real‑world examples and code snippets.
This article outlines six practical guidelines for writing clean, maintainable Python functions—including meaningful naming, single responsibility, comprehensive docstrings, returning useful values, limiting length, and ensuring idempotence or purity—illustrated with code examples and explanations to help developers improve function quality.
This article explains the importance of code review, outlines Google’s comprehensive code‑review rules, and provides practical steps—including process controls and automation—to help teams adopt effective review practices and improve software quality.
This article explains essential clean‑code techniques for naming variables in JavaScript/TypeScript, covering self‑descriptive, pronounceable identifiers, avoiding type prefixes, using consistent terminology, eliminating unnecessary context, and replacing magic numbers and strings with meaningful constants.
The article shares practical advice on overcoming career anxiety and becoming a top engineer by adopting deliberate practice, identifying patterns, integrating learning with daily work, continuously reviewing code, mastering troubleshooting, and deeply understanding both technology and business contexts.
This article reviews the paper “Build Systems à la Carte”, explains its abstract build‑system model, shows how incremental computation concepts apply to tools such as Excel, React, Recoil, module loaders and dependency injection, and demonstrates a TypeScript translation of the core ideas for front‑end developers.
This article explains how the O2 CodeReview tool, built on a pure‑frontend IDE, determines the appropriate merge‑base using Git data, handles multiple branch scenarios, and implements a version‑skip algorithm to reduce review workload while ensuring correct diff information.
The article shares a senior DiDi engineer's perspective on how engineers can overcome growth anxiety, adopt deliberate practice, build deep domain knowledge through work‑centered learning, and persistently refine coding and troubleshooting skills to become true technical leaders.
This article compiles detailed interview experiences, question lists, and practical advice for candidates targeting backend, big‑data, and cloud positions at leading Chinese tech firms, offering timelines, personal background, preparation tips, and reflections to help job seekers navigate multi‑round technical interviews efficiently.
This article explains the evolution of software development from machine language to high‑level languages, describes the two software crises and the emergence of structured, object‑oriented, and component‑based design, and clarifies key architectural concepts such as systems, subsystems, modules, components, frameworks, and architecture itself.
This article explains why Python’s Django framework is a top choice for backend development, outlining its popularity, benefits, essential system‑planning and web‑script skills, rapid prototyping, scientific computing, and the specific Python and Django expertise needed to become a proficient developer.
The article reports on Inner Mongolia Mobile's successful achievement of Level 3 in the national DevOps continuous delivery assessment, detailing the GOPS conference announcement, the ESOP project's architecture and improvements, interview insights from the IT manager, and the measurable benefits that positioned the company at a domestic leading level.
Anxin Securities’ CIO discusses how the company’s Internet Customer Service Platform passed the DevOps Standard Continuous Delivery Level 3 assessment, detailing the motivations, implementation challenges, measurable improvements, and future plans for scaling DevOps across its technology stacks.
Guoxin Securities’ Chief Engineer Liu Hanxi and IT Head Xue Zhongyi discuss how their Gold Sun information platform leveraged a self‑developed microservice framework and the national DevOps standard to achieve a Level‑3 continuous delivery assessment, dramatically improving delivery speed, test coverage, automation and overall digital transformation.
This article explains the evolution of software architecture toward microservices, defines microservice architecture, outlines its key characteristics, advantages and disadvantages, and then details ten essential design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—while advising when each should be applied.
This guide shares a former second‑tier university graduate's practical roadmap—covering mindset, goal setting, skill acquisition in C++, data structures, algorithms, OS, networking, databases, internships, project work, interview tactics, and Tencent's recruitment process—to help aspiring engineers land offers at top tech firms.
The article examines why many Java server‑side developers resist switching to Kotlin, exploring misconceptions about learning time, language maturity, pride, tooling, hiring costs, complexity, codebase mixing, and perceived lack of benefits, while offering practical insights to encourage adoption.
The article explains widely used code quality evaluation standards—including coding conventions, readability, maintainability, duplication, and testability—and describes how the @iceworks/doctor tool scores projects across five dimensions to compute an overall quality score.
The article outlines seven common behaviors of inexperienced developers—such as large one‑off commits, messy code, multitasking, arrogance, ignoring feedback, handling personal matters during work hours, and chasing every new tech trend—and offers practical steps to become a more professional and effective software engineer.
The article lists twenty‑one harmful programming habits—such as reinventing wheels, overusing design patterns, skipping testing, ignoring monitoring, and avoiding proper architecture—that can cripple a development team and serve as a warning for engineers seeking better practices.
The author recounts a full Google China interview experience—including resume submission, recruiter prescreen, phone and onsite coding rounds, HR and English interviews, lunch with engineers, and final feedback—while sharing practical advice and insights to help future candidates prepare effectively.
The article analyses the rise and fall of UML, tracing its origins in the 1990s, the impact of CASE tools, the shift toward agile development, and the technical and cultural reasons for its decline, while also exploring emerging lightweight modeling alternatives such as C4 and masala diagrams.
The article presents a three‑stage "Gong" theory for tech career growth, explaining how early effort drives advancement, while later stages rely more on opportunity, and outlines practical actions for each phase from junior developer to senior leadership.
Design patterns are proven, reusable solutions to common software design problems, and this comprehensive guide explains their definitions, classifications, key concepts, real‑world examples, code snippets, and best‑practice principles, helping developers choose the right pattern for any scenario.
This article explains why continuous refactoring is essential for evolving projects, defines refactoring and its scales, lists common code smells and their impact, and presents practical techniques—including SOLID principles, design patterns, naming conventions, layering, and test‑driven development—to turn messy code into high‑quality, maintainable software.
This article explains how software build processes have progressed from simple manual compilation to sophisticated, automated, cloud‑native platforms, covering the distinction between build and compile, the rise of tools like Ant, Maven and Gradle, containerization, Kubernetes‑based orchestration, and the challenges and future directions of large‑scale build infrastructures.
The article outlines four crucial mindsets for early‑stage software engineers—continuous learning, focusing on the critical path, treating the company’s business as personal, and prioritizing ideas—to help them make tough decisions, validate assumptions, and drive successful product development.
This article explains how concise yet valuable project documentation—README, architecture, and API docs—helps developers onboard quickly, understand system design, and maintain long‑term project health, while offering practical content guidelines and real‑world examples.
China’s low‑code market, valued at CNY 1.9 billion in 2020 and projected to hit a hundred‑billion by 2024, is booming as enterprises like iQIYI adopt visual development platforms that abstract reusable components, accelerate activity page creation, and address integration, modularity, and business‑driven platform design challenges.
The article outlines seven practical suggestions—strengthening requirement review, proactively improving efficiency, deepening core technical fundamentals, focusing on performance, monitoring production, maintaining a global view, and regularly summarizing work—to help ordinary programmers advance toward senior or expert roles.
This article presents a detailed R&D performance measurement framework that outlines five design principles, three categories of metrics, and concrete calculations for indicators such as demand lead time, defect ratios, availability, throughput, and flow efficiency, helping organizations balance speed, quality, and sustainability.
This article explains why well‑structured error logs are essential for troubleshooting, analyzes common sources of errors, and provides concrete guidelines and code examples to make logs complete, specific, and actionable for developers and operations teams.
This article traces the evolution from machine code to high‑level languages, explains the two software crises, defines system, subsystem, module, component and framework, and clarifies the true purpose and goals of software architecture for modern developers.
The article explains why engineers and leaders must perform code reviews, outlines common pitfalls such as duplicated code, premature optimization, and poor design, and presents concrete principles—KISS, composition, transparency, and error handling—backed by Go examples and Unix philosophy to help teams produce maintainable, high‑quality software.
The article humorously explains 23 classic software design patterns—ranging from creational to behavioral—using everyday dating scenarios to illustrate each pattern's intent, structure, and typical usage, making the concepts easy to grasp for developers.
This article explains microservice architecture, its key characteristics, advantages and disadvantages, and presents ten essential design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—while offering guidance on when to apply each pattern.
This article outlines what middleware development is, the essential technical and personal qualities required, and provides a step‑by‑step learning roadmap for aspiring Java developers aiming to join or build middleware teams in modern backend environments.
Low‑code and no‑code development are evolving from simple UI assembly tools into AI‑driven human‑machine collaborative programming, reshaping software engineering by reducing development and usage costs, integrating with DevOps and cloud native architectures, and promising a future where anyone can create software through intelligent, context‑aware automation.
This article explains Uber's Domain‑Oriented Microservice Architecture (DOMA), describing why microservices were adopted, the challenges of scaling them, the concepts of domains, layers, gateways and extensions, and provides practical advice for organizations looking to reduce complexity while retaining flexibility.
By applying the DRY principle, the team abstracted audit requirements into a micro‑core plugin architecture, built a two‑week MVP for Xianyu’s community moderation, and demonstrated how systematic research, reusable patterns, and incremental evolution prevent duplicated effort and create a scalable, maintainable audit system.
This article describes Baidu's quality metric model that integrates development process data, self‑testing and automation data to automate test prioritization, estimate project risk, and improve testing efficiency through a six‑component platform covering process control, feature mining, data collection, storage, strategy management, and annotation.
This article chronicles Alibaba’s three‑year evolution of frontend intelligence, detailing the origins of AI‑driven code generation, key technologies like imgCook, BizCook and UICook, the methodology, toolchain, organizational integration, and future directions for boosting development efficiency and business value.
This article explores the evolution of software development—from machine language and assembly to high‑level languages—examines the two software crises that spurred structured and object‑oriented programming, and explains how software architecture emerged to manage system scale, coupling, and complexity.
This article shares practical techniques for crafting high‑quality technical articles, emphasizing solid content, clear structure, engaging narratives, and effective writing habits to help engineers produce useful and readable documentation.
The article explains why excessively long classes hinder readability and extensibility, outlines the problems caused by redundant code and violated design principles, and provides a step‑by‑step guide using IntelliJ IDEA to extract methods, move members, and create new classes for cleaner, maintainable code.
This article shares practical advice from experienced engineers on how to broaden business knowledge, understand end‑to‑end systems, pursue self‑study, practice through hands‑on exercises, adopt systematic learning, and reinforce mastery by teaching, helping anyone from students to seasoned developers accelerate their technical growth.
This article explores the evolution of software development from machine code to high‑level languages, explains the two software crises, and defines software architecture by clarifying related concepts such as systems, subsystems, modules, components, and frameworks, ultimately highlighting architecture as a solution to system complexity.
This article explores the evolution of software development from machine language to high‑level languages, explains the two software crises, and defines software architecture by distinguishing systems, subsystems, modules, components, and frameworks, emphasizing architecture as a top‑level structural solution for managing complexity.
The article explains that CTOs, technical directors, and architects are valued for their strategic technical judgment rather than coding ability, outlines how technical roles evolve from senior developers to CTOs, and highlights the importance of proper title assignment and career development in growing tech teams.
This article explores what a web architect does, the core value they bring to software projects, and the extensive technical and soft‑skill competencies required, offering a practical roadmap for developers aspiring to transition from coding to strategic system design.
This article showcases remarkable historical source code—from the Apollo 11 guidance computer and Quake III Arena's graphics tricks to the massive GNU compiler, Chromium's modular architecture, and the compact Gitk GUI—highlighting how developers achieved extraordinary efficiency and innovation with limited resources.
This article explains the evolution of software development from machine code to high‑level languages, describes the two software crises that led to structured programming and OOP, and defines software architecture as the top‑level structure that manages system complexity through clear components, modules, and rules.
This article explores the concepts, background, and future of low-code/no-code development, comparing differing industry definitions, linking it to classic software‑engineering ideas, DevOps and cloud native practices, and outlining AI‑driven human‑machine collaborative programming as the core technology shaping the next wave of software creation.
An interview with China Mobile Suzhou's chief scientist reveals how their "China Mobile Sentiment" project achieved a Level‑3 DevOps continuous delivery assessment, boosting delivery speed, release success, and operational confidence while outlining future scaling plans.
Jiangsu Mobile’s Alading marketing empowerment project recently passed the third‑level DevOps continuous‑delivery assessment, showcasing significant improvements in delivery speed, automation, and quality, while the interview reveals the team’s strategies, tooling, metrics, challenges, and future plans for scaling DevOps across the organization.
The article emphasizes that clear, well‑structured comments are vital for code readability, team collaboration, maintenance, and knowledge transfer, illustrating common pitfalls through developer anecdotes and offering practical guidelines such as writing concise explanations, categorizing notes, timing comments, and preserving code history to avoid future confusion.
This article shares a senior engineer's practical philosophy on code review, covering why reviews matter, common pitfalls like duplicated code and premature optimization, and twelve concrete principles—such as simplicity, composition, transparency, and early returns—to help developers write clearer, more maintainable Go programs.
This article examines the chronic decay of a long‑standing warehouse inventory system, identifies its tangled business boundaries, chaotic architecture, and uncontrolled delivery efficiency, then presents a domain‑driven design solution with clear modeling, onion‑style layering, CQRS, and practical implementation steps to restore maintainability.
This article humorously explains 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 playful dating scenarios to illustrate each pattern’s intent, structure, and trade‑offs.
The Vivo App Store recommendation system uses a modular, hot‑plug architecture—layered from plugins to base services and employing Template Method, Strategy, and Composite patterns—to integrate unchanged data sources, deliver high‑performance personalized recommendations, reduce development effort by ~75%, and enable rapid, low‑bug scene‑specific upgrades.
The article examines typical criticisms of the Lombok library—JDK compatibility, forced adoption, reduced readability, increased coupling, and perceived drawbacks—while providing detailed rebuttals that argue Lombok remains useful for Java backend development despite these concerns.
This guide breaks down interview focus and resume‑writing strategies for interns, fresh graduates, engineers with 1‑3 years, and professionals with 5+ years of experience, offering practical tips, template recommendations, and a clear roadmap to improve your job‑search success.
The article systematically refutes typical criticisms of Lombok—such as JDK compatibility, forced adoption, reduced readability, increased coupling, and technical debt—by arguing that these concerns are overstated and that Lombok remains a valuable tool for Java backend development.
The article shares a senior Alibaba engineer’s reflections on system architecture design, the evolving role of architects, essential skills such as problem discovery, definition and solution, and how continuous learning, technical breadth, and business understanding enable architects to tackle complex, high‑scale challenges like Double 11.
A former Facebook engineer, newly hired as CTO of the social platform Gab, introduced a simple SQL injection vulnerability by removing critical reject and filter calls, allowing hackers to steal 70 GB of user data, demand a $500,000 Bitcoin ransom, and expose the company's lax security practices.
