Client
A client is a person, organization, device, or software component that receives or uses a product, service, resource, or functionality provided by another party or system.
Apache Kafka in Action
A Kafka client is an application that connects to a Kafka cluster to publish, consume, or otherwise interact with Kafka data.
- How it is used
- Defines external applications that connect to Kafka brokers to write, read, or process data.
- How deep it goes
- Explains client roles, bootstrap metadata, and selected consumer behavior, while deferring fuller client mechanics.
- Examples
- Uses console producer and consumer commands to send price changes and read them independently, including from the beginning.
- What you can do after
- Operate/configure console clients with bootstrap servers and topic options, and recognize connection and monitoring concerns.
Kafka for Architects
A client is an application that communicates with a message broker to send or receive messages.
- How it is used
- Defines the applications that send events to Kafka brokers or consume them for independent processing.
- How deep it goes
- Explains client configuration and consumer workflows, including offsets and scaling, but stops short of detailed client API tutorials.
- Examples
- Uses address-change subscribers and a customer dashboard whose profile and transaction consumers can overwrite concurrent updates.
- What you can do after
- Operate/configure Kafka clients with justified choices about consumer groups, offset commits, and application-side processing.
Spring Security in Action, Second Edition
An OAuth client is an application that requests authorization and accesses protected resources on behalf of a resource owner.
- How it is used
- Deploys the client for user login or authenticated communication between backend applications.
- How deep it goes
- Explains actors, token flows, grant selection, and Spring configuration, stopping short of detailed OAuth 2 or OpenID Connect expertise.
- Examples
- Uses Google login, an invoices web application, a backend service, and a /token endpoint that returns a retrieved access token.
- What you can do after
- Build it with Spring Security for external-provider login or service-to-service token retrieval.
Read how Spring Security in Action, Second Edition explains client →
Learn Go with Pocket-Sized Projects
A client is a computer or software process that requests services or resources from a server over a network.
- How it is used
- Uses clients to retrieve exchange rates and call a habits service from tests and a frontend.
- How deep it goes
- Explains client configuration, timeout handling, and integration testing, without implementing an HTTP or gRPC client from scratch.
- Examples
- Uses an exchange-rate request, a delayed test server, and generated habits-service calls.
- What you can do after
- Apply clients via Go’s net/http and gRPC libraries to make requests, configure timeouts, and test service calls.
Read how Learn Go with Pocket-Sized Projects explains client →
The Well-Grounded Python Developer: How the pros use Python and Flask
A client is software or a device that sends requests to a server and receives its responses.
- How it is used
- Positions clients as applications that access server functionality, especially browsers assembling web pages through requests.
- How deep it goes
- Explains browser request–response behavior and session cookies, but stops short of a full HTTP protocol treatment.
- Examples
- Traces a browser requesting HTML and linked files, and mentions social networks and multiplayer games as client applications.
- What you can do after
- Evaluate/understand how a browser obtains and renders server responses and carries session information between requests.
Read how The Well-Grounded Python Developer: How the pros use Python and Flask explains client →
Lead Developer Career Guide
A person or organization that receives professional services or commissioned work from another party.
- How it is used
- Positions clients as partners whose needs and expectations guide a lead developer’s software decisions and communication.
- How deep it goes
- Develops practical listening, requirements, trust-building, and relationship tactics rather than a formal client-management process.
- Examples
- Uses troubled projects, casual conversations about running, and concerns over deadlines or budgets to illustrate client interactions.
- What you can do after
- Practice/perform client conversations that clarify needs, address concerns, and support collaborative decisions.
Effective Platform Engineering
A customer is a person or group that receives or evaluates the value provided by a product or service.
- How it is used
- Guides engineering-platform priorities toward the people who use the product and experience its value directly.
- How deep it goes
- Distinguishes frequent, occasional, and influential users, then stops short of prescribing a complete client-research method.
- Examples
- Uses daily platform users, occasional users, influential leaders, and alpha-user feedback as concrete client distinctions.
- What you can do after
- Evaluate platform priorities by client usage, frequency, expected value, and feedback rather than stakeholder influence alone.
Grokking Software Architecture
A software component that initiates communication with a server to request resources or operations.
- How it is used
- Establishes the requesting side of client-server architecture before introducing API contracts and communication.
- How deep it goes
- Explains request-response steps, responsibility boundaries, and thick-versus-thin tradeoffs without implementing a client.
- Examples
- Uses a burger order, a user lookup, and email validation to illustrate client requests and responsibilities.
- What you can do after
- Evaluate/understand client-server responsibility splits and the tradeoffs between thin and thick clients.
Spring in Action, Sixth Edition
A client application is software that requests authorization and uses access tokens to access a protected resource server.
- How it is used
- Uses the client role to explain how an application obtains authorization and accesses a protected API.
- How deep it goes
- Explains authorization roles and compares grant flows, focusing on authorization code grant and JWT access tokens.
- Examples
- Contrasts a browser-based authorization flow with client credentials for non-user-focused operations.
- What you can do after
- Evaluate and understand how different grants affect client credential handling and whether a token can act for a user.
Automating API Delivery
Client code is software that calls an API according to its defined interface.
- How it is used
- Positions client code as the consumer-side integration with an API product whose interface must serve consumer needs.
- How deep it goes
- Defines the client as requester and identifies code generation and provider schema checks, without detailing client implementation.
- Examples
- Uses a product response schema with a UUID `id` and length-constrained `name` to illustrate what a client receives.
- What you can do after
- Evaluate/understand it: distinguish client requests from provider responses and place generated clients and schema tests in an integration workflow.
The Design of Web APIs, Second Edition
A customer is a business-domain entity representing a person or organization whose information is managed by a system.
- How it is used
- Identifies who uses an API so capabilities and interface decisions reflect consumer needs without becoming specific to one consumer.
- How deep it goes
- Defines API consumers and works through HTTP and authenticated requests, but does not define a customer-record schema.
- Examples
- Shows a browser or curl fetching a page and a shopping website retrieving an end user’s orders.
- What you can do after
- Evaluate/understand it: distinguish client applications from end users and assess which consumers a breaking API change affects.
Read how The Design of Web APIs, Second Edition explains client →
Grokking Concurrency
A client process is a process that initiates a connection to a server to request or exchange data.
- How it is used
- Uses a client process to request services or exchange data with a server over network sockets.
- How deep it goes
- Explains the connection lifecycle, socket roles, IP addresses, ports, messages, and a working terminal exchange.
- Examples
- Uses web browsers, email programs, Netcat, ncat, and a pizza-ordering client as concrete examples.
- What you can do after
- Operate/configure a client connection with Netcat or ncat using a server IP address and listening port.
Think Like a CTO
A person or organization that receives products or services from another organization, typically in a business relationship.
- How it is used
- Centers client understanding in technology vision planning, including departmental clients who consume an organization’s primary output.
- How deep it goes
- Defines clients and develops a listening-led discovery process, but does not prescribe a complete service-design method.
- Examples
- Uses a homeowner’s call-center claims experience to expose pain points and desired self-service options.
- What you can do after
- Evaluate client needs by listening for system use, data flows, availability dependencies, pain points, and desired process changes.
Rust in Action: Systems programming concepts and techniques
A client is a network participant that initiates requests or sends messages to a service or peer.
- How it is used
- Uses the client role to demonstrate sending requests or work through channels to another thread or peer.
- How deep it goes
- Explains client communication through sending, receiving, request-response flow, and task queues, without exposing channel internals.
- Examples
- Demonstrates clients sending 42, Ping messages, and rendering tasks through crossbeam channels.
- What you can do after
- Operate/configure crossbeam channels to send values, requests, and queued work from a client to a receiving thread.
Read how Rust in Action: Systems programming concepts and techniques explains client →
Robotics for Programmers
A service client is the ROS node-side component that invokes a service and receives its response.
- How it is used
- Invokes sporadic, request-response operations when a node needs confirmation that a server acted.
- How deep it goes
- Explains the client-server RPC model and demonstrates asynchronous Python calls, but does not detail transport internals.
- Examples
- Uses a ROS 2 Python SetBool client that sends true periodically and logs the returned message.
- What you can do after
- Builds a Python ROS 2 node that creates a service client, sends requests asynchronously, and handles responses.
gRPC Microservices in Go
A gRPC client is a client-side component that invokes operations exposed by a gRPC service.
- How it is used
- Connects an Order service to Payment.Create through a generated gRPC client stub when charging customers.
- How deep it goes
- Walks through dependency setup, dialing, client creation, calls, closure, and timeouts while leaving underlying communication abstracted.
- Examples
- Shows an Order-to-Payment Create call using grpc.Dial and NewPaymentClient, plus a ten-second context timeout.
- What you can do after
- Apply it via generated Go gRPC stubs to call Payment.Create from an Order service with error handling and a timeout.
Learn Rust in a Month of Lunches
Receiver is a Rust standard-library channel handle that obtains values transmitted by corresponding senders.
- How it is used
- Receives values sent through a Rust standard-library channel, including messages produced by multiple threads.
- How deep it goes
- Explains channel pairing, blocking and nonblocking methods, dropped handles, queued values, and Result-based failures.
- Examples
- Demonstrates receiving 5, consuming messages from cloned senders, and observing RecvError after queued values are exhausted.
- What you can do after
- Apply via std::sync::mpsc::channel by receiving values, choosing blocking or immediate checks, and handling closed channels.
Microservices Patterns, Second Edition
A service client is a software component that invokes one or more service APIs on behalf of a user interface or application.
- How it is used
- Places API composition in a frontend client to retrieve data for a system query.
- How deep it goes
- Compares four placement options and their applicability, without detailing API composition implementation.
- Examples
- Uses a web Order Status view on the same LAN and contrasts it with outside-firewall access.
- What you can do after
- Evaluate composer placement by weighing client network location, query audience, and aggregation complexity.
Read how Microservices Patterns, Second Edition explains client →
Also covered in
- Contract Testing in Action
- Object-Oriented Software Design in C++
- The Joy of JavaScript
- Acing the CCNA Exam: Volume 2 Advanced Networking and Security
- Python Concurrency with asyncio
- Kotlin in Action, 2E
- Software Design for Python Programmers
- Fast Python: High performance techniques for large datasets
- Test Driven: Practical TDD and Acceptance TDD for Java Developers
- Causal Inference for Data Science
- Crack Any Codebase with AIIn early access (MEAP)
- The Well-Grounded Data Analyst
What to know first
- HTTPHTTP is an application-layer protocol that defines request-and-response communication for transferring resource representations and related metadata between networked systems.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
- protobufProtocol Buffers is a language- and platform-neutral system for defining structured data schemas and serializing messages in a compact binary format, with support for generated code.
Related concepts
- web applicationincludes · A web application is software that provides functionality through web technologies and is accessed over a network, typically through a browser or other web client.
- queueuses · A queue is an ordered collection that holds items for retrieval or processing, commonly in first-in, first-out order.
- kafka-console-consumerincludes · kafka-console-consumer is an Apache Kafka command-line utility that reads records from topics or partitions and prints them to the console.
- kafka-console-producerincludes · kafka-console-producer is an Apache Kafka command-line utility that reads console input and publishes records to topics.
- refresh tokenuses · A refresh token is a credential a client exchanges with an authorization server to obtain a new access token without repeating the user authorization process.
Questions about client
What is client?
A client is a person, organization, device, or software component that receives or uses a product, service, resource, or functionality provided by another party or system.
Which Manning books explain client?
Apache Kafka in Action, Kafka for Architects, Spring Security in Action, Second Edition, Learn Go with Pocket-Sized Projects, The Well-Grounded Python Developer: How the pros use Python and Flask, Lead Developer Career Guide, Effective Platform Engineering, Grokking Software Architecture and 10 more.
What should I know before learning client?
Manning books that teach client usually introduce HTTP, contract, JSON and protobuf first.
What kinds of client are there?
Kinds of client include web application, http.DefaultClient, kafka-console-consumer and kafka-console-producer.
What is client also called?
Client is also called customer or service consumer.
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.

















