This article introduces Moco, a Java‑based mock server tool, explains its purpose for early API testing and frontend development, provides step‑by‑step startup commands, showcases JSON request/response demos for various HTTP methods, outlines global configuration, and discusses its limitations.
This article compiles 17 essential Python interview questions covering basic syntax, type conversion, memory management, dictionary methods, lambda functions, os and sys modules, object copying, path handling, regex, generators, WSGI vs FastCGI, Django vs Tornado, debugging tools, Redis caching, unit testing, HTTP protocol fundamentals, request headers, and common status codes.
This article explains key networking concepts including the meaning and differences of HTTP 301/302 status codes, forward versus redirect mechanisms, TCP versus UDP characteristics, the TCP three‑way handshake, OSI layers, GET versus POST request distinctions, and multiple cross‑origin solutions such as JSONP, CORS, window.name, postMessage, and proxies.
This article provides a comprehensive overview of the HTTP protocol, covering its relationship with DNS/TCP/IP, request/response structure, methods, design principles, persistent connections, cookies, compression, caching, status codes, and the enhancements introduced in HTTP/2.
This comprehensive tutorial walks through capturing HTTP traffic with Wireshark and tcpdump, decodes raw TCP packets, explains request and response structures, explores encoding, MIME types, methods, status codes, and advanced topics such as proxies, caching, cookies, redirection, and connection management, giving developers a solid understanding of how HTTP works under the hood.
This article reviews five widely used JavaScript HTTP request libraries—Axios, Superagent, Request, Fetch, and Supertest—detailing their advantages, drawbacks, and typical use cases to help developers choose the most suitable tool for their projects.
The article explains step‑by‑step what occurs when a user types a URL, covering DNS resolution, browser caching, HTTP requests and redirects, server processing, HTML generation, resource fetching, compression, and asynchronous AJAX communication, using Facebook as a concrete example.
This comprehensive guide explains the HTTP protocol, covering its connection model, request and response message structures, common methods, URL components, version differences, header field categories, the request/response lifecycle, status code classifications, and the practical distinctions between GET and POST.
This article walks through the complete lifecycle of a web request—from entering a URL, DNS resolution, and HTTP communication, to server processing, HTML delivery, resource fetching, and AJAX interactions—explaining each step with diagrams and code examples.
This article explains how to build a lightweight Tomcat-inspired web server called MyTomcat, covering its socket service, request dispatching, HTTP request/response encapsulation, servlet mapping, and demonstrates the complete project structure with illustrative diagrams and code snippets.
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 article explains the RESTful architectural style, detailing its core constraints such as resource identification, representation, stateless state transfer, and the uniform interface, and compares REST with RPC while outlining Java frameworks and multi‑layer designs for building scalable backend web services.
This article explains the concept of FUZZ testing, describes its two main techniques, presents the design and core functions of a self‑developed FUZZ testing tool, showcases real‑world test results on SQL and HTTP interfaces, and outlines future enhancements for broader applicability.
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 article provides a thorough overview of the HTTP protocol, covering network architecture basics, the request/response model, detailed structures of request and response messages, and extra topics such as HTTP/1.1 vs HTTP/1.0, HTTPS differences, and long‑connection handling.
This comprehensive guide walks you through the core concepts of computer networking, including the OSI and TCP/IP models, detailed explanations of TCP and UDP protocols, HTTP fundamentals, socket programming, IP addressing, ICMP, ping operations, and the differences between routers, switches, cookies, sessions, and tokens.
This tutorial walks through using Python and browser developer tools to locate the NetEase Cloud Music comment API, extract encrypted request parameters, retrieve hot comments in JSON, and parse the Hot Songs chart to collect each song's name and ID with regular expressions.
Whistle is a Node.js‑based cross‑platform web debugging proxy that lets developers view and modify HTTP(S) and WebSocket traffic, offering features like host binding, request replacement, response status manipulation, script/style injection, and powerful mock data generation for front‑end development.
This article explains how to construct various HTTP response codes using a PHP script and how to emulate network anomalies such as TCP resets, packet loss, and latency with iptables and tc netem, providing practical techniques for robust backend testing.
This article explains how browsers handle CORS by distinguishing simple and non‑simple requests, the conditions that trigger a preflight OPTIONS request, the required Access‑Control response headers, and how server‑side implementations—such as Java interceptors—manage these interactions.
This article explains the fundamental differences between GET and POST requests, the dual TCP/UDP usage of DNS, the meaning of idempotence, the contrast between cookies and sessions, causes and solutions for TCP packet fragmentation, the three‑way handshake and four‑way termination, the complete HTTP request flow, long‑connection handling, TCP reliability mechanisms, detailed HTTP structure, the distinction between URI and URL, and how HTTPS secures data transmission.
This article explains the principle of HTTP pipelining, presents detailed performance tests comparing single‑thread, thread‑pool, and pipelined request methods, and provides a simple .NET implementation that demonstrates why pipelining can achieve ten‑fold speed gains over conventional HTTP keep‑alive.
This article explains the concept of HTTP pipelining, presents a series of performance tests comparing pipe, thread‑group, and asynchronous request methods on a typical PC, analyzes the results and underlying TCP behavior, and provides a simple .NET implementation for practical use.
This article explains the fundamentals of HTTPS by clarifying key terms such as HTTP, SSL/TLS, and encryption, describing how HTTP works over TCP, the differences between symmetric and asymmetric cryptography, and the core security requirements of confidentiality, integrity, authenticity, and performance.
This guide demonstrates how to programmatically log into the Super Schedule mobile app using Python, capture its JSON responses, and continuously fetch user-generated topics by mimicking the app’s HTTP requests, complete with sample code and request headers.
This article explains why plain‑HTTP traffic is vulnerable, outlines encryption tricks, describes file‑path traversal, DNS spoofing, proxy risks, HTTP error codes, POST data formats, cookie security, CSRF, XSS, JSONP, and CORS, and provides practical mitigation techniques for each threat.
This article explains how to create HTTP middleware in Go, covering request reading, trailing‑slash redirection, request‑ID injection, server header manipulation, custom ResponseWriter implementation, and handling of additional interfaces such as Push and Flush, with complete code examples.
This guide walks through creating Go middleware, showing how to read and modify requests, manage response headers with custom ResponseWriter implementations, handle edge cases like missing Write calls, and preserve additional interfaces such as http.Pusher and http.Flusher.
This article walks through using Python to log into CSDN, capture the dynamic Geek News list via its JSON API, handle request parameters, and extract article titles and links, providing concise code screenshots for a complete web‑scraping solution.
This article investigates an intermittent timeout issue caused by a Java Apache HttpClient implementation that leaks connections, explains why numerous RST packets appear during TLS shutdown, and presents experiments and code revisions that clarify the TCP/TLS interaction and proper resource handling.
This article explains how computers exchange data packets over the Internet, covering MAC and IP addressing, subnet determination, static and dynamic IP configuration via DHCP, DNS resolution, and the step‑by‑step construction of TCP, IP, and Ethernet frames for a web request.
This article explains what head‑of‑line blocking is in HTTP, why HTTP/1.1 suffers from it, how HTTP/2 over TCP mitigates request‑level blocking but not transport‑level issues, and how QUIC over UDP fully resolves the problem.
This article explains the fundamentals of the HTTP protocol, compares HTTP/1.0 and HTTP/1.1, details request and response structures, and demonstrates how to control browser behavior with various response headers using Java servlet examples.
This article explains the concept of asynchronous I/O, introduces Python’s provisional asyncio module, and walks through a complete example that creates an HTTP keep‑alive benchmark tool, including code, test environment, performance results, and key asyncio concepts such as event loops, futures, coroutines, and generators.
A comprehensive guide to common Linux operations interview questions, covering environment variables, TCP characteristics and handshake, proxy principles, TCP vs UDP trade‑offs, OOP vs procedural programming, HTTP request flow and status codes, deadlock concepts, TCP states, and inter‑process communication mechanisms.
This article explains the origins, core concepts, design principles, common misconceptions, and maturity levels of RESTful APIs, illustrating how resources, representations, HTTP verbs, and hypermedia (HATEOAS) together enable scalable, decoupled web services for modern client platforms.
This guide walks through curl’s syntax and options for fetching URLs, saving pages, handling cookies and headers, bypassing SSL verification, using proxies, performing POST requests, looping downloads, and FTP transfers, all illustrated with concrete command examples.
This article explains how using a POST‑then‑PUT workflow can prevent duplicate resource creation in HTTP APIs, illustrated with PayPal’s payment endpoint, and why this pattern offers a more reliable, idempotent solution for backend services.
This article compares HTTP/2 with its predecessor HTTP/1.x, detailing performance gains through multiplexing, binary framing, header compression, and server push, and explains the underlying mechanisms such as TCP behavior, binary frames, static and dynamic header tables, illustrating concepts with visual examples.
This article explains how web crawlers work—from initial URL seeding and request handling to flow control, content extraction, and handling dynamic pages—while covering essential modules, HTTP details, common obstacles like JavaScript rendering, anti‑scraping measures, and strategies for large‑scale, distributed crawling.
The article details a real‑world investigation of a surge of HTTP 406 errors on a Chinese e‑learning platform, tracing the issue to malformed Accept headers sent by a search‑engine crawler and illustrating how CDN routing and header negotiation can cause widespread client‑side failures.
This article presents a comprehensive, academically‑styled guide for designing a unified RESTful API, covering core concepts such as REST constraints, HATEOAS, security, idempotency, URL naming conventions, request/response structures, version control, and recommended implementation tools.
This article provides a comprehensive overview of the HTTP protocol, covering its connection model, request and response structures, common methods such as GET, POST, OPTIONS, detailed header fields across general, request, response, and entity categories, URL components, version differences, and status code classifications.
This article explains the complete web request lifecycle, breaks down each latency component, and details how various cache layers—from browser DNS caches to server‑side memory and disk caches—can be leveraged and tuned to dramatically speed up page loads.
This article explains hiproxy's core proxy mechanisms, including HTTP and HTTPS request handling, automatic certificate generation, plugin architecture, and browser proxy configuration, providing developers with a comprehensive overview of its implementation and extensibility.
This article walks through creating a Python blog website, covering project structure, HTTP workflow, ORM implementation, aiohttp web framework integration, and showcases the final UI screenshots, while reflecting on lessons learned and future learning needs.
This article explains how Node.js handles HTTP requests using an I/O multiplexing model, walks through a simple hello‑world server, examines connection and request events, discusses keep‑alive, Expect headers, proxying, and presents performance measurements comparing Node.js to a pure C implementation.
This article reviews various front‑end data exchange techniques—including HTTP methods, form encodings, AJAX, fetch, Server‑Sent Events, WebSocket, postMessage, and Web Workers—explaining when to use each, providing practical examples and code snippets for real‑world scenarios.
Server-Sent Events (SSE) provide a lightweight, HTTP‑based mechanism for real‑time server push, and this article explains its principles, compatibility, and step‑by‑step implementation—including a simple server that streams timestamps every second and a front‑end page that displays the incoming data.
This article explores TCP/IP fundamentals—including three‑way handshake, receive windows, congestion control mechanisms, and HTTP header limits—while demonstrating practical packet captures with tcpdump and building a simple WebSocket chat demo to illustrate protocol behavior and differences from WebRTC.
This guide explains how to use the curl command-line tool to fetch web pages, display or combine HTTP headers, save output to files, follow redirects, customize User-Agent and headers, manage cookies, and perform POST and GET requests with data, including examples for multiple file downloads.
This guide compiles eleven practical Python requests tips—including preserving cookies across calls, simplifying headers, adding retry logic, disabling redirects, sending JSON payloads, extracting debug information, performing asynchronous requests with grequests, customizing cookies, mocking APIs, measuring request time, and setting timeouts—to help developers write cleaner, more reliable HTTP code.
A poetic tale follows a programmer’s evolution from using shared memory for secret messages to mastering sockets, TCP handshakes, firewalls, and HTTP‑based web services, illustrating core networking concepts through a heartfelt metaphor.
This article presents a comprehensive guide to front‑end performance optimization, covering reduction of HTTP requests, proper handling of repaint/reflow, minimizing DOM operations, using JSON, efficient HTML/CSS, CDN acceleration, external resource loading, minification, image compression, and cookie management.
This guide dives deep into urllib2, covering proxy configuration, timeout handling, custom headers, redirects, cookies, PUT/DELETE methods, response codes, debugging logs, form processing, browser impersonation, and anti-hotlinking tricks, providing practical code snippets for each feature.
Discover the top ten Node.js REST API best practices—from proper HTTP verbs and status codes to JWT authentication, rate limiting, and effective documentation—offered by RisingStack engineer Gergely Nemeth, with real‑world examples like GitHub, Twilio, Stripe, and DigitalOcean APIs.
This article explains how to solve the problem of undefined results when making asynchronous HTTP requests in a Node.js microservice by passing a callback function that receives the response data and any error, allowing the data to be accessed outside the request handler.
This article introduces the WSGI specification, explains how WSGI servers and applications interact, details the application interface and environment handling, and provides practical examples for processing GET and POST requests in Python, helping beginners build their own web frameworks.
This article explains how load balancers act as the nervous system of web applications, compares hardware versus open‑source solutions, and details why HAProxy—especially in TCP (layer 4) mode—often outperforms Nginx for high‑performance reverse proxy and load‑balancing tasks.
This article explains the concept of communication protocols, defines HTTP and its security shortcomings, introduces HTTPS with its encryption mechanisms, compares their performance and cost implications, and clarifies common misconceptions, helping developers understand why HTTPS is essential for modern web applications.
This article introduces Node.js’s built‑in HTTP core module, explains its main classes and functions, and demonstrates how to create a simple HTTP server and a client in JavaScript, illustrating request handling, response generation, and data exchange between the two.
This article explains how Python's urllib and urllib2 modules differ and demonstrates practical techniques for sending HTTP requests, encoding query strings, setting custom headers, handling JSON payloads, managing cookies, and configuring proxies using Request objects and build_opener handlers.
This article explains the fundamentals of HTTP, covering client‑server interactions, page rendering flow, proxy roles, statelessness, request/response structures, common methods, limitations of HTTP/1.0, and the performance enhancements introduced by HTTP/2.
Although RESTful principles recommend using distinct HTTP verbs for CRUD operations, many developers still rely on GET and POST for creating, updating, and deleting resources, leading to non‑standard JSON APIs; this article explains the HTTP methods, their semantics, and why practical constraints often shape API design.
This article explains the purpose, classification, and detailed meanings of all HTTP status codes, helping developers interpret server responses and troubleshoot client‑server communication issues effectively.
This guide introduces the wrk HTTP load‑testing tool, explains its multithreaded and Lua‑scriptable architecture, walks through installation and command‑line usage, interprets key performance metrics, and demonstrates how to extend functionality with custom Lua scripts for advanced testing scenarios.
This tutorial walks you through installing, launching, configuring browser proxy settings, and creating rules with Whistle, a Node‑powered web debugging proxy, showing practical examples such as replacing a site’s logo and mapping directories to local files.
This guide explains why HTTP caching can be tricky, then provides concise, actionable rules for static assets and dynamic content, covering Cache‑Control, Expires, ETag, Last‑Modified, Vary headers, and how browsers handle refreshes to improve web performance.
This article explains the complete journey of a web request—from DNS lookup and TCP handshake through HTTP exchange, server processing, and browser rendering—while highlighting optimization techniques and the roles of front‑end and back‑end engineers.
This article walks through the design and implementation of a lightweight asynchronous Python web framework, covering its core components such as HTTPServer, HTTPConnection, request parsing, routing, timeout handling, and the App class, while explaining design choices, limitations, and testing strategies.
This article shares real‑world Node.js pitfalls—from unsafe decodeURIComponent usage and hidden Promise errors to unhandled HTTP request failures—explaining why they occur and providing practical code‑level solutions such as try‑catch wrappers and proper error event handling to keep applications stable.
This article traces the origin and development of URLs from Tim Berners‑Lee's 1992 invention of HTTP, HTML and the universal document identifier, through the standardisation of syntax, query strings, fragments and authentication, highlighting key proposals, code examples and the ongoing debates about their purpose.
This article provides a comprehensive overview of the HTTP protocol, covering its evolution from 0.9 to 2.0, the structure of request and response messages, common methods and status codes, header fields, MIME types, URI/URL distinctions, and the underlying mechanisms of web resource handling and concurrency.
This comprehensive guide walks through HAProxy's version landscape, connection and closing modes, load‑balancing algorithms, persistence, content routing, header rewriting, multiple configuration examples—including dynamic and multi‑process setups—and practical debugging tips, supplemented by a live Q&A session.
This article provides a comprehensive overview of HTTP, TCP, UDP, and socket communication, explaining protocol layers, request/response structures, key headers, and the differences between GET and POST methods for web development.
This article explains what HTTP cookies are, their historical origin, how they are created and managed via Set-Cookie headers, the meaning of options like expires, domain, path, and secure, as well as JavaScript handling, subcookies, HTTP‑Only flags, and common limitations.
This guide walks you through the essential concepts of building robust RESTful APIs—including request/response handling, serialization, validation, authentication, CORS, and URL design—so you can create secure, standards‑compliant services from scratch.
This article explains why a static‑file server can produce many TIME_WAIT connections, examines the role of the HTTP Connection and Keep‑Alive headers, and shows how different header settings affect when the server or client closes the TCP connection.
This article investigates the feasibility of improving Locust's HTTP request performance by replacing urllib3 with PycURL, explores protocol extensions, examines the impact of gevent's monkey patching, and concludes that the substitution does not yield significant gains despite a modest single‑user speedup.
In this whimsical interview, the aging Internet Explorer, Firefox, and Chrome discuss their rivalry, the evolution of browsers, how they fetch web pages via HTTP requests and responses, status codes, cookies, and the challenges of modern web technologies, offering a clear overview of web fundamentals.
Learn how HTTP caching works by leveraging the ETag response header, the If-None-Match request header, and Cache-Control directives to reduce bandwidth, improve performance, and control resource freshness across browsers and proxies, with practical examples and guidance on choosing appropriate caching strategies.
This comprehensive guide reviews the essential elements of HTTP requests and responses, explains version differences, clarifies the distinctions between HTTP, Socket, and TCP, and provides practical iOS implementation details for developers seeking a deeper understanding of web communication.
This guide introduces PHP's cURL extension, outlines its basic workflow, and provides clear GET and POST code examples, showing how to configure options, execute requests, handle responses, and decode JSON data into arrays or objects.
This article explains how to design a gray‑release solution for HTTP read interfaces by using either Nginx with embedded Lua scripts or a version‑aware gateway layer, detailing rule design, configuration handling, and the trade‑offs of each approach.
This article explains the purpose and structure of the HTTP protocol by using a narrative about two developers building a String utility class and a card validator, then mapping their method calls to the three steps of a web request, complete with code examples and protocol details.
This article explains the purpose and structure of the HTTP protocol, using a humorous story and Java code examples to illustrate request‑response mechanics, URL syntax, headers, and servlet interfaces, helping developers grasp how browsers and servers communicate over the web.
This article explains the HTTP protocol, outlines the purposes of GET and POST methods, details their characteristics, compares them across factors like caching, security, and data limits, and introduces additional HTTP methods such as HEAD, PUT, DELETE, OPTIONS, and CONNECT.
This article explains the purpose and proper use of HTTP 3xx redirect status codes—from 300 Multiple Choices to 307 Temporary Redirect—along with related caching headers like Cache-Control and ETag, highlighting differences, SEO implications, and how browsers handle each case.
This article walks through creating a Python 2.7 script that logs into Weibo, fetches red‑envelope lists, evaluates their value with a custom algorithm, and automatically claims them, covering required libraries, cookie handling, HTTP GET/POST functions, RSA encryption, and result logging.
From typing a URL to rendering a page, this article walks through each step—browser DNS lookup, HTTP request and response, redirects, server processing, content delivery, and asynchronous calls—revealing the complex interactions that make modern web browsing possible.
This article explains how HTTP relies on TCP/IP, clarifies the stateless nature of HTTP, and compares long and short connections—including their TCP handshakes, keep‑alive mechanisms, advantages, disadvantages, and appropriate usage scenarios for web and database communications.
This article explains how to effectively reduce server load and bandwidth by leveraging HTTP caching mechanisms such as Last-Modified, ETag, Expires, and Cache-Control headers, including practical servlet code examples and browser behavior details.
This article walks you through the philosophy of rebuilding software systems, explains what a network server is, and provides a detailed, hands‑on tutorial for creating a minimal Python web server, covering URLs, sockets, HTTP requests, and responses.
This article provides a comprehensive overview of the HTTP protocol, covering its versions, communication processes, request and response structures, header fields, entity body handling, status codes, and practical examples of content-length and chunked transfer encoding.
This article explains what RESTful APIs are, why they are essential for modern web and mobile development, and provides clear examples of common CRUD operations using standard HTTP methods.
This article explains the fundamentals of HTTP, covering its place in the TCP/IP stack, URL structure, request and response message formats, key header fields, and the differences between GET and POST methods, illustrated with practical examples and diagrams.
This article explains the steps from a client’s HTTP request to server response, analyzes performance bottlenecks such as TCP connection overhead, and presents practical browser‑side caching techniques—including Keep‑Alive, Last‑Modified/If‑Modified‑Since, ETag/If‑None‑Match, Expires, and Cache‑Control—to improve web site speed.
This article explains the fundamentals of HTTP and HTML, covering protocol definitions, request and response structures, header categories, methods, status codes, HTML document structure, static and dynamic generation, MIME types, URI/URL formats, and web server I/O models.
This article explains how HTTP relies on TCP/IP, clarifies the stateless nature of HTTP, and compares long‑lasting persistent connections with short‑lived ones, covering their handshakes, advantages, disadvantages, and appropriate usage scenarios.
This article examines server‑push technologies such as Comet, comparing plugin‑based socket approaches with HTTP long‑connection methods like AJAX long‑polling and iframe/htmlfile streaming, and provides practical guidance on building robust Comet applications using frameworks such as Pushlet.
