Client
A client is a person, organization, device, or software component that receives or uses a product, service, resource, or functionality provided by another entity.
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 fetch exchange rates, call habit-tracker endpoints, and connect a web frontend to a backend.
- How deep it goes
- Works through HTTP configuration and gRPC client construction, including timeout and integration tests, without detailing transport internals.
- Examples
- Shows an exchange-rate request, a slow-server timeout test, and habit creation and listing through a generated gRPC client.
- What you can do after
- Build it from scratch with `http.Client` or a generated gRPC client, then test requests and timeout behavior.
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.
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
- Requests authorization and uses an access token to reach a protected API.
- How deep it goes
- Explains the client’s place in authorization code grant and contrasts other grants, but does not show client token-handling code.
- Examples
- Illustrates an OAuth 2 authorization flow and a separate ingredient lookup made with WebClient.
- What you can do after
- Evaluate/understand how a client obtains a token for authenticated API access and why client credentials cannot 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
- Frames customer goals, workflows, constraints, and compatibility as inputs to reusable API capabilities.
- How deep it goes
- Connects clients to workflows, API consumption, constraints, and security checks, but stops short of defining a customer data schema.
- Examples
- Uses event-ticket booking, online shopping applications, browser requests, curl commands, and partner consumers affected by breaking changes.
- What you can do after
- Designs reusable API capabilities around customer workflows while accounting for consumer limitations, security, and compatibility.
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 →
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.
Related concepts
- queueuses · A queue is an ordered collection that holds items for retrieval or processing, typically removing them in the order they were added.
- 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.
- web applicationincludes · A web application is software that provides functionality through web technologies and is accessed by users through a browser or other web client.
- kafka-console-producerincludes · kafka-console-producer is an Apache Kafka command-line utility that reads console input and publishes records to topics.
- messageuses · A message is a discrete unit of information or data represented, processed, or exchanged in a communication context.
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.