This article explains how DevOps transforms software testing by moving from isolated, waterfall‑style testing to continuous, automated, shift‑left practices, and outlines best‑practice recommendations such as test automation, tool selection, metrics, documentation, and the role of test‑automation engineers.
This tutorial walks through configuring Spring Boot 2.3.10 with Elasticsearch 7.8, defining Maven dependencies, setting up application properties, creating a searchable Product model, implementing a repository with derived query methods and custom @Query annotations, and testing CRUD and advanced search operations using both repository and RestTemplate approaches.
The article outlines how map‑collection vehicles achieve high hardware quality and reliability through systematic design, production management, and rigorous testing—including derated components, redundancy, thermal and mechanical safeguards, sensor protection, and data‑driven failure prediction—to meet MTBF targets and extend service life.
This guide walks you through using Airtest to connect Android emulators, Windows desktop apps, and real Android phones—both via USB and Wi‑Fi—covering required developer settings, driver installation, input method configuration, and sample connection scripts.
This article chronicles the six‑year evolution of the Tian'e Home Service order platform—from its early embedded form in 2015 to a unified, multi‑service order system—detailing architectural milestones, functional upgrades, and the testing challenges faced by the QA team throughout each phase.
The article describes how a rapidly growing development team built a one‑click, cloud‑native platform that automates the provisioning, configuration, Docker image creation, and Kubernetes deployment of diverse test environments, addressing challenges such as heterogeneous tech stacks, middleware variety, and configuration inconsistencies.
This guide outlines essential Python best‑practice techniques—including memory management, choosing Python 2 vs 3, adhering to style guides, using static analysis tools, optimizing performance, profiling, testing, and continuous integration—to help developers write clean, fast, and reliable code.
This article introduces the Airtest mobile automation IDE, explains its cross‑platform and platform‑specific APIs, and provides detailed code examples for device initialization, control, app management, screen actions, and assertions, enabling developers to automate mobile testing efficiently.
This guide presents six practical Python best‑practice techniques—including memory management, version compatibility, code style, performance tuning, profiling, and testing with CI—to help developers write faster, more maintainable, and well‑documented code for open‑source and personal projects.
This article explains how Go's built‑in testing tool gathers code coverage, detailing the relevant go test flags, configuration steps for unit and integration testing, instrumentation mechanics, output formats, and practical solutions used in real‑world projects.
This guide introduces the most essential Visual Studio Code extensions for Python developers, covering tools for code analysis, snippets, docstring generation, testing, preview, type hinting, and Jupyter Notebook integration, each with download links and key features to boost productivity.
The article outlines CI/CD best practices for ToB platforms, detailing standardized branch and pipeline conventions, automated testing with Jest, versioning strategies, frontend‑backend contract design, and tools like YAPI to ensure reliable, fast, and decoupled deployments across numerous coupled systems.
This article introduces JD's code coverage statistics platform, detailing its concepts, significance, implementation approaches for Android and iOS—including Jacoco and Xcode configurations—its SDKs, data collection, reporting mechanisms, and how it enhances testing quality and development efficiency.
This article introduces Youzan's testing team, detailing its growth to over 120 engineers across three cities, the test‑development responsibilities, automation and load‑testing practices, quality‑assurance framework, training programs, and the open, growth‑focused team culture that candidates can expect.
The article describes how algorithm testing teams tackled data‑quality and interface‑semantic monitoring problems by building a unified business monitoring platform that checks table, storage and service consistency, validates response semantics, and, through dashboards, alerts and correction tools, quickly identified dozens of offline and online issues, guiding future reliability enhancements.
This article details JD's end‑to‑end implementation of HDFS erasure coding, covering the migration from replication to EC, the three‑phase upgrade and rollback process, comprehensive automated testing, a custom data‑lifecycle management system for hot‑warm‑cold data, and multi‑layer integrity safeguards to achieve significant storage cost reduction while maintaining reliability.
This article walks through the complete lifecycle of transforming a simple online‑store monolith into a full‑blown microservice system, covering the initial requirements, emerging problems, service decomposition, monitoring, tracing, logging, gateway, service discovery, circuit breaking, testing, framework choices, and the eventual adoption of a service mesh.
Learn how to set up Go in Linux, macOS, and Windows, understand its core syntax, manage packages, work with variables, arrays, slices, maps, control structures, goroutines, channels, interfaces, write unit tests, use Go Convey, connect databases with GORM, and build simple web servers with the standard library or Gin.
This article explains how business-driven requirements guide software selection, detailing how to identify research targets, evaluate system architecture, community health, documentation, compliance, and feature fit, and then verify through testing before applying the chosen solution.
This article presents a comprehensive model quality assurance framework for click‑through‑rate (CTR) prediction, detailing the challenges of data and logic inconsistency, defining consistency goals, describing a full‑stack verification pipeline—including online data capture, offline sample alignment, multi‑stage q‑value comparison, and automated reporting—and sharing practical deployment experiences and results.
Ant Group’s Service Mesh experience reveals that while MOSN’s extensive feature integration boosts capabilities, it also introduces significant R&D efficiency challenges such as large change volumes, centralized releases, and quality assurance, prompting the development of Test Mesh, health metrics, low‑impact high‑frequency deployments, and advanced diagnostic tools.
The article explains how Google measures and maintains software quality before release by dividing responsibilities between product teams and SRE, using monorepo, trunk‑based development, daily release candidates, automated testing, performance monitoring, and a Project Health (pH) metric system that tracks productivity, release velocity, reliability, and quality.
This guide outlines the core JavaScript concepts, asynchronous programming fundamentals, package management, HTTP protocols, web frameworks, databases, caching strategies, template engines, real‑time communication, API clients, and testing tools that form a comprehensive learning roadmap for aspiring Node.js backend developers.
This article shares a software team’s experience of shortening release cycles from two‑week to one‑week sprints, the quality challenges encountered, the root causes of instability, and the practical process improvements—including stable release branches, extended testing windows, and holiday moratoriums—that restored service reliability.
This article walks through the journey of transforming a simple online supermarket from a monolithic web application to a fully fledged microservice architecture, covering the motivations, common pitfalls, service decomposition, monitoring, tracing, logging, gateway, service discovery, circuit breaking, testing strategies, and the role of service mesh.
During the Chinese New Year break the author used draw.io (now diagrams.net) to create a comprehensive architecture diagram of the FunTester testing framework, outlining its functional and performance layers, supported protocols, utility modules, and multithreaded execution model.
This article explains the long‑term benefits of unit testing such as saving time and money, reducing code complexity, providing documentation, and enabling performance evaluation, and then provides a detailed guide on writing, organizing, and running Go tests with code examples.
The article explains why offline environments are inherently unstable, outlines the root causes, and provides a comprehensive set of practical strategies—including infrastructure standards, stable layer improvements, dev environment hygiene, IaC, and continuous integration—to make offline environments as stable as possible.
A seemingly harmless code change that returned null triggered a massive production outage, costing millions, and the author recounts the incident, the emergency rollback, root‑cause analysis, and the broader lessons about code review, testing, monitoring, and disciplined release practices.
This article presents practical refactoring techniques for PHP developers, emphasizing unit testing, bottom‑up restructuring, eliminating magic numbers, using braces, meaningful naming, and leveraging language features, illustrated with real‑world hotel management code examples and concise best‑practice tips.
Hulk is a non‑intrusive HTTP mock platform built with Django, mitmproxy, Vue, MongoDB and MySQL that lets teams mock client‑side, gateway-level and inter‑service APIs via configurable responses, without modifying production code, thereby reducing test‑data creation effort, stabilizing automation and improving overall testing efficiency.
Facing a massive 1500‑node Flink 1.4.2 cluster handling over 12,000 tasks and 30 trillion daily events, we migrated to Flink 1.10, detailing new DDL/Catalog support, SQL enhancements, memory tuning, compatibility patches, extensive testing, and engine optimizations such as task‑load metrics and balanced sub‑task scheduling.
This article walks through using Socket.IO to test whiteboard pixel data transmission, presenting a Java test script, sample console logs, and an explanation of the joinRoom interface that pushes full board state to connected clients.
The article introduces Baidu's self‑developed test middleware, explains its data‑plane and control‑plane architecture inspired by Istio, describes the challenges of building test environments, and details the system’s components, working modes, and diverse testing use cases such as functional, system, integration, sandbox, and chaos engineering.
This article introduces Microsoft’s open‑source Playwright‑Python library, explains its advantages over Selenium, walks through installation, code generation, synchronous and asynchronous usage, mobile emulation, and highlights its strengths and current limitations for Python developers.
This article outlines the typical roles in an internet company, explains how cross‑department collaboration, timeline definition, resource allocation, development‑testing‑deployment phases, and comprehensive project retrospectives work together to ensure successful project delivery.
This article compiles a wide-ranging discussion on how development teams can guarantee that developers allocate sufficient time for writing test cases despite tight schedules, covering division of testing duties, organizational processes, requirement handling, performance metrics, and skill development.
This article explores the challenges of frontend availability, introduces chaos engineering concepts, and details Alibaba's practical approach to frontend fault injection—including static resource hijacking, a safe isolated environment, monitoring integration, and a real‑world drill that demonstrates how to measure and improve detection and response capabilities.
This article explains how Microsoft’s Azure DevOps team transformed its testing approach by shifting tests left, introducing new quality principles, redefining test classifications, improving automation reliability, and measuring progress with DevOps metrics to achieve faster, more trustworthy continuous integration and delivery.
This article explores the core principles of clean code—from effective naming and expressive functions to purposeful comments and rigorous testing—illustrating how disciplined practices like meaningful identifiers, single‑responsibility functions, and the FIRST testing criteria can dramatically improve code readability, maintainability, and reliability.
This article presents a curated list of ten insightful resources covering Google’s OKR guide, code coverage best practices, code health principles, software product team efficiency metrics, unit testing responsibilities, quality assurance case studies, effective code review, Microsoft’s testing transformation, agile misconceptions, and related engineering topics.
This article walks through the design and implementation of a custom JsonPath validation library using Groovy operator overloading, detailing the core enums, verification bean, arithmetic handling, and practical demo code, while providing repository links for Gitee and GitHub.
This article explores why and when to refactor legacy projects, outlines common pitfalls such as missing functionality and inadequate testing, and offers practical guidance on assessment, testing, branching, feature toggles, and A/B testing to ensure a successful rewrite.
The article introduces the widely‑starred GitHub project “Node.js Best Practices,” highlighting its multilingual documentation, comprehensive coverage of project structure, error handling, coding standards, testing, production, security, and performance, and encourages readers to visit the repository for detailed guidance.
This tutorial explains how to configure retry mechanisms in Spring Batch jobs, covering Java and XML setups, code examples for processing CSV input, handling REST timeouts, and unit tests that demonstrate retry behavior and job outcomes.
This article examines why teams moving from waterfall to agile need automated regression testing, compares building a custom Selenium framework with adopting a no‑code solution, and outlines the practical considerations of cost, maintenance, integration, reporting, and team skill development.
This article walks through the transformation of a simple online supermarket from a monolithic application to a fully fledged microservice architecture, covering design principles, common pitfalls, monitoring, tracing, logging, service discovery, circuit breaking, testing strategies, and the role of service meshes.
Faced with network latency and only a Docker container available, this guide compares two practical ways to run Groovy test scripts—packaging the test class into a JAR and invoking its main method, or using a reflection utility to call methods dynamically—complete with code samples, Maven commands, and execution results.
This guide shows how to create a Python 3.7 Socket.IO client script for testing socket interfaces, including installation of the python‑socketio package, handling authentication tokens with tools like Postman, and a complete example script with repository links for reference.
This article explains how to integrate JUnit unit testing into Jenkins pipelines using Maven and Spring Boot, covering project setup, dependency configuration, test case creation, Jenkins job configuration, and result reporting to achieve fully automated testing in a DevOps workflow.
This guide explains how to set up a local PHP development server—either on Windows or in a Linux VM—by creating a www directory, adding test scripts, using PHP's built‑in web server with optional root or router settings, and verifying the results via browser requests.
This article explains what code quality means, outlines its essential characteristics, discusses how to measure it with metrics and coverage, and introduces static analysis tools such as Checkstyle, PMD, and CPD to help Java developers maintain reliable, maintainable, and secure code.
This article walks through building and executing a Groovy‑based test script that registers two users, joins a room, exchanges chat messages over a Socket (WebSocket) connection, and cleanly closes the sockets, illustrating the full workflow and code structure for backend socket API testing.
This guide outlines the three‑stage data‑migration testing process—preparation, execution, and verification—detailing how to assess data scope, choose migration methods, evaluate system compatibility, construct test scenarios, validate scripts, monitor performance, and confirm backend, frontend, and business‑logic integrity after migration.
The article explains the challenges of keeping interface model definitions synchronized between development and testing, compares code‑first and doc‑first approaches, introduces the Go‑based GinDoc library for generating Swagger documentation and client code from annotated routes, and provides step‑by‑step usage examples and integration tips.
This article walks through the design and implementation of a Java Socket.IO client library, covering dependency setup, core class architecture, event handling, connection management, performance testing utilities, and a complete usage demo with console output.
This article walks through the evolution of an online supermarket from a simple monolithic website to a fully split microservice architecture, highlighting the pitfalls of ad‑hoc growth, the need for service abstraction, monitoring, tracing, fault tolerance, testing, and the trade‑offs of frameworks versus service mesh.
This article describes how Dada built a JaCoCo-powered code coverage platform for Java services deployed on Kubernetes, covering tool selection, on‑the‑fly instrumentation, data collection, incremental coverage analysis, CI gate enforcement, encountered pitfalls, and future enhancements.
This guide walks through creating a Java WebSocket chat application, covering a SpringBoot server implementation, client setup using java‑websocket, configuration pitfalls, a bean‑based scheduler, and a test script that simulates multiple users joining, messaging, and leaving the chat room.
This article explores the design and implementation of the Yueying front‑end monitoring SDK, covering its purpose, core design principles, module architecture, reference formats, semantic versioning, key interfaces, testing strategy, and user‑experience enhancements such as quick integration and dynamic sampling.
This article explains what an SDK is, outlines key design principles such as minimalism, stability, and extensibility, and walks through the practical implementation of Alibaba’s Yueying front‑end monitoring SDK, covering architecture, module division, versioning, core interfaces, testing, and deployment options.
This article provides a comprehensive overview of the most common Selenium WebDriver exceptions, categorizes them into checked and unchecked types, details language‑specific variants for Java, C# and Python, and offers practical guidance on diagnosing and handling each exception during automated browser testing.
This article explores how software engineers can improve their work by clearly defining roles, applying systematic refactoring strategies, and enforcing quality through team consensus, testing practices, and a strong engineering culture, drawing on over two decades of industry experience.
This article introduces a Groovy‑based Verify utility that overloads arithmetic and comparison operators to simplify JsonPath response validation, eliminating manual type conversions and enabling expressive syntax for front‑end test cases.
The article outlines the complex nature of testing environments, enumerates typical problems such as resource constraints, external dependencies, and service bugs, and presents systematic troubleshooting methods, useful tools, and real‑world case studies to improve reliability and efficiency.
This article examines the complexities of testing environments, outlines typical causes of failures such as resource constraints, external dependencies, and service bugs, and provides systematic troubleshooting methods, useful tools, and real‑world case studies to improve reliability and efficiency.
The article explains how to use JaCoCo to instrument Android SDK classes—detailing probe insertion strategies for methods, branches, and code blocks, offline and Ant/Gradle integration, building instrumented packages, collecting execution data, and generating HTML coverage reports without modifying source code.
The guide walks developers through Android testing basics by explaining JUnit unit tests, instrumented tests, and Espresso UI tests, showing where local and device tests reside, demonstrating how to generate a Calculator unit test and an Espresso test for a simple activity, and how to run them in Android Studio.
This article reviews five popular Python automation testing frameworks—Robot Framework, Pytest, UnitTest/PyUnit, Behave, and Lettuce—detailing their prerequisites, strengths, weaknesses, and how they compare, to help developers select the most suitable tool for their projects.
This article walks through the creation of a Groovy‑compatible JsonPath utility library, explaining its design, key methods for extracting various data types, a custom verification helper, and how to test it later with the Spock framework.
This article presents a practical, multi‑stage approach for improving software reliability in Kubernetes‑based microservice environments, covering static analysis, testing pyramids, CI/CD observability, performance testing, deployment strategies, and feedback loops to help engineering teams deliver faster, higher‑quality releases.
This article walks through the transformation of a simple online supermarket from a monolithic design to a fully fledged microservice system, explaining the motivations, architectural changes, component selection, common pitfalls, and best‑practice solutions such as service decomposition, database sharding, monitoring, tracing, service mesh, resilience patterns, and testing strategies.
The article details the architecture of 58.com’s SSP advertising platform, identifies three key reliability challenges—data consistency, interface regression, and storage synchronization—and presents a three‑layer testing quality system comprising web‑layer validation, service‑layer automated testing, and data‑layer monitoring with concrete tools and future improvement plans.
This article explains how a comprehensive event‑tracking management platform can streamline definition, offline and online assurance, automate testing, and monitor data quality across multiple client platforms, improving collaboration and reducing errors in fast‑growing business environments.
The article explains how to bypass internal network restrictions by configuring a Java HTTP proxy, provides demo code for setting and using the proxy, and includes utility methods for proxy validation and request configuration.
This article explains how to measure Python code coverage using the Coverage tool, covering installation, command‑line and API usage, and provides a complete example with a simple function, unit tests, and generated HTML reports to visualize covered and missed statements.
This article details the end‑to‑end process of designing, publishing, packaging, optimizing, and continuously delivering a reusable React component library at Ctrip, covering npm workflow, build tooling choices, CSS extraction, on‑demand loading, package splitting, collaborative documentation, CI/CD, and automated testing.
Angular, a Google‑maintained front‑end framework from version 2 onward, offers cross‑platform capabilities such as progressive web apps, native mobile and desktop applications, along with high performance through code generation, server‑side rendering, automatic code splitting, and a rich productivity ecosystem including CLI, IDE support, testing, animation and accessibility tools.
The article describes Alibaba’s flow‑based comparative testing and introduces Youku’s hot‑link coverage technique, which instruments method chains to automatically identify high‑frequency request paths, recommend them for regression testing, achieve full business‑link coverage without manual effort, and outlines future machine‑learning enhancements.
The article introduces Bach, a lightweight Bash unit‑testing framework that lets developers safely detect dangerous commands like rm ‑rf in scripts, explains how to import it, use its @do‑not‑panic API and other mock commands, and outlines its principles, limitations, and real‑world adoption.
The author recounts bugs uncovered during a web‑based QA session—ranging from mismatched character‑length limits and inconsistent filter defaults to fragmented documentation—highlighting how overlooking tiny validation rules can cause costly defects and why unified standards and professional testing are essential.
This article explains how the JD.com "Jingxi" mini‑program uses the official miniprogram‑automator SDK to build an automated disaster‑recovery testing workflow that launches the devtools, simulates user actions, intercepts network requests, generates screenshots, and validates fallback behavior with manual comparison.
The author shares a first‑hand account of a newly launched backend project, explaining how strict coding standards, Groovy‑Java mixed development, and a pragmatic testing strategy—including limited unit testing, interface checks, and annotation‑based validation—enabled rapid bug resolution and a smooth release.
This guide walks you through installing Node.js, creating a project directory, installing Cypress via npm, launching the tool, and understanding its default file structure, providing clear step‑by‑step instructions and screenshots for a smooth setup.
The article explains why programming has become essential for software testers, compares Java and Python for automation, and offers practical ways—continuous coding, problem‑solving on OJ platforms, and project practice—to steadily improve coding ability.
The article shares practical experiences on running test cases concurrently using Java multithreading and a custom thread pool, and outlines MySQL database naming, null handling, and schema design guidelines, including full code examples for the case runner and thread pool implementation.
The article explains how to isolate testing scenarios and choose appropriate testing methods for various business contexts—storefront changes, order processing, and cross‑platform integrations—by establishing baseline data, comparing results, and leveraging tools like YApi to improve quality and efficiency.
Learn step-by-step how to set up and test multiple data sources in a Spring Boot application using MyBatis, covering property configuration, DataSource beans, mapper scanning, entity definitions, and verification through unit tests with complete code examples and key configuration notes.
This guide explains why Linux is essential for software testers, outlines how to build test environments, use key commands like tail, grep, top, and vmstat for log analysis and performance monitoring, and offers tips for deeper Linux learning and interview preparation.
This article details the Agricultural Bank’s Distributed Application Interconnection (AIR) platform’s DevOps journey, covering small‑granularity development, comprehensive configuration management, end‑to‑end automated pipelines, advanced testing automation, metric‑driven improvements, and the successful third‑level continuous delivery assessment across multiple projects.
This guide explains step‑by‑step how to set up two separate databases in a Spring Boot application, configure Spring Data JPA for each, create the necessary configuration classes, and verify the setup with a simple integration test.
Despite pandemic‑induced remote work challenges, the author details progress on implementing test case management, focusing on MyBatis resultMap usage, bean and database design complexities, and provides the full XML mapping and SQL query for retrieving detailed test case information.
This article explains a practical approach to validate test‑account login status by using a special syntax, per‑user locking, and thread‑safe caching to avoid repeated logins, while discussing transaction isolation levels and propagation settings needed for reliable backend testing.
The article walks through creating a test management platform using Spring Boot, mockJS, and custom MyBatis TypeHandlers to store public data as JSON arrays, detailing the data model, handler implementations, and full mapper XML configuration for CRUD operations.
This guide outlines why manual testing can’t fully replace automation, then walks you through seven concrete steps—including data preparation, API testing, and web UI automation using tools like MySQL, Redis, SOAP UI, Postman, and Selenium with Java or Python—to become a proficient automation test engineer.
This article explains the RIB (Router‑Interactor‑Builder) architecture for iOS, detailing its core components, how to generate and connect them with Xcode templates, manage navigation, inject dependencies, write unit tests with mock generation, and integrate the whole structure into a root RIB for a production‑ready app.
This guide explains how to structure a Maven project to run unit tests and integration tests separately, configure the Build Helper, Surefire, Failsafe, and JaCoCo plugins, and generate combined test reports that can be visualized in SonarQube.
This article explains how to construct a precise testing system for Java services by combining java‑callgraph for call‑graph extraction, Neo4j for graph storage, and Jenkins with Overmind for automated diff analysis and report generation, detailing architecture, tool setup, scripts, and integration steps.
This article outlines a five‑stage Laravel learning path, covering simple CRUD operations, database factories and seeders, form validation with request classes, browser automation testing with Dusk, and the application of design patterns to build robust backend applications.
This article explains how to extend the Moco mock server with custom delay handlers so that developers can simulate API responses that take longer than five seconds, including sample usage, wrapper methods, and the full implementation of a DelayHandler class in Java.
