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 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 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.
This article introduces Microsoft’s open‑source Playwright‑Python library, explains how to install it, demonstrates recording and code generation, provides synchronous and asynchronous usage examples—including mobile device emulation—and discusses its advantages and current limitations for web automation testing.
This tutorial walks through creating a production‑ready React Native UI component library named vant‑react‑native, covering monorepo setup with Lerna, package naming, Yarn workspaces, commit and code standards, icon generation, on‑demand loading, debugging, documentation with Dumi, CI/CD deployment, and unit testing.
This article explains the difference between synchronous and asynchronous method calls in Spring Boot, shows how to convert blocking tasks into @Async methods, demonstrates unit‑test setups with CompletableFuture for proper coordination, and provides complete code examples to reduce overall execution time.
This article explains how automation drives DevOps practices by improving speed, consistency, and reliability across the software lifecycle, discusses tools and challenges, and outlines future trends for integrating automated testing and infrastructure-as-code in modern development operations.
The article explains why fixed sleep calls are inefficient for asynchronous operations, introduces polling as a flexible alternative, provides Python code examples with the polling library, discusses advantages and disadvantages, and presents decorator and generic‑function abstractions for reusable polling logic.
The article outlines practical criteria for creating qualified and excellent API documentation, covering project overview, modular organization, request/response details, maintenance practices, and common pitfalls, illustrated with a Jira issue‑creation example, to help testers and developers improve efficiency and communication.
The article explains how embedding quality throughout the development lifecycle—from architecture and design to code, system integration, and release—ensures faster, more reliable delivery, reduces rework, and supports continuous improvement in both software and hardware contexts.
Hexagonal Architecture, introduced by Alistair Cockburn in 2005 and revived since 2015, separates application, domain, and infrastructure layers using ports and adapters, enabling isolated testing, clear dependency direction, and flexible code organization, illustrated with a console‑based poem‑printing example and detailed implementation guidelines.
This article explains how to measure code coverage for C/C++ projects using GCC's built‑in Gcov tool and the LCOV utility, covering prerequisite setup, compilation with profiling flags, running tests, generating .gcno/.gcda files, producing .gcov reports, creating HTML visualizations, and cautions against over‑relying on coverage percentages.
This guide provides a comprehensive overview of Android system architecture, explains the ADB communication mechanism, presents a detailed Android app testing checklist covering UI, compatibility, installation, OTA, interaction, concurrency, database, interface, performance, security, and other tests, and lists essential ADB commands and monitoring principles.
This article explains pytest hook functions, detailing the framework's lifecycle phases, enumerating key hooks for initialization, collection, execution, debugging, and reporting, and provides practical code examples for extending pytest with custom options, dynamic parametrization, logging, and output customization.
This article surveys the popularity of Java, outlines the benefits of using Java testing frameworks, and provides detailed overviews of nine leading frameworks—including JUnit, JBehave, Serenity, Selenium, TestNG, Mockito, HTTPUnit, Gauge, and Geb—highlighting their core features and suitability for different testing needs.
This article explains the difference between FastJSON's getInteger and getIntValue methods, analyzes a common validation bug in a custom isRight() implementation, and provides corrected code examples and optional global switches for robust response handling in Java backend projects.
This article explains agile testing, contrasts it with traditional testing, and details ten guiding principles—including continuous feedback, customer value, face‑to‑face communication, courage, simplicity, continuous improvement, adaptability, self‑organization, people focus, and enjoyment—that help testers and agile teams deliver high‑quality software efficiently.
This guide explains Selenium 4's deprecation of DesiredCapabilities, shows how to use Options for Chrome, Firefox, IE and Safari, demonstrates the updated Actions API for clicks, double‑clicks, right‑clicks and drag‑and‑drop, and details the FluentWait syntax changes with code examples.
The article explains why test suites in enterprise DevOps must run quickly—ideally within five to fifteen minutes—to keep developers productive, and outlines common causes of slow tests such as unnecessary sleep statements, poor test data handling, and lack of event‑driven design, recommending refactoring and optimization.
Microsoft’s Visual Studio Code roadmap for Java (July‑December 2021) outlines security enhancements with Workspace Trust, expanded remote development via GitHub Codespaces, new Gradle and Maven support, testing APIs, virtual‑thread debugging, and ongoing improvements to code completion, navigation, and large‑scale project handling.
This article walks through the evolution of an online supermarket from a simple monolithic website to a fully split micro‑service system, highlighting the motivations, architectural changes, operational challenges, and the tooling needed for monitoring, tracing, logging, and resilient deployment.
This article explains why and when to split existing microservices, validates the split idea with event storming and data‑model analysis, outlines guiding principles, and provides a detailed, step‑by‑step process—including code restructuring, testing, dependency removal, and database separation—to ensure a smooth transition.
Microsoft’s July‑December 2021 VS Code roadmap for Java introduces Workspace Trust security, enhanced remote development via Codespaces, expanded Gradle and Maven support, new testing APIs, virtual‑thread debugging, and ongoing improvements to code completion, package imports, compilation, large‑project handling, performance and reliability.
This comprehensive tutorial walks through creating a React Native component library using Lerna monorepo, Yarn workspaces, code standards, automated builds, unit testing, documentation with Dumi, and on-demand loading techniques, providing practical guidance for developers to manage, test, and publish reusable UI components.
This article explains what coroutines are, compares them with threads, outlines when to use them, introduces the async‑capable httpx library, shows installation and sample code, and demonstrates a performance test where asynchronous requests cut execution time by about 73% compared to synchronous requests.
