REST
REST is an architectural style for distributed hypermedia systems that organizes interactions around resources and representations through constraints including a uniform interface, stateless communication, cacheability, and layered components.
Learn Go with Pocket-Sized Projects
REST is an architectural style that defines resources and interactions with them through uniform representations and HTTP semantics.
- How it is used
- Defines the HTTP-facing interface for creating and playing a word game through a service.
- How deep it goes
- Defines REST conventions and works through a creation route, JSON response, status codes, curl request, and handler test; defers deployment.
- Examples
- Uses POST /games, a JSON game response, curl output, and an httptest handler check.
- What you can do after
- Build it from scratch as a Go HTTP creation endpoint with a route, JSON response, status code, and handler test.
Read how Learn Go with Pocket-Sized Projects explains REST →
Rust Servers, Services, and Apps
REST is an architectural style for networked applications that models functionality as interactions with identifiable resources.
- How it is used
- Uses REST to expose course creation and retrieval to web or mobile clients over HTTP.
- How deep it goes
- Defines REST constraints and works through Actix routes, handlers, shared state, and tests; stops short of exhaustive failure testing.
- Examples
- Builds a health check and three course endpoints, then exercises creation with curl and retrieval with a browser and tests.
- What you can do after
- Build it from scratch: implement and test a small RESTful course service with Actix Web and in-memory state.
Building Web APIs with ASP.NET Core
REST is an architectural style for network-based applications that uses standardized operations and resource representations over a uniform interface.
- How it is used
- Guides the design of a board-game web API that exchanges and manipulates resource data through HTTP.
- How deep it goes
- Moves from HTTP method meanings and guiding constraints to ASP.NET Core configuration and response design, without dwelling on theory.
- Examples
- Uses a board-game API and ASP.NET Core response caching, CORS, and hypermedia responses as implementation contexts.
- What you can do after
- Apply it via ASP.NET Core to make a board-game API more RESTful and evaluate when REST’s fetching trade-offs warrant an alternative.
Read how Building Web APIs with ASP.NET Core explains REST →
The Design of Web APIs, Second Edition
The REST architectural style is a distributed-systems style that emphasizes stateless interactions, resource representations, layered components, and a uniform interface.
- How it is used
- Guides the design of HTTP-based programming interfaces that represent business capabilities for diverse consumers.
- How deep it goes
- Defines six architectural constraints and applies them to resources, methods, status codes, and data modeling, while deferring detailed implementation.
- Examples
- Uses product search, product deletion, CRUD operations, and message sending to demonstrate REST-oriented HTTP design.
- What you can do after
- Apply it via HTTP by identifying resources, selecting methods and status codes, and modeling operation inputs and outputs.
Read how The Design of Web APIs, Second Edition explains REST →
ASP.NET Core in Action, 3e
A RESTful API is a web API designed around REST constraints and resource-oriented HTTP interactions.
- How it is used
- Deploys REST as an HTTP API style for mobile apps, single-page applications, and other clients.
- How deep it goes
- Defines stateless HTTP interactions and maps common verbs to operations, but does not detail broader REST constraints.
- Examples
- Uses a C# MapGet route, HTTP verb mappings, and Postman, Rider HTTP Client, or Swagger UI for testing.
- What you can do after
- Apply it via ASP.NET Core minimal APIs by assigning resource operations to semantically appropriate HTTP verbs.
Building User-Friendly DSLs
A REST API is an HTTP-based interface whose resources and operations follow the constraints and conventions of Representational State Transfer.
- How it is used
- Uses HTTP resources to persist and transport AST data between a frontend editor and a backend.
- How deep it goes
- Implements one resource with GET and PUT, then defers broader API complexity while addressing JSON storage and AST references.
- Examples
- Demonstrates /contents, a persisted contents.json file, Express handlers, frontend fetch calls, and a serialized Rental AST.
- What you can do after
- Builds a minimal Express REST API that reads and writes JSON, then connects a frontend client to its resource.
Acing the CCNA Exam: Volume 2 Advanced Networking and Security
Representational state transfer is an architectural style for distributed systems that models interactions around resources and their representations.
- How it is used
- Connects software applications and commonly supplies the SDN northbound interface for network automation.
- How deep it goes
- Defines six constraints and explains client-server and stateless behavior, while deferring detailed treatment of all six constraints.
- Examples
- Uses HTTP requests and responses, CRUD method mappings, response codes, SDN northbound communication, and Cisco Catalyst Center API calls.
- What you can do after
- Evaluate REST-based APIs using authentication, CRUD operations, HTTP verbs, data encoding, and response behavior.
Read how Acing the CCNA Exam: Volume 2 Advanced Networking and Security explains REST →
Apache Kafka in Action
REST is an architectural style for networked applications that represents resources and accesses them through stateless, uniform interfaces.
- How it is used
- Uses REST for request-driven service communication and for administering Kafka Connect connectors.
- How deep it goes
- Explains resource-oriented requests and works through connector operations, but does not develop REST's architectural constraints.
- Examples
- Demonstrates curl requests that create a customer-file connector, change its source path, and pause or restart it.
- What you can do after
- Operate/configure it through Kafka Connect's REST API to create, update, inspect, pause, resume, delete, and restart connectors.
Learn Docker in a Month of Lunches, Second Edition
A REST API is an HTTP interface that exposes resources and operations according to the principles of representational state transfer.
- How it is used
- Uses HTTP interfaces to expose and manage resources for applications, Docker components, and registries.
- How deep it goes
- Explains client-server interaction and practical request workflows, but does not detail REST constraints or HTTP semantics.
- Examples
- Demonstrates a cached NASA image service and registry operations for listing tags, reading manifests, and deleting images.
- What you can do after
- Apply it via Docker CLI workflows and documented registry requests to inspect and manage container resources.
Read how Learn Docker in a Month of Lunches, Second Edition explains REST →
Deep Learning with Python, Third Edition
- How it is used
- Deploys model predictions online through an API that consuming applications can access.
- How deep it goes
- Shows export and serving flows plus deployment-fit criteria, but does not detail REST request handling.
- Examples
- Uses Keras export and prediction flows for TensorFlow SavedModel and ONNX Runtime.
- What you can do after
- Apply it via Keras export() to prepare TensorFlow Serving or ONNX artifacts for online inference.
Read how Deep Learning with Python, Third Edition explains REST →
Deep Learning with R, Third Edition
A REST API is a web interface that exposes resources or operations through HTTP requests following REST architectural conventions.
- How it is used
- Deploys inference models as online prediction services for applications that can reliably access the internet.
- How deep it goes
- Explains exporting weights and computation graphs, then serving them through TensorFlow Serving or ONNX; it does not detail request schemas.
- Examples
- Demonstrates Keras SavedModel export, TensorFlow artifact loading, ONNX Runtime execution, and Posit Connect deployment.
- What you can do after
- Apply it via TensorFlow Serving, ONNX Runtime, or Posit Connect to expose a trained model for prediction.
Read how Deep Learning with R, Third Edition explains REST →
Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
A REST API is a web API that exposes resources and operations through HTTP according to REST architectural constraints.
- How it is used
- Explains how web applications expose resource operations and how AWS services are reached through HTTP APIs.
- How deep it goes
- Implements three Express routes and their AWS interactions, but leaves framework internals and broader REST constraints unexplained.
- Examples
- Uses S3 listing requests and an Imagery image-processing service with creation, status, and upload routes.
- What you can do after
- Apply it via Node.js and Express to build routes backed by DynamoDB and S3.
Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains REST →
Spring AI in Action
A REST service is a network service that exposes functionality or resources through REST-style HTTP endpoints.
- How it is used
- Deploys REST endpoints as the application boundary for submitting questions and returning AI-generated answers.
- How deep it goes
- Demonstrates endpoint implementation with Spring annotations, request records, dependency injection, service delegation, and JSON output.
- Examples
- Uses a POST /ask controller with Question and Answer Java records to demonstrate an AI-backed endpoint.
- What you can do after
- Build an AI-backed REST endpoint that accepts JSON questions and returns JSON answers through Spring components.
Kafka Streams in Action, Second Edition
A REST API is an HTTP-based interface that exposes resources and operations through conventional web representations and methods.
- How it is used
- Uses HTTP requests to register, inspect, and test schemas while developing Kafka producers and consumers.
- How deep it goes
- Explains request routing and Kafka-backed persistence, then demonstrates basic curl commands without detailing REST endpoint internals.
- Examples
- Demonstrates curl and jq commands for registering an Avengers Avro schema and retrieving subjects and versions.
- What you can do after
- Apply it via curl and jq to register schemas, list subjects, and retrieve schema versions.
Read how Kafka Streams in Action, Second Edition explains REST →
Latency
A REST API is an HTTP-based application programming interface that exposes resources and operations according to REST architectural constraints.
- How it is used
- Uses REST APIs to connect HTTP request handling with database access and quantify deployment latency.
- How deep it goes
- Builds a runnable endpoint, handler, database integration, and benchmark, but does not detail REST architectural constraints.
- Examples
- Uses a GET /hello endpoint backed by PostgreSQL or SQLite, then compares latency distributions with wrk and an eCDF plot.
- What you can do after
- Build it from scratch with Actix Web, connect PostgreSQL or SQLite, and measure endpoint latency with wrk.
Go by Example
REST is an architectural approach for designing networked resources and interactions through uniform operations, commonly over HTTP.
- How it is used
- Structures a maintainable HTTP microservice by separating REST handlers from core service logic.
- How deep it goes
- Explains REST through HTTP methods, handler boundaries, service calls, and API tests.
- Examples
- Uses a link-shortening API with POST-based shortening and GET-based resolution redirects.
- What you can do after
- Build it from scratch and test it with Go's standard-library http and httptest packages.
Data Pipelines with Apache Airflow, Second Edition
A REST API is an HTTP-based application programming interface that exposes resources and operations through stateless web requests.
- How it is used
- Uses REST APIs as external data sources and event-related inputs for Airflow workflows.
- How deep it goes
- Explains endpoints, authentication, parameters, response records, and request-size limits, but stops short of general REST design.
- Examples
- Demonstrates a Citi Bike API returning ride coordinates and timestamps through configurable recent-period endpoints.
- What you can do after
- Apply it via curl by authenticating, selecting an endpoint interval, and retrieving records for pipeline processing.
Read how Data Pipelines with Apache Airflow, Second Edition explains REST →
Pro ASP.NET Core 7, Tenth Edition
REST, or Representational State Transfer, is an architectural style for networked systems in which resources are identified and manipulated through representations and standardized operations.
- How it is used
- Provides application data to clients through HTTP endpoints, commonly supporting rich client-side applications.
- How deep it goes
- Defines the URL-and-method model and common verb conventions, but stops short of prescribing a complete REST specification.
- Examples
- Uses /api/products/1 to identify a product and GET, POST, PUT, PATCH, and DELETE to illustrate operations.
- What you can do after
- Build RESTful endpoints by pairing URLs with HTTP methods and selecting controller or minimal-API implementations.
Pro Angular 16
REST is an architectural approach for designing web services around resources, URLs, and HTTP operations.
- How it is used
- Uses HTTP requests and resource URLs to deliver application data through web services.
- How deep it goes
- Defines resource selection and HTTP operations, demonstrates standard combinations, and cautions that implementations vary without specifying a formal standard.
- Examples
- Uses products and orders collections, the /products/2 endpoint, JSON responses, and json-server middleware.
- What you can do after
- Apply via HTTP requests by selecting resource URLs, choosing verbs, and supplying JSON request bodies where required.
Digital Twins in Action
A REST API is a web interface that exposes resources and operations through HTTP methods and resource-oriented URLs.
- How it is used
- Uses REST to retrieve external satellite imagery and to expose digital-twin resources through HTTP endpoints.
- How deep it goes
- Works through a Python image request and a multi-request resource traversal, but does not develop a REST server.
- Examples
- Uses a NASA GIBS request for a Lake Kariba image and a second-floor temperature query across rooms, sensors, and measurements.
- What you can do after
- Apply it via Python requests to retrieve an image, and evaluate REST’s request-count tradeoff for related digital-twin data.
Investing for Programmers
A REST API is a web interface that exposes resources and operations through the conventions of the Representational State Transfer architectural style.
- How it is used
- Connects Python automation to Notion by creating pages and writing generated investment-research content.
- How deep it goes
- Explains payload construction, HTTP methods, status checks, identifiers, and chunked writes, but does not develop REST architecture broadly.
- Examples
- Uses Notion page creation, block updates, title properties, JSON dictionaries, and 2,000-character content chunks.
- What you can do after
- Apply it via Python requests to create resources, update content, validate responses, and handle service size limits.
Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more
A REST API is a network interface that exposes resources and operations through HTTP using representational state transfer conventions.
- How it is used
- Connects remote clients, scripts, CI/CD systems, GUI tools, and compose workflows to Podman containers.
- How deep it goes
- Defines socket activation, API modes, bindings, and SSH communication without detailing request formats.
- Examples
- Demonstrates docker-compose, Python bindings, podman --remote, and podman system connect workflows.
- What you can do after
- Operate remote Podman through REST clients, Python bindings, Docker-compatible tools, or SSH connections.
Related concepts
- HTTPuses · HTTP is a standardized application-layer protocol that defines request-and-response messages for transferring resource representations between networked systems.
- GraphQLalternative to · GraphQL is a query language and execution specification for APIs that lets clients request and manipulate data through a schema.
- gRPCalternative to · gRPC is an open-source remote procedure call framework for defining services and invoking them across process or network boundaries, commonly using Protocol Buffers and HTTP/2.
- web servicekind of · A web service is a programmatic software interface that exposes functionality or data through web technologies or network protocols, typically HTTP.
- schema registryused by · A schema registry is a service that stores, versions, and provides schemas for structured data, often validating compatibility between schema versions.
- stateless systemuses · A stateless system handles each operation without relying on state retained from prior operations, though state may be maintained externally.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.