This article demystifies cloud‑native infrastructure by clarifying common misconceptions, defining its core principles—API‑controlled, software‑managed resources aimed at running applications with minimal human intervention—and outlining its benefits, implementation steps, and the mindset shift required for modern operations.
This article guides Java developers on creating a comprehensive interface testing project using the FunRequest framework, covering reusable utilities, request/response handling, and detailed code examples for HTTP GET and POST operations, while also providing links to related tutorial videos.
This article introduces FastAPI, a modern high‑performance Python web framework, walks through installation, basic routing, async handling, query and path parameters, data modeling with Pydantic, template rendering with Jinja2, and compares its speed to Flask, providing complete code examples and screenshots.
This article provides a comprehensive guide to Java's reflection mechanism, covering its definition, core capabilities, practical code examples, common API usage, and considerations such as performance and security, enabling developers to understand and apply reflection effectively in real-world projects.
This article explains the fundamental principles of REST architecture, describes the main HTTP verbs and response codes, compares REST with SOAP, introduces the Richardson maturity model, and surveys common description languages, server frameworks, and client tools for building and consuming RESTful APIs.
This article introduces a Spring Boot API project seed that combines MyBatis, a generic Mapper plugin, and PageHelper, offering a ready‑to‑use project structure, unified response handling, exception processing, code generation tools, and simple signature authentication to accelerate backend development.
This article explains the design of Java's time system, covering the epoch start, offset representation, timezone handling, historical changes, and the modern Java 8 date‑time API with practical code examples and usage guidelines.
This guide explains how to integrate WeChat OAuth2.0 login into Android and iOS mobile applications, covering preparation, the authorization code flow, token exchange, user‑info retrieval, phone‑number binding, repeated login handling, and comprehensive test cases.
This article walks through creating a Go‑based multi‑cloud management platform by leveraging each cloud provider's open APIs, demonstrating how to use curl and Go HTTP requests to query Tencent Cloud's DescribeRegions endpoint, generate the required signature, and integrate the results into a unified dashboard, reducing operational overhead across diverse cloud environments.
This article provides a comprehensive overview of REST architecture, covering its core concepts, differences from SOAP, the Richardson Maturity Model, detailed explanations of HTTP verbs and response codes, resource identification standards, description languages, server frameworks, and client tools for building and testing RESTful APIs.
This article compiles a comprehensive list of over fifty free, unlimited-use API interfaces covering phone number lookup, historical events, stock data, weather forecasts, ID verification, jokes, currency exchange, and many other services, each with direct documentation links for developers.
This article details UCloud's engineering of API and SDK management—including unified modeling, code generation, automated testing, and CI/CD pipelines—to dramatically improve the stability, reliability, and release efficiency of its public cloud services.
This article introduces an open‑source, four‑layer CMDB designed for operations teams, detailing its storage, data, API, and UI layers, dynamic modeling capabilities, searchable CI APIs, various resource views, relationship mapping, and role‑based permission management, while providing deployment links and usage notes.
This article compiles a comprehensive collection of free, unlimited-use API interfaces across various categories such as phone number lookup, weather, stock data, and more, providing direct URLs for each service to help developers quickly integrate external data sources.
This article explains Java 8's commercial licensing, highlights Java 11's performance gains, outlines major language and API enhancements from Java 8 to 11, provides code examples, discusses HTTP client usage, removed components, container support, and recommends Amazon Corretto as a free JDK alternative.
This article examines GraphQL’s emergence since its 2015 open‑source release, outlines its five core design principles, contrasts its single‑endpoint, client‑driven architecture with traditional RESTful APIs, and demonstrates practical query and response examples to highlight performance and developer‑experience advantages.
This guide lists Jenkins REST API endpoints for project management tasks such as retrieving information, creating, disabling, enabling, deleting, and building jobs, and demonstrates how to wrap HTTP requests with the httpRequest step in a Jenkins pipeline using authentication tokens.
This article walks through a complete performance‑testing setup for a VIP purchase callback API, detailing the request flow, distributed‑lock handling with Redis, parameter generation using AtomicInteger, Java implementation, and pitfalls to ensure accurate, high‑concurrency testing.
This tutorial introduces Java 8's new date‑time API, explains why the old java.util.Date and SimpleDateFormat were problematic, and demonstrates immutable, thread‑safe classes like LocalDate, LocalTime, LocalDateTime, ZoneId, YearMonth, and Instant through clear, runnable code snippets.
This article explains how to standardize backend API responses by defining a JSON result format, using HTTP‑like status codes, creating a Result wrapper class, and applying a custom @ResponseResult annotation together with a Spring interceptor and ResponseBodyAdvice to automatically wrap controller outputs for cleaner, more maintainable code.
This guide introduces Elasticsearch fundamentals—including its core concepts, main features, and essential terminology—followed by step‑by‑step Docker setup and practical API commands for creating, indexing, searching, and managing documents in a single‑node cluster.
This tutorial demonstrates how Java 8's new immutable, thread‑safe date‑time API (java.time) can be used to obtain the current date, extract year/month/day, create specific dates, compare dates, handle time zones, format and parse strings, and perform common date‑time calculations with clear code examples.
This article introduces five relatively unknown testing tools—including Endtest, Postman, Apache JMeter, Grabber, and Litmus—detailing their key features and how they can help improve automation, API, performance, security, and email testing workflows.
This article explains how to scrape all of your Zhihu saved collections using a Python crawler, store the data in JSON files, and then serve it through a Flask backend API and a Vue.js single‑page front‑end, complete with screenshots and full source code.
The article outlines how OpenWhisk’s serverless execution model supports diverse use cases—including microservices, web and mobile back‑ends, IoT pipelines, API services, data processing, and cognitive applications—highlighting its modularity, language flexibility, automatic scaling, and integration with cloud services.
This tutorial walks through creating an end‑to‑end Zhihu hot‑list project that scrapes the billboard page, stores the data with Flask‑SQLAlchemy, schedules periodic updates, exposes RESTful APIs, and finally displays the results in a uni‑app mini‑program with interactive charts.
This guide introduces Python’s Requests library, covering installation, GET and POST requests, handling headers, response codes, cookies, redirects, timeouts, and proxy settings, with practical code examples to help developers perform reliable HTTP operations and avoid common pitfalls in web scraping.
This guide demonstrates how to use Zabbix's API with Python to retrieve host information, item IDs, historical and trend data, process the metrics, and automatically write them into an Excel/CSV file, enabling scheduled monitoring reports.
This article explains how to design a standardized JSON response format, define status codes and messages, and implement a global @ResponseResult annotation with interceptors and ResponseBodyAdvice in Java to simplify controller return values and improve error handling.
This guide shows how to use Baidu's AI speech synthesis service with Python, covering SDK installation, app creation, obtaining credentials, and sample code to convert text—including daily quotes from an external API—into audio files, even customizing voice styles.
Vue 3 replaces Vue 2’s Object.defineProperty reactivity with a Proxy‑based system, using the Composition API (e.g., a reusable usePosition hook) to create reactive state, cache proxies via WeakMaps, differentiate array additions from length changes, and track dependencies through effect stacks for efficient updates.
This article explains why the legacy Date and SimpleDateFormat classes are problematic, introduces Java 8's immutable LocalDate, LocalTime, LocalDateTime and Instant classes, demonstrates thread‑safe creation, formatting, parsing, modification and calculation, and shows practical SpringBoot integration examples.
This article explains the REST architectural style, its basic concepts, differences from SOAP, the Richardson maturity model, HTTP verbs, response codes, resource specifications, popular implementations, client tools, and recommended books for building robust web APIs.
The interview with W3C China General Manager Wu Xiaoqian at Tencent's Front‑End Technology Conference explains the origins, syntax, tooling, and future of WebIDL, showing how this language‑neutral interface description helps developers and browser engineers create consistent, standards‑based Web APIs.
This article explains how Huawei's IoT platform enables device management, fault monitoring, and data analysis through three development approaches—API, SDK, and a visual SaaS service—while also detailing server deployment options and useful testing tools.
The article explains how to improve system scalability through hardware and software architecture enhancements, defines idempotency and its importance for preventing duplicate processing, and describes a practical implementation using unique request identifiers to ensure consistent responses for repeated API calls.
This article introduces Java 8's new date‑time API, explains the shortcomings of the old java.util.Date classes, and provides practical examples for using Instant, LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Duration, Period and DateTimeFormatter in real projects.
This article explains why front‑end/back‑end separation is needed, describes the evolution from MVC to SPA, and provides detailed API design rules, request/response formats, and implementation steps to achieve a clear, maintainable, and efficient development workflow.
This article explains why commercial calculations should use Java's BigDecimal for exact decimal arithmetic, details its structure, shows how to construct instances safely, covers common API methods, rounding modes, number formatting, and provides practical code examples.
This tutorial demonstrates how to create a Spring Boot project, define a GraphQL schema, implement data fetchers, expose REST endpoints, and query book data using GraphQL, highlighting the advantages of GraphQL over traditional REST APIs.
This article explains how to test a probabilistic lottery API where the winning chance increases with consecutive losses, outlines the required interfaces, discusses two large‑scale testing approaches, and highlights the challenges of ensuring correctness without consecutive wins.
This article demonstrates how to use Java HttpClient to call the free JD.com Wanxiang news channel API, providing a fully commented implementation, response handling methods, and a sample JSON output for developers who need a clear, unwrapped example.
This guide shows how to replace outdated GET calls with a POST request to the Turing Robot API using Java's HttpClient, explains recent changes to the service, and provides a full, ready‑to‑run code example for retrieving chatbot replies.
This article explains the concept of idempotency, lists common solutions, and demonstrates a practical implementation using Spring Boot, Redis, and a token‑based mechanism with custom annotations and interceptors, including full code examples, testing steps, and important pitfalls to avoid.
This guide shows how to extend Moco with a custom RandomHandler that selects one of several predefined responses at runtime, providing full Java code, helper methods, and a usage example for building more realistic mock APIs.
This article explains how to extend the Moco API with a custom LimitHandler to restrict request frequency, provides the Java implementation of the handler, and demonstrates several overloads for configuring default and custom intervals for rate limiting in backend testing scenarios.
Electron 6.0.0 introduces updated Chromium 76, Node.js 12.4.0, V8 7.6, extensive Promise‑based API enhancements, new helper app signing requirements, deprecation of the 3.x.y line, and outlines future release plans, providing developers with the latest JavaScript features, performance improvements, and security fixes.
This article provides a complete Java HttpClient implementation for sending push notifications through AlertOver’s API, including JSON payload construction, request execution, response handling, and highlights potential integration tips for production environments.
Electron 6.0, the newest stable release, brings Chromium 76, Node.js 12.4, V8 7.6, enhanced Promise support, async dialog APIs, new shell.showItemInFolder, and numerous API improvements such as excludedFromShownWindowsMenu, all_frames support, Linux preview, Touch ID, and more, all installable via npm.
This article shares practical experience using the Python wxpy library to automate WeChat, detailing outdated API challenges, custom wrapper functions for friends, groups, message recall, image sending, and Turing chatbot integration, along with code snippets and logging tips.
The Kubernetes 1.15 release introduces 25 enhancements—including stable, beta, and alpha features—focused on sustainability, API extensibility, admission webhook improvements, cluster lifecycle stability, CSI storage advances, and deprecations, providing a comprehensive overview of the new capabilities and updates.
This article demonstrates how to query SonarQube web APIs for Java rule data, retrieve quality profile information, and use a Python script that leverages execjs to translate rule descriptions via Google Translate, providing examples of both API responses and translation code.
This article introduces GraphQL as a query language for APIs, explains its history, shows how to define a schema and resolvers with graphql‑js, demonstrates query execution, error handling, built‑in types, and presents useful development tools such as GraphiQL and graphql‑import.
JD Chain, JD Digital Technology’s open‑source blockchain engine announced in 2019, offers enterprise‑grade features such as modular cryptographic algorithms, pluggable consensus protocols, key‑value ledger model, flexible storage, and comprehensive APIs, aiming to accelerate blockchain adoption across diverse business scenarios.
The article explains how modern enterprises can achieve adaptive integration by applying Gartner's Pace‑Layered architecture, categorizing applications into record, differentiation, and innovation layers, and using Microsoft services such as Azure Service Bus, Logic Apps, and BizTalk to manage governance, change control, and messaging across these layers.
The article introduces Service Mesh Interface (SMI), a lightweight standard for Kubernetes service meshes, explains its design goals, details the core API objects for traffic specification, access control, traffic splitting, and monitoring, and reviews the ecosystem of vendors and contributors supporting the specification.
The article shares Ctrip Hotel’s practical experiences and lessons learned while developing multiple mini‑programs (WeChat, Alipay, Baidu, Toutiao), covering product‑development collaboration, UI constraints, webview login handling, QR‑code strategies, “black‑tech” workarounds, and cross‑platform conversion tools.
This article explains a practical circuit‑breaker design for backend services, detailing detection logic, algorithm thresholds, time‑window statistics, recovery duration, manual overrides, a global switch, and how to monitor the breaker’s current state using Redis.
Cloud Call lets WeChat Mini Programs invoke most server‑side APIs with a single line of code by automatically handling access‑token acquisition and refresh, so developers can directly call functions such as templateMessage.send without managing credentials, while benefiting from the broader cloud development platform’s serverless resources.
Android Q brings a comprehensive set of enhancements—including stronger privacy controls, refined location permissions, shared shortcuts, a settings panel API, dynamic depth imaging, new audio/video codecs, native MIDI support, and ART performance improvements—designed to empower developers and improve user experience across a wide range of modern mobile devices.
The article introduces Octopus, the core automation service of 58 Group, detailing its overall architecture, the Octopus Agent lifecycle, communication mechanisms, management center capabilities, and key functional modules such as server information collection, command execution, deployment, permission control, and file transfer.
This tutorial walks through setting up a personal WeChat account, registering a public account, configuring an Nginx server on a public‑IP host, verifying WeChat signatures with Python, and implementing simple text, image, and QR‑code interactions using the official API.
This article explains what JavaScript Promises are, their immutable states, advantages and drawbacks, details the constructor, instance and static methods, provides code examples, and walks through the source implementations of resolve, reject, all, and race.
Microservices are isolated, loosely‑coupled units that solve single concerns, offering teams independent tooling, rapid iteration, and easier scaling; this article explains their principles, design considerations, challenges such as data sharing and dependencies, and provides a practical Node.js example with deployment tips.
This article explains the origins and problems GraphQL solves, describes its core concepts and advantages, and provides step‑by‑step instructions for integrating GraphQL into a Vue front‑end with Apollo as well as setting up a simple Node.js GraphQL server, complete with code examples.
This article introduces the Fiddler Mock Interface plugin, explains its background for API mocking during testing, details its one‑click features, UI additions, right‑click menu actions, color‑coded status indicators, and provides a step‑by‑step demonstration of mocking JSONP interfaces for front‑end developers.
This article demonstrates how to retrieve jokes from a free online API using Python, provides the same functionality in C#, shows the expected results, and includes links to the original API documentation for further exploration.
The article explains why consumer‑driven contract testing is essential for API and microservice development, describes how Spring Cloud Contract automates contract generation, stub creation, and testing for both providers and consumers, and provides practical tips, configuration details, and example contract formats.
This article examines the challenges of entrenched banking legacy systems—regulatory constraints, costly replacements, data migration delays, low developer morale, and file‑dependency bottlenecks—and details a practical API‑centric microservice solution built with Spring Cloud, DevOps tooling, and domain‑driven design to accelerate client onboarding, improve agility, and pave the way for cloud deployment.
This article explains how to build a simple WeChat auto‑reply robot in Python using the itchat library, integrate it with the Turing chatbot API, and handle message sending, receiving, and login persistence with concise code examples.
Front‑end developers often suffer from constantly changing back‑end APIs, outdated documentation, and testing that only starts near release, but by treating API specifications as contracts, using tools like Raml‑Mocker to generate mock servers and automate testing, teams can reduce rework, raise interface design quality, and streamline delivery.
This article explains the OAuth protocol, its role in providing secure third‑party access to user resources, describes the overall authorization architecture, outlines the involved parties and step‑by‑step flow, and details the four main grant types along with token refresh mechanisms.
Microservice architecture, likened to the human body's independent systems, breaks monolithic applications into loosely‑coupled, high‑cohesion services with isolated data stores and well‑designed APIs, enabling flexibility, scalability, and continuous delivery, while requiring careful scope definition, automation, monitoring, and handling of added DevOps complexity.
This article provides a comprehensive Java tutorial for accessing Baidu's OCR service, covering prerequisite setup, Maven dependencies, token acquisition, image-to‑Base64 conversion, HTTP request construction, and performance observations for Chinese, English, and mixed‑language image recognition.
This tutorial walks through building a Weibo monitoring tool in Python by simulating mobile login, extracting API endpoints, fetching user posts via JSON, handling containers, and implementing a session‑based class that polls for new tweets and sends email alerts.
Microservices decompose applications into small, autonomous services, offering advantages such as independent deployment, scalability, and technology diversity, while introducing challenges like operational complexity, DevOps demands, and governance, and the article compares them to monolithic architectures, discusses communication patterns, API design, and supporting infrastructure.
REST, an architectural style defined by Roy Fielding, structures web APIs around resources identified by URIs, exchanged as representations, and manipulated through stateless, uniform HTTP methods that enforce constraints such as client‑server separation, caching, layered systems, and optional code‑on‑demand to ensure scalable, predictable interactions.
This guide walks you through detecting push support, registering a service worker, requesting notification permission, creating a PushSubscription with proper options, and sending the subscription data to a backend for later use, all using modern JavaScript APIs.
This article explains microservice architecture, contrasting it with monolithic systems, outlines its benefits, challenges, governance, communication patterns, and the role of containers and DevOps in enabling fast, low‑cost responses to change.
This article explains the shortcomings of hard‑coded exposure tracking in the Beike Zhaofang Android app, benchmarks industry practices, proposes a flexible API‑driven strategy, and provides a complete RecyclerView scroll‑listener implementation with a double‑ended queue to record precise card visibility durations.
This article introduces GitLab as a powerful open‑source version control platform and explains how its comprehensive API can be leveraged to automate tasks such as branch creation, code commits, and project monitoring, enabling continuous integration and workflow management for development teams.
This article provides a step‑by‑step tutorial on deploying trained deep‑learning models to production, covering client‑server architecture, load balancing with Nginx, using Gunicorn and Flask, cloud platform choices, autoscaling, CI/CD pipelines, and additional tools such as TensorFlow Serving and Docker.
This article provides a detailed overview of JDK 10’s new features, including the twelve JEPs such as local‑variable type inference, expanded class‑data sharing, new APIs, JVM and language specification updates, and highlights the impact of these changes for Java developers.
The article argues that programmers who spend most of their careers developing on Linux tend to advance faster than those confined to Windows, citing differences in open‑source availability, API complexity, learning curves, and the ability to study superior architecture and design patterns.
This article explains what APIs are, outlines various API types—including web service, source code, hardware, and WebSocket APIs—and discusses their browser compatibility challenges, such as deprecated SDK methods, REST method support, and cross‑origin issues, offering practical tips for developers to ensure reliable API integration.
This article introduces JavaScript’s Proxy object, explains its core concepts—targets, handlers, and traps—and demonstrates practical uses such as property validation, data binding, and wrapping RESTful API calls with code examples, highlighting its versatility for developers.
This guide explains how to configure the Python environment and use the jenkinsapi library to interact with Jenkins, detailing class constructors, method signatures, parameters, and common operations such as retrieving job information, managing builds, and controlling jobs.
This article compares quick apps and WeChat mini programs across usage scenarios, entry points, API differences, component implementations, styling, event handling, static resources, and version constraints, highlighting how quick apps offer a more native‑like experience while leveraging front‑end technologies.
Learn how to design and implement a robust proxy IP pool for distributed web crawlers using Python, Flask, and SSDB, covering proxy acquisition, quality testing, storage, API services, scheduling, installation, and usage examples to ensure fast and stable crawling.
The article argues that, in most cases, developers who work on Linux gain skills faster than those who stay on Windows because of richer open‑source resources, fewer APIs to master, and easier access to high‑quality reference implementations.
Learn how to set up a personal WeChat public account, configure a public platform test server on Alibaba Cloud, verify messages via Python and Tornado, and implement basic text, image, and QR‑code interactions using the official WeChat API, complete with code snippets and configuration details.
This article explains Java's String class, covering its automatic import, how to create string objects without the new keyword, concatenation, immutability, common methods like replace, and provides useful API references and code examples for practical use.
This comprehensive guide walks you through installing the SpeechRecognition library, choosing a suitable Python package, handling audio files and microphones, and using the Recognizer API to convert spoken English into text while addressing noise, offsets, and advanced options.
This article explains what libvirt is, its role as an open‑source virtualization library and API, the hypervisors and tools it supports, its daemon architecture, the main API groups, and how client‑server connections are established for managing KVM‑based virtual machines.
This article combines humorous blockchain anecdotes with a clear, illustrated explanation of blockchain fundamentals and a complete Python tutorial that walks you through creating a blockchain, implementing proof‑of‑work, exposing it via Flask APIs, and handling node consensus.
This tutorial shows how to wrap the jsonplaceholder REST service with a GraphQL layer in Go, covering data models, schema creation, resolver functions, server setup, and example queries with results.
This guide walks you through logging into Baidu Cloud, capturing the transfer API via browser dev tools, analyzing required cookies and parameters, constructing the proper request headers and URL, and programmatically extracting share information to automate file transfers using Python.
This article dissects the Go implementation of Ethereum’s eth.syncing API, explaining the Syncing method, the SyncProgress struct, how block synchronization statistics are gathered, and how different sync modes affect the returned values, all illustrated with real source code excerpts.
Learn how to build a functional blockchain in Python using Flask, covering environment setup, the core Blockchain class, block and transaction structures, a simple proof‑of‑work algorithm, RESTful API endpoints, node registration, and a longest‑chain consensus mechanism, complete with runnable code examples.
This guide introduces GraphQL’s core concepts, compares it with REST, explains queries, mutations, types, and scalar rules, and walks through practical examples using GitHub’s GraphQL API, including fetching user data, comments, and adding or removing reactions.
