This article outlines common data migration scenarios such as system consolidation and database sharding, details analysis of user data before migration, discusses conflict resolution rules, presents migration planning and acceptance testing steps, and highlights post‑release monitoring and user feedback handling.
This article analyzes the challenges of fragmented API documentation workflows at DeWu, introduces the Document‑&‑Test‑Driven Development (DTDD) model, and details the architectural and procedural improvements—including data asset consolidation, multi‑level classification, mock services, and automated testing—that boosted documentation utilization and reduced development friction.
This article provides a comprehensive guide to implementing and testing Go Redis Set APIs—including SAdd, SCard, SIsMember, SMembers, SRem, SPop, and SPopN—complete with code examples, a unified test suite, and a performance benchmark that reports QPS and execution time.
This curated collection introduces key front-end topics—including architecture layering, JavaScript monkey‑patch detection, component sharing via Webpack Module Federation, automated testing basics, Vue 2 this behavior, UX effectiveness measurement, and product versus UX design differences—offering practical insights for modern developers.
This comprehensive guide explains why automated testing is essential for frontend development, outlines the differences between unit, integration, component, and end‑to‑end testing, and recommends practical tools and frameworks such as Jest, Vitest, Testing Library, Cypress, Playwright, and Puppeteer.
The article examines the limitations of unittest's assertEqual for validating hundreds of CSV metrics, proposes method-splitting, custom checkpoint classes, and pytest‑assume techniques to allow multiple assertions to run and report failures without halting the entire test suite.
This article walks through the design and implementation of a lightweight Mocha-like test framework for Node.js, covering automated testing concepts, core functions, asynchronous support, suite‑test tree construction, result collection, and verification with code examples and diagrams.
The article examines why chaos‑engineering experiments often seem low‑cost‑effective, argues that unclear and unquantified steady‑state hypotheses hinder business value and automation, and proposes concrete, user‑centric, measurable hypotheses and equivalence‑class reasoning to streamline experiments and lower costs.
This article describes how Qunar Travel has evolved its testing environment governance from a fixed 10‑machine setup to a template‑driven, soft‑routing architecture (Environment 3.0), improving delivery speed, reliability, business connectivity, and reducing operational costs through automated sync, smart recommendations, and continuous business checks.
This guide shares practical advice on preparing for testing job interviews, handling technical questions, and conducting post‑interview reviews, emphasizing resume optimization, clear skill definitions, and proactive follow‑up to improve interview success rates.
This article shares practical guidelines for new backend projects, covering database design, module organization, scheduled task management, meaningful naming and comments, code robustness, clear error messages, and comprehensive self‑testing to help developers build maintainable and scalable systems.
This article explains how to improve overall delivery efficiency by systematically breaking down testing tasks, setting realistic schedules based on clear goals, preparation steps, granular time estimates, dependency considerations, and post‑execution reviews, while emphasizing a target testing effort not exceeding half of development time.
This article introduces Tox as a virtualenv manager and command‑line testing tool for Python, explains how to install it, set up a simple project with test and setup files, configure tox.ini, run tests across multiple Python versions, and customize environments for advanced usage.
The Xianyu transaction chain now employs automated regression testing that records and replays interface traffic, verifies scenarios, and integrates a strong checkpoint in the release pipeline, cutting manual validation from thirty minutes to one minute, enhancing quality assurance, release safety, and paving the way for broader test coverage.
This article details 58.com’s end‑to‑end approach to securing mobile, H5, and server SDKs—covering security fundamentals, the 5A methodology, the 金盾 architecture, integration steps, data‑flow encryption, comprehensive risk‑based testing, performance evaluation, and release decision making.
The team implements a sustainable “discover‑analyze‑validate” loop that uses a performance blacklist, user‑centric metrics such as interactive time and second‑open rate, automated SDK data collection, and continuous trend monitoring to pinpoint front‑end bottlenecks, apply targeted fixes, and verify measurable load‑time improvements.
This article explains why technical leaders must establish robust code quality assurance mechanisms—covering static analysis, unit testing, code reviews, defect tracking, automation, and release checks—to reduce manual effort, prevent production issues, and ultimately accelerate delivery while fostering developer growth.
This newsletter curates recent technical insights covering the high‑performance Bun JavaScript runtime, ESM Loader Hooks for module processing without bundlers, deep dives into Canvas and CSS graphics, practical guides on unit testing, serverless deployment, and advanced JavaScript features like Proxy and Reflect, offering developers a comprehensive overview of modern frontend engineering trends.
This guide explains why systematic code reviews improve software quality, uncover deep design flaws, enhance security, and foster continuous learning among developers, while outlining clear goals, principles, review criteria, best practices, and measurable metrics for successful implementation.
This article explains how to extend the dble distributed middleware with ClickHouse to provide OLAP capabilities, covering environment setup, XML configuration of user.xml, db.xml and sharding.xml, command‑line testing, data import, and a sample architecture that combines dble, MySQL and ClickHouse.
This article presents fifteen practical, actionable rules for Test‑Driven Development, explaining how disciplined short cycles, writing tests first, and avoiding production data can make TDD both effective and executable for developers.
This article details the design and implementation of a comprehensive quality assurance system for SDK development, covering background motivations, step‑by‑step methodologies, documentation practices, toolchains, real‑time crash data handling, hardware testing, platform automation, and practical Q&A for startup engineering teams.
This curated list presents eleven essential frontend development articles covering VS Code debugging, React component library maintenance, web application evolution, monorepo task orchestration, Ant Design table export, testing strategies, low‑code rendering, browser observers, React Server Components, modern ES features, and effective test planning.
This article explains how to design and implement a data‑masking service that also provides mock data generation for data‑warehouse testing, covering the architecture, pain points, masking principles, workflow, evolution into a warehouse mock service, practical scenarios, and the significant efficiency and cost benefits achieved.
This comprehensive guide explains how to set up continuous integration and continuous deployment (CI/CD) for a front‑end Vite‑React‑TypeScript project using GitHub Actions, covering basic concepts, workflow configuration, code linting, testing, release management, deployment to an Nginx server, status badges, email notifications, rollback mechanisms, and end‑to‑end testing.
This article walks through the author’s decision to continue learning Go for Redis access, outlines a step‑by‑step study plan, compares Go and Java Redis clients, presents a custom Go‑Redis wrapper with full source code, demonstrates usage in unit tests, and shares console output observations.
The article uses a humorous story about two development teams manipulating KLOC defect rates to illustrate Goodhart's law and the McNamara fallacy, then presents a comprehensive set of software quality metrics and guidelines for selecting meaningful measurements that truly improve product quality.
The article presents a comprehensive overview of DevOps quality management, explaining the concepts of left‑shift and right‑shift testing, the role of automation, exploratory testing, and chaos engineering, and offers practical guidance for integrating testing throughout the software delivery lifecycle.
Since 2016, the author shares a collection of Spring Boot best practices—including using custom BOMs, leveraging auto‑configuration and starters, employing Spring Initializr, structuring code, designing services, managing databases, handling concurrency, externalizing configuration, global exception handling, logging, and thorough testing—to help developers build robust, maintainable microservices.
This article presents a detailed collection of Spring Boot best practices—from custom BOM dependency management and automatic configuration to project initialization, code structure, logging, testing, and configuration externalization—providing actionable guidance for building robust, maintainable micro‑services in Java.
Mooncake is a unified data‑mocking platform that lets developers quickly generate and switch multi‑scenario mock data via a Chrome proxy plugin, online configuration service, and capture panel, supporting various client environments, and has been promoted internally through demos, documentation, and feedback loops, now serving hundreds of users and thousands of mock scenes.
This issue curates five technical articles covering Gaode's full‑chain stress testing platform, a distributed web UI automation system, a comprehensive WWDC22 session review, ShouQianBa's efficient automated testing practices, and Autohome's AutoDiff traffic replay for integrated testing.
This article explains the purpose and syntax of Java annotations, describes built‑in annotations such as @Override, @Deprecated and @SuppressWarnings, shows how to create and use custom annotations with meta‑annotations, and demonstrates a lightweight testing framework that records annotation‑driven test failures.
This article introduces typical subtraction, multiplication, and division damage formulas, explains their design principles, demonstrates practical examples from games such as Arknights and Dota 2, and outlines testing methods, effective metrics, and additional concepts like stacking, round‑table theory, and second‑roll analysis for balanced combat systems.
After a year of cross‑BU experimentation, the Tianji precision testing platform was built to centralize coverage data, automate incremental analysis, and provide actionable insights, resulting in higher test coverage, faster release gating, and measurable productivity gains for both developers and QA teams.
The article outlines ten key traits of high‑quality code—robustness, efficiency, maintainability, brevity, testability, reusability, portability, observability, operational readiness, and scalability—explains why many engineers overlook these standards, provides examples of bad code, and emphasizes the importance of thorough requirement analysis, design, testing, and documentation throughout the software development lifecycle.
This article provides an extensive overview of the modern React ecosystem, covering project setup options, state management, routing, styling, component libraries, animation, data fetching, testing, type checking, internationalization, and many other tools and best‑practice recommendations for frontend developers.
This article explains why concurrency issues like overselling occur in e‑commerce, introduces distributed lock concepts and mainstream implementations (MySQL, Redis, Zookeeper/etcd), and provides a three‑stage quality‑assurance framework with code‑review checklists, testing methods, and data‑reconciliation techniques.
This article presents sixteen practical Spring Boot best‑practice recommendations—ranging from custom BOM management and automatic configuration to project structure, logging, testing, and externalized configuration—to help developers build clean, maintainable, and production‑ready Java microservices.
This collection presents five technical articles covering the Spock unit‑testing framework, reasons why automation testing struggles, backend automated testing with continuous deployment, AI‑based UI defect detection, and practical automation of HarmonyOS applications, offering valuable insights for developers and testers.
This article walks through setting up the Go environment, defining protobuf files, generating code, and implementing both server and client sides of a gRPC service, complete with runnable examples, common pitfalls, and output verification to help developers quickly adopt Go‑based gRPC testing.
This article demonstrates how to use EasyPOI to export Excel files with dynamically generated column headers and data rows in Java, covering dependency configuration, header creation, data population, merging cells, utility methods, DTO definitions, and a complete test case.
This article recounts the end‑to‑end experience of planning, executing, and reviewing a database sharding project for a high‑traffic order platform, detailing pre‑implementation risk assessment, the detailed testing lifecycle, gray‑release strategies, performance validation, and post‑mortem lessons learned.
This article presents the design, implementation details, and workflow of a Java code coverage platform built on JaCoCo, covering full and incremental coverage collection, configuration, analysis of diff code, reporting, and future integration plans to improve testing quality and code reliability.
This guide presents five practical Go techniques—using a large ballast slice to control GC timing, leveraging benchmark and pprof for performance profiling, applying the monkey library for test stubbing, avoiding unreleased locks that cause OOM, and employing proper synchronization primitives to prevent stale memory reads.
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.
This article chronicles Lyft's evolution from a PHP monolith to a Python and Go microservice architecture, detailing the development and testing environments—including Devbox, Onebox, integration testing, pre‑release staging, and the migration to Kubernetes—while highlighting the scalability and productivity challenges faced as the service count grew to hundreds.
DeWu’s international e‑commerce team adopts shift‑left, business‑driven testing and a Java‑SpringBoot‑JUnit5 automation framework with continuous coverage analysis, moving tests earlier in the lifecycle to deliver rapid feedback, cut manual effort, and ensure high‑quality, efficient releases aligned with business value.
The article explains what a mobile advertising SDK is, outlines its core components such as documentation, interfaces, logs, and samples, and details comprehensive testing approaches—including functional, compatibility, network, security, stability, and performance tests—organized in layered strategies from demo to code-level automation.
This article provides a comprehensive guide to Pytest, covering basic test case creation, exception handling, test classes, automatic test discovery, advanced features like parametrize, marks, fixtures, and plugin/hook development, complete with practical code examples and configuration tips.
The article outlines ten essential characteristics of good code, contrasts them with common bad‑code patterns, and explains how thorough requirement analysis, system design, testing, and operational practices together produce high‑quality software, while also promoting a related book giveaway.
This article outlines eighteen provocative tactics—ranging from blaming QA for every incident to inflating branch counts, eliminating testability, and enforcing excessive overtime—that collectively illustrate how various roles can deliberately sabotage a software testing team and degrade overall product quality.
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.
The author recounts submitting a Go PR to fix a benchmark timeout overflow bug, detailing the code review feedback, overflow detection issues, testing strategies, and proper commit‑message conventions, ultimately sharing insights from a largely unsuccessful contribution attempt.
This article introduces the concept of QA in game development, explains its responsibilities from delivery testing to test delivery, highlights the importance of early requirement analysis, test case design, cost estimation, and collaboration with planners, and reflects on the value and confidence QA brings to the production pipeline.
This article explains the SRE role originated by Google, outlines its core responsibilities such as automation, observability, incident response, testing, capacity planning, and SLI/SLO/SLA management, and highlights the skills and cultural practices needed for reliable service operations.
The DeWu Tech Salon, co‑hosted by DeWu App Quality Platform and TesterHome, brought senior engineers from Alibaba Cloud, ByteDance, Lagou and DeWu together to share practical QA insights on end‑side monitoring, traffic replay, full‑link stress testing, and industry‑scale chaos engineering, while announcing a PPT collection, a testing‑expert recruitment drive, and a preview of the next wireless‑technology salon.
This talk shares Yuque’s experience building an Electron‑based desktop product, covering why Electron was chosen, the app’s architecture, and engineering practices—including unit testing, integration‑test coverage, package and data security, update strategies, and full‑link logging—to improve code quality and runtime stability.
This guide explains how to use Python's pymysql library to connect to a MySQL database and perform batch updates of user login information, a technique useful for large‑scale interface automation where login credentials may expire during test execution.
This article outlines four key areas for modern Python development—type hinting, virtual environment and package management tools, recent syntax enhancements like pattern matching and the walrus operator, and testing frameworks—providing practical guidance for writing robust, up‑to‑date Python code.
This article demonstrates how to extend Go's HTTP client with a custom DNS resolver using net.Dialer, configure load‑balancing, and test the implementation with sample code and a simple mock service, providing a practical guide for backend developers.
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 distills key lessons from the book "Clean Code", covering expressive naming, purposeful functions, minimal and meaningful comments, and rigorous testing practices, illustrated with concrete code examples to help developers write more readable and maintainable software.
This article outlines four essential modern Python concepts—type hinting, virtual environment and package management tools, recent syntax enhancements such as pattern matching and the walrus operator, and advanced testing frameworks—providing developers with the knowledge needed to write clean, efficient code in 2022 and beyond.
This article explains feature toggles (feature flags), illustrating their use through a game‑engine story, categorizing toggle types, describing management and configuration strategies, presenting implementation patterns to decouple decision logic, and offering testing and operational best practices for reliable continuous delivery.
This comprehensive guide walks developers through creating, testing, and refining custom ESLint rules, covering rule scaffolding, meta configuration, AST traversal, scope analysis, handling various node types, code path analysis, autofix implementation, and extensions for React JSX and TypeScript.
This guide explains how Sentry's browser SDK integration tests are built with Playwright, covering test structure, helpers, fixtures, local execution commands, troubleshooting tips, and step‑by‑step instructions for setting up and running the tests across Chromium, Firefox, and WebKit.
This guide details Sentry's comprehensive testing strategy, covering devservices setup, Python pytest workflows, factory-based data creation, feature flag handling, SQL logging, Selenium acceptance tests, visual regression, Jest frontend tests, API fixtures, and Kafka integration within CI pipelines.
This tutorial walks through adding pagination and flexible where‑filters to the User List interface, configuring gqlgen extensions, handling GraphQL errors, wrapping mutations in transactions, and building unit, integration, and end‑to‑end tests for a Go clean‑architecture project using Ent and gqlgen.
This article walks through setting up Spock for Java/Groovy projects, lists required Maven dependencies, shows how to handle static‑method mocking with PowerMock and Mockito, and provides concrete code examples for mocking @Autowired components, shared objects, and defining mock behavior.
The article demonstrates how to structure a Go backend using Clean Architecture’s four‑layer model, interface‑driven design, and compile‑time dependency injection with Google Wire, providing concrete examples of repository, service, and API implementations and unit‑testing each layer with sqlmock, gomock, and httptest.
This guide explains how to set up Selenium to drive Chrome and Electron applications on macOS, covering ChromeDriver version matching, configuring Electron's binary location, building and packaging the app, and using remote debugging to test already‑running Electron instances.
The article explains how to create a lightweight custom waiting utility in Java (using Groovy syntax) that repeatedly checks a condition every 0.5 seconds, simplifying thread synchronization for performance testing of multithreaded code.
This article outlines ten practical habits for developers, from relying on official documentation and thorough testing before delivery to effective logging, mastering Git, prioritizing functional implementation over premature optimization, managing requirements, proactively solving project issues, allocating buffer time, hands‑on learning, and improving English for technical growth.
This article presents a concise collection of ten Chinese-language resources that summarize the 2021 DORA DevOps report, the importance of consistency in R&D, fundamental efficiency principles, Microsoft’s testing shift, Google’s release and productivity metrics, and SRE health measurements, offering valuable insights for modern software engineering teams.
This article explains why and how to use code diff and code‑coverage metrics, provides concrete examples of debugging and test‑case design, and shares step‑by‑step instructions for using IDEA and remote debugging to ensure business quality throughout the development lifecycle.
This article explains how to use Go's test command with various flags such as -c, -run, -timeout, and -coverprofile, demonstrates writing test cases, TestMain setup, benchmarking, profiling with pprof, generating flame graphs, and interpreting coverage reports to improve Go application reliability and performance.
Spring Boot 2.6.0 introduces several important changes such as default prohibition of circular dependencies, custom sanitizing functions, automatic Redis connection‑pool activation, moved reactive session properties, Maven build‑info exclusions, WebTestClient support for MVC testing, and Log4j2 composite configuration options.
This guide walks developers through installing Apifox, importing API specifications, designing and debugging endpoints, configuring environments, creating custom scripts, and generating realistic mock data, demonstrating how the all‑in‑one platform can replace Postman, Swagger, JMeter and other tools for comprehensive API documentation, testing, and automation.
This article examines the Athena customer‑service system by describing its purpose, behavior‑tree based architecture, configuration‑driven logic, and practical testing approaches, while also proposing future improvements such as engine‑plus‑configuration designs and automated test‑case generation.
This guide explains how to contribute to Sentry's frontend codebase, covering repository layout, file naming, index usage, React component patterns, PropTypes, event‑handler conventions, Emotion styling, lint rules, TypeScript defaultProps, state management, testing with React Testing Library, Storybook setup, and migration from grid‑emotion to modern Emotion APIs.
This article introduces the importance of frontend unit testing, presents survey data on current practices, compares popular frameworks like Jest and Mocha, provides step‑by‑step setup instructions, demonstrates code examples for JavaScript, TypeScript and async functions, and explains how to generate coverage reports and use common assertions.
This article outlines ten practical habits for developers, from relying on official documentation and thorough testing to effective logging, Git mastery, prioritizing functionality, handling ambiguous requirements, proactive problem‑solving, scheduling buffers, hands‑on learning, and improving English for better access to technical resources.
This article reviews the 13‑year evolution of Ant Group's registration center, analyzes the scaling and reliability challenges of multi‑cluster service discovery, and explains how the SOFARegistry 6.0 redesign—featuring meta‑driven consistency, slot‑based sharding, application‑level discovery, chaos testing, and automated operations—addresses those challenges while preparing the project for open‑source community growth.
This guide explains how to separate unit and integration tests in a Maven project, configure the Build Helper and Failsafe plugins, set up JaCoCo to generate combined coverage reports, and visualize them in SonarQube, including a complete example pom.xml.
This article shares ten practical habits for developers, from consulting official documentation and thorough testing before delivery to effective logging, mastering Git, prioritizing functional implementation, managing requirements, proactively solving project issues, allocating buffer time, hands‑on learning, and improving English for better access to technical resources.
This guide walks through using the Gorilla WebSocket library in Go, covering dependency setup, server implementation with an Upgrader, Java and Go client examples, testing procedures, and performance observations that highlight Go's advantages for WebSocket workloads.
This article walks through developing a simple Go WebSocket server that echoes the current time, shows a minimal client, compares startup speed with Java, and provides full source code and test logs for practical performance testing.
This article details how the Android Room library added experimental Kotlin Symbol Processing (KSP) support to replace KAPT, describing the performance benefits, the architectural challenges of creating an X‑Processing abstraction layer, the testing infrastructure built around it, and the remaining limitations and future work.
The article highlights recent releases and tools for developers, including icejs 2.0’s React‑Vite integration, Kraken 0.9’s QuickJS performance boost, the Detox mobile testing framework, Teaful’s lightweight React state management with code example, MJML’s responsive email builder, and a brief guide to pure‑CSS icons.
The article explains how to automatically generate separate unittest test cases for each combination of input parameters by using setattr and static methods, avoiding large monolithic tests and enabling clear result reporting, and provides a complete Python code example.
This article explains the fundamentals of Jepsen testing, compares it with TLA+, describes its architecture and workflow, illustrates how to apply Jepsen for linearizability verification of distributed systems such as locks, and offers practical guidance on integrating Jepsen or building custom testing frameworks.
This guide explains what ZZNohost is, why it is used, and provides step‑by‑step instructions—including account setup, environment creation, whistle configuration, mobile proxy capture, UI automation integration with code examples, and platform‑level usage in Jarvis and WatchDog—to streamline multi‑environment testing and debugging.
In an interview, Tencent senior frontend engineers Wu Wenbin and Yang Chen explain the pain points of traditional development‑testing workflows, how their internal TDE platform built on the open‑source Whistle engine streamlines remote collaboration, improves security, and accelerates testing for both internal teams and external partners.
This article walks through creating a reusable Go HTTP client wrapper, demonstrates its use in a test script, shows console output, and integrates a mock server with Moco to enable quick API testing while applying a learning‑by‑doing approach.
This article surveys the most commonly used Java libraries and tools—from Netty and SpringBoot to JUnit, JMH, OkHttp, HikariCP, Caffeine, Hazelcast, logging frameworks, Jackson, Jolokia, Hibernate Validator, and FreeMarker—highlighting their roles, advantages, and integration tips for modern enterprise development.
This article walks you through every stage of turning a Python project into an open‑source package, covering licensing, project structure, setup.py creation, testing, documentation, continuous integration, and finally releasing the package to PyPI or Conda.
This article describes how the Auto Home Dealer business unit transformed its software quality process over three years by piloting, scaling, and institutionalizing testing practices, addressing role‑specific challenges, introducing automation, and continuously measuring impact to achieve faster, more reliable releases.
This article provides a comprehensive overview of microservice architecture, tracing its history, explaining its benefits over monolithic and SOA approaches, and detailing common cognitive, time, cost, development, testing, and operational traps along with practical mitigation strategies for successful adoption.
