This guide explains how to implement declarative retry mechanisms in Java using Spring‑Retry and Guava‑Retry, covering dependency setup, template and annotation usage, various retry and back‑off policies, test examples, and a comparative analysis of their flexibility and configuration options.
This article explains why using Go's init() function is discouraged due to readability, testing complications, and error‑handling limitations, and it offers practical alternatives such as direct variable initialization, custom init functions with sync.Once, and controlled error‑aware initialization patterns.
This article shares a two‑week experience of quickly learning and testing the after‑sales business for a QA engineer, outlining preparation steps, core B2C after‑sales workflow, demand analysis, and practical testing strategies for cross‑business tasks.
Node.js v19.1.0 introduces function mocking in the test runner, recursive file‑system watching support, updated ICU, documentation collaborator additions, removal of experimental fetch warnings, MIME utilities, and performance improvements for text decoding, providing a comprehensive set of backend enhancements.
This collection highlights essential frontend topics—including Vite's performance debate, low‑code concepts, functional programming fundamentals, JMeter performance testing, strategies for managing module dependencies and theme switching, as well as practical guidance on preventing XSS and CSRF attacks—offering developers a concise roadmap to modern web development.
This article outlines ten common developer missteps—from hoarding knowledge and skipping code reviews to weak testing and undocumented changes—and explains how avoiding them can transform you into a high‑value software engineer.
This article provides a thorough overview of backend development, covering system development principles, architectural design patterns, network communication techniques, common faults and exceptions, monitoring and alerting strategies, service governance practices, and deployment workflows, all illustrated with clear explanations and practical examples.
This article provides a comprehensive overview of backend development, covering system development principles, architecture design patterns, network communication techniques, fault and exception handling, monitoring and alerting strategies, service governance, testing methodologies, and deployment practices to help developers build robust, scalable, and maintainable services.
This article presents a comprehensive collection of Python coding principles, idioms, library usage guidelines, design patterns, internal mechanisms, tooling recommendations, and performance profiling techniques to help developers write clean, efficient, and maintainable code.
This article analyzes the difficulties of initializing stable environments, the poor usability and low reliability of feature environments, proposes concrete solutions such as unified test environments, streamlined creation workflows, middleware adjustments, testing and documentation, and shares practical reflections from real deployments.
This article walks through the step‑by‑step transformation of a simple online supermarket from a monolithic web app to a fully‑featured microservice architecture, covering common pitfalls, component choices, monitoring, tracing, logging, service discovery, fault‑tolerance, testing, and deployment strategies.
This article walks through the evolution of a simple online supermarket from a monolithic website to a fully split microservice architecture, highlighting the challenges encountered—such as code duplication, database bottlenecks, and operational complexity—and presenting practical solutions like service decomposition, monitoring, tracing, gateway control, service discovery, circuit breaking, rate limiting, testing strategies, and the use of service meshes.
This article walks through building a lightweight Qiankun JS sandbox by first explaining sandbox principles, then creating a snapshot sandbox, a singular proxy sandbox that records changes via ES6 Proxy, and finally a multiple‑proxy sandbox that isolates each micro‑frontend with its own fake window, complete with test cases and setup instructions.
This article provides a comprehensive guide on unit testing custom React Hooks using Jest, renderHook, act, and the React Testing Library, covering examples such as useCounter, useEventListener, useHover, and useMouse with detailed code snippets and best‑practice recommendations.
Onion Architecture, a DDD‑aligned design pattern, structures applications into concentric layers centered on the domain model, promoting loose coupling, testability, and technology‑agnostic core logic, while detailing principles, layer responsibilities, testing strategies, microservice applicability, modular packaging, and practical implementation considerations.
This article provides a comprehensive guide to upgrading Spring Boot to version 2.7, detailing common issues such as missing dependencies, logging conflicts, circular bean references, Swagger configuration changes, Flyway compatibility, JUnit version mismatches, and JSON Long precision loss, along with concrete code‑based solutions.
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.
