This article explains why REST APIs have become cumbersome, introduces GraphQL as a more flexible alternative, and details its benefits, execution model, schema and type system, as well as practical server and client implementation options.
This article explains the limitations of traditional REST APIs, introduces GraphQL as a flexible alternative, details its core concepts such as schema, types, queries, mutations and subscriptions, and outlines various deployment architectures and implementation considerations for backend development.
This article examines the limitations of traditional REST APIs, explains how GraphQL offers a more flexible, efficient, and declarative approach to data fetching, outlines its core concepts, schema design, type system, and deployment architectures, and provides guidance on integrating GraphQL into existing backend and frontend ecosystems.
This article explains the evolution and limitations of REST APIs, introduces GraphQL as a more flexible, declarative alternative, details its core concepts such as schema and type system, compares execution models, and outlines various backend integration architectures for adopting GraphQL.
This article examines the four major API architectural styles—RPC, SOAP, REST, and GraphQL—explaining how each works, their strengths and weaknesses, and the scenarios where they shine, helping developers choose the best fit for their projects.
This article compares the main HTTP API design styles—REST, RPC, and GraphQL—explaining their principles, typical code examples, and trade‑offs, and also discusses serialization formats such as protobuf and JSON, helping backend developers choose the most suitable approach.
This article compares the four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, strengths, weaknesses, and typical use cases, and provides guidance on selecting the most suitable style for a given project.
This article explains how REST’s coarse‑grained, redundant interfaces hinder front‑end efficiency, then introduces GraphQL as a flexible, declarative alternative that automatically adapts to changing data requirements, reduces API proliferation, and streamlines backend‑frontend communication.
This article explains how to test GraphQL APIs by illustrating request/response examples, outlining testing approaches, reviewing the official sgqlc Python client, and presenting a self‑developed GraphQL testing framework called graphy with its design and usage details.
San CLI UI combines a San‑based client, a Node.js/Express GraphQL server, and lowdb file storage, enabling custom routing, component enhancements, and a versatile plugin system—supporting widgets, configurations, tasks, and custom views—managed through ClientAddonApi and PluginManager with IPC communication.
This article examines four major API architectural styles—RPC, SOAP, REST, and GraphQL—detailing their mechanisms, advantages, disadvantages, and typical use cases, and provides guidance on selecting the most suitable style based on project requirements and constraints.
This article explains why REST APIs have become cumbersome, introduces GraphQL as a more flexible alternative, describes its core concepts such as schema, types and modifiers, and outlines various server‑side and client‑side integration patterns and tooling options.
The article explains how the rapid growth of API endpoints and data fields in complex business scenarios can be mitigated by introducing a GraphQL middle‑layer built with Node.js, detailing schema design, resolvers, performance considerations, tooling, custom scalars, response formatting, caching, and security measures.
The article details OkCupid’s year‑and‑a‑half migration from a REST API to a production GraphQL API, describing the four‑step process—page selection, schema construction, shadow requests, and A/B testing—along with lessons learned about error handling, business‑logic placement, and performance monitoring.
This article introduces GraphQL as a modern API definition model, explains how to design schemas and queries, outlines its key characteristics such as precise field selection, single‑request data retrieval, front‑back end decoupling, and compares its advantages and drawbacks with traditional RESTful interfaces.
This article walks through a practical approach for front‑end engineers to cut down a sluggish legacy API from over three seconds to under a second by adding a Node.js proxy layer that leverages GraphQL field selection, Redis caching, and a scheduled cache refresh.
This article offers a concise, scenario‑driven introduction to GraphQL, explaining what it is, how it differs from REST, its data‑graph approach, and illustrating usage with sample schema and queries, helping developers quickly grasp its core concepts without diving into detailed implementation.
This weekly roundup curates essential front‑end insights, covering technical debt, the 7GUIs benchmark, SvelteKit updates, GraphQL debates, Adobe XD integration, adapter design pattern deep‑dive, enterprise data‑visualisation challenges, CodeSandbox tricks, quirky JavaScript quirks, open‑source tools, CSS Houdini breakthroughs, and a host of other cutting‑edge resources for developers.
This article explains what GraphQL is, how its type system and Relay standard work, the N+1 problem, and presents three architectural approaches—prefixing, schema stitching, and RPC composition—for integrating GraphQL into microservices, along with authentication, authorization, and routing considerations.
This article analyzes the shortcomings of the existing RESTful Node BFF service for Qunar's domestic hotel platform—such as data customization difficulty, manual documentation, and redundant fields—and demonstrates how adopting GraphQL can provide precise data fetching, automatic schema documentation, and unified request composition to improve development efficiency and system performance.
This article explains the limitations of traditional REST APIs, introduces GraphQL as a more flexible alternative, compares their advantages, and provides a detailed guide on GraphQL concepts, schema design, server‑client architecture, supported operations, and popular tools for implementation.
This article explains the limitations of traditional REST APIs, introduces GraphQL as a flexible alternative, compares their architectures, and outlines how GraphQL’s schema‑driven approach simplifies data fetching, reduces redundancy, and integrates with existing backend services.
This article explains the limitations of traditional REST APIs, introduces GraphQL as a flexible alternative, and details its core concepts, type system, server‑client architectures, deployment options, and popular tools and services for modern backend development.
The article surveys the most significant software‑architecture trends of 2020—including micro frontends, AsyncAPI, data mesh, policy‑as‑code, serverless, low‑code/no‑code, and GraphQL—highlighting expert opinions, adoption status, and the ethical considerations shaping modern distributed systems.
This article explains what GraphQL is, why it was created, how it differs from RESTful APIs, and the advantages of its schema‑driven, flexible data fetching model for modern mobile and web applications.
Kong’s Insomnia Designer adds a collaborative, spec‑first environment for designing REST and GraphQL APIs, integrates CI/CD, GitOps, and Kubernetes, and embeds Kong gateway policies directly into API specifications, boosting productivity for cloud‑native development.
This article explains GraphQL's origin, its five core design principles, how a GraphQL server is structured, and compares its single‑endpoint, type‑safe approach to traditional RESTful APIs, highlighting performance and developer‑experience advantages despite higher initial setup costs.
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 article compares REST and GraphQL, outlining their architectural origins, endpoint structures, issues of over‑ and under‑fetching, versioning challenges, and demonstrates how GraphQL’s single‑endpoint, client‑driven queries can provide more precise data retrieval while reducing the need for multiple API versions.
This week’s Front‑End roundup covers a visual page‑builder design, Canvas‑based image filters, a Vue vs React comparison, a 2019 technology review, Airbnb’s large‑scale GraphQL migration, and the latest ES2020 JavaScript features, each with concise insights and illustrative images.
The Gaode App full‑chain dependency analysis system parses source code across JS, C++, Android and iOS into ASTs, extracts forward and reverse dependencies, stores them for GraphQL queries, and uses the data to guide regression testing, API deprecation, migration trends, and package‑size optimization, improving codebase governance.
This article presents ten GraphQL principles—grouped into integrity, agility, and operations—that guide the design, evolution, and secure large‑scale deployment of a unified data‑graph layer, emphasizing a single schema, collaborative implementation, schema registries, performance monitoring, and structured logging.
Facing tangled microservice calls and heavy front‑end data stitching, Fangdd’s engineering team evolved from monolithic PHP to a multi‑layered microservice architecture, introducing Duo‑GraphQL to unify data via GraphQL providers, a BFF layer, and optimized engine, dramatically improving development speed and performance.
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 predicts the 2020 programming landscape, highlighting Rust's rise to mainstream, the continued growth of GraphQL, the surge of Progressive Web Apps, the bright future of Web Components, React's dominance, and JavaScript's decade-long reign, supported by data and industry observations.
This article examines why GraphQL naturally emerges for complex front‑end data needs, details its language design, architecture, resolver middleware, mocking strategies, and various deployment patterns such as API‑gateway and BFF, offering practical guidance for building scalable GraphQL services.
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.
This article explains what GraphQL is, how it solves common REST API problems, details its request structure, schema, type system, fragments, aliases, interfaces, unions, and resolvers, and provides a step‑by‑step tutorial for creating a GraphQL server using ThinkJS, MongoDB, and Apollo Server, while also outlining its advantages and drawbacks.
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 compares REST, gRPC, GraphQL, and Webhooks, explaining the scenarios each is best suited for and helping developers decide which API design approach matches their project's performance, flexibility, and integration requirements.
Xianyu introduced a lightweight data‑aggregation service and adopted Alibaba’s TQL GraphQL gateway, allowing front‑ends to fetch multiple domain data in a single request, which cut development costs by over 50%, reduced latency, and accelerated page composition across more than 30 pages.
GraphQL, created by Facebook in 2012 and open‑sourced in 2015, offers a flexible, efficient alternative to REST by allowing clients to request exactly the data they need, reducing redundancy, cutting request counts, and simplifying API evolution, with practical Node server and Apollo client implementations illustrated.
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.
The 2017 JavaScript State of the Nation survey of 23,000 developers uncovers the rise of React, shifting roles of Angular and Vue, salary‑driven technology choices, the surge of GraphQL and TypeScript, and how JavaScript is expanding far beyond the browser into back‑end and IoT.
Explore the 2018 JavaScript landscape, from Vue’s rising popularity and React’s Next.js ecosystem to emerging tools like GraphQL, Storybook, and WebAssembly, while uncovering essential learning resources and why developers should adopt these trends to stay competitive.
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.
Based on responses from over 23,000 developers, this survey uncovers the latest JavaScript ecosystem trends—including the dominance of React, the evolving roles of Angular and Vue, rising interest in GraphQL, salary impacts of framework choices, and the expanding use of JavaScript beyond the browser.
This tutorial walks through creating a lightweight blog using React, Next.js, and Cosmic.js GraphQL, covering environment setup, dependency installation, package configuration, core component implementation, and sample GraphQL queries to fetch and display posts.
This article explains why GraphQL addresses key limitations of REST APIs—reducing round‑trips, improving client‑server decoupling, and enhancing developer experience—while also discussing its flexibility costs, security concerns, caching strategies, and practical code examples comparing both approaches using a Star Wars data scenario.
Learn how to replace RESTful endpoints with a GraphQL service by creating a Hacker News API in Go, covering core concepts, type and field definitions, query and mutation setup, and essential resolver implementations illustrated with complete code examples.
The article explores the rise of experience APIs and Backends for Frontends, discussing how microservice architectures, API facades, custom payloads, media types, Prefer headers, and GraphQL can be used to tailor APIs for diverse client platforms while weighing the trade‑offs for small versus large teams.
GitHub introduced a GraphQL‑based public API to overcome REST’s scalability and flexibility limits, allowing clients to specify exact data needs, reduce network overhead, and combine multiple queries into a single request, while offering features like batching, subscriptions, and data latency control.
This article explains how GraphQL’s schema and type system model complex business data, and how its query language lets front‑end developers freely compose and customize data requests, covering core components, scalar and advanced types, queries, fragments, directives, and practical code examples.
This article explains why traditional front‑end/back‑end data coupling leads to duplicated effort, introduces GraphQL as a solution, and provides a step‑by‑step guide to creating a Node.js GraphQL server, defining schemas, handling queries, mutations, and extending the API for flexible, reusable data retrieval across multiple business scenarios.
