Contract
An API contract is a specification of the operations, data, and behavioral expectations that govern interactions between software components.
Secure APIs
A defined software interface through which applications or services expose data and functionality to other software.
- How it is used
- Enables applications, services, devices, and users to access defined data and functionality while framing each interface as a security boundary.
- How deep it goes
- Defines APIs plainly, explains attack and business consequences, and extends into gateway-based network topology without detailing API implementation code.
- Examples
- Uses web, mobile, IoT, and service-to-service integrations plus public-versus-private endpoint topologies and a customer-data breach scenario.
- What you can do after
- Evaluate/understand API exposure, identify likely security and business consequences, and plan gateway, subnet, access-control, and monitoring protections.
Platform Engineering on Kubernetes
A platform API is an interface that exposes platform-provided capabilities and workflows to application services or their automation.
- How it is used
- Defines self-service requests and application capabilities while hiding the tools and workflows that fulfill them.
- How deep it goes
- Works through an Environment resource and its provisioning path, then identifies compatibility, local-development, latency, and security concerns.
- Examples
- Uses a Conference application development-environment request, an Environment resource definition, and an isolated vcluster provisioned with Crossplane.
- What you can do after
- Build it from scratch as an Environment-request workflow backed by Crossplane, or apply HTTP/gRPC capability APIs to decouple services from infrastructure.
Read how Platform Engineering on Kubernetes explains contract →
The Design of Web APIs, Second Edition
An application programming interface is a defined boundary through which software components communicate and access capabilities or data.
- How it is used
- Connects applications and systems through consumer-facing operations that expose capabilities while hiding implementation details.
- How deep it goes
- Defines boundaries, consumers, HTTP interaction, openness, and design timing, then sketches REST interface design without implementation internals.
- Examples
- Uses social-network Share and Timeline operations, SMS services, health checks, taxi calls, smart lights, and face detection.
- What you can do after
- Build it from scratch by identifying capabilities, selecting an API style, and designing an interface that serves consumers across contexts.
Read how The Design of Web APIs, Second Edition explains contract →
Functional Design and Architecture: Examples in Haskell
An application programming interface is a defined contract through which software clients interact with a component or service.
- How it is used
- Separates client code from device, service, and subsystem implementations to control coupling and support composition.
- How deep it goes
- Defines APIs as implementation-independent contracts and develops object-oriented, imperative, functional, and HTTP forms.
- Examples
- Uses spaceship commands, sensor and connection interfaces, C opaque types, hardware handlers, loggers, and HTTP schemas.
- What you can do after
- Evaluate/understand how to hide implementations, substitute dependencies, and design narrow contracts for testable business logic.
Read how Functional Design and Architecture: Examples in Haskell explains contract →
Learn Go with Pocket-Sized Projects
An API is a defined interface through which software components or services communicate and request functionality or data.
- How it is used
- Defines how callers use a library or send requests to a service and interpret responses.
- How deep it goes
- Works through exported library choices, HTTP request design, and gRPC boundary handling rather than stopping at a definition.
- Examples
- Uses a logger library, currency converter, JSON game request, and gRPC habit tracker.
- What you can do after
- Build it from scratch by defining caller-facing contracts, implementing endpoints, and isolating external dependencies behind small interfaces.
Read how Learn Go with Pocket-Sized Projects explains contract →
Simple Object-Oriented Design: Create clean, maintainable applications
An API is a defined interface through which software systems invoke functionality or access data from another system.
- How it is used
- Defines communication boundaries between modules, applications, and external systems while hiding implementation details.
- How deep it goes
- Explains API design through stability, simplicity, compatibility, extension points, infrastructure boundaries, and leakage tradeoffs rather than protocol internals.
- Examples
- Uses employee repositories, message delivery, caching, and a JSON notification service with create, add-participant, and remove-participant operations.
- What you can do after
- Apply it via module interfaces or web APIs that isolate clients from internal and infrastructure changes.
Read how Simple Object-Oriented Design: Create clean, maintainable applications explains contract →
Build and Orchestrator in Go (From Scratch)
An API is a defined interface through which software components request operations or exchange data.
- How it is used
- Exposes manager and worker operations so developers submit tasks and managers coordinate workers over HTTP.
- How deep it goes
- Builds HTTP APIs through routes, routers, handlers, JSON processing, status codes, and runnable manager-worker servers.
- Examples
- Demonstrates GET, POST, and DELETE task requests with curl, JSON task data, HTTP status codes, and a running Docker container.
- What you can do after
- Build it from scratch using Go handlers, chi routes, HTTP servers, JSON bodies, and manager-worker API boundaries.
Read how Build and Orchestrator in Go (From Scratch) explains contract →
Starting Data Analytics with Generative AI and Python
A defined software interface through which programs request data or operations from another system and receive responses.
- How it is used
- Enables programmatic model requests within repeatable text-analysis workflows and custom analytics applications.
- How deep it goes
- Demonstrates Python requests, response handling, and evaluation; does not explain API internals.
- Examples
- Uses Portuguese review-keyword generation and API-based classification of 500 customer reviews.
- What you can do after
- Apply it via the OpenAI Python library to request model output, inspect responses, and compare sentiment results with a reference.
Read how Starting Data Analytics with Generative AI and Python explains contract →
Unit Testing Principles, Practices, and Patterns
The public API is the set of publicly accessible operations and contracts through which a software component can be used.
- How it is used
- Frames API design as aligning client-visible operations and state with observable behavior while hiding implementation details.
- How deep it goes
- Defines public and private APIs, explains leakage and encapsulation, and demonstrates refactoring without covering API versioning or protocols.
- Examples
- Uses User name normalization, Customer promotion discounts, and purchase operations to expose leaking state or multi-call APIs.
- What you can do after
- Evaluate/understand whether a public member represents client-observable behavior and refactor leaked implementation details behind private boundaries.
Read how Unit Testing Principles, Practices, and Patterns explains contract →
Effective Data Analysis
An API is a defined programmatic interface through which software requests data or operations from another software system or service.
- How it is used
- Supplies external, up-to-date data for repeatable analyses and stakeholder deliverables.
- How deep it goes
- Works through a forecast request, JSON inspection, and dataframe preparation; also weighs whether automation is worth the setup effort.
- Examples
- Uses a National Weather Service forecast and NYC Open Data rat-sighting records to illustrate refreshed datasets.
- What you can do after
- Apply it via Python requests to retrieve and prepare API data, then evaluate whether automated retrieval serves the stakeholder’s needs.
Build Financial Software with Generative AI (From Scratch)
An application programming interface (API) is a defined interface through which software components communicate and request functionality or data.
- How it is used
- Connects dashboard, backend, database, and payment-processing capabilities through callable interfaces.
- How deep it goes
- Walks through FastAPI routes, CORS, UI integration, tests, documentation, management, pagination, and asynchronous processing; defers fuller production implementation.
- Examples
- Uses health-status calls, ACH batch retrieval, audit records, D3.js rendering, Docker endpoints, and WSO2 deployment.
- What you can do after
- Build it from scratch with FastAPI routers, test endpoints, connect a UI, configure CORS, and expose managed API routes.
Read how Build Financial Software with Generative AI (From Scratch) explains contract →
100 Go Mistakes and How to Avoid Them
An application programming interface is a defined set of operations and conventions through which software components interact.
- How it is used
- Guides the design of Go operations that callers can understand, reuse, and test without unnecessary abstraction.
- How deep it goes
- Works through interface placement and return-type tradeoffs, then traces one signature’s allocation effect; it does not prescribe a universal interface rule.
- Examples
- Uses customer storage, `io.Reader` and `io.Writer`, and contrasting `Read` signatures to expose caller and allocation consequences.
- What you can do after
- Build it from scratch with interfaces shaped by callers, concrete return types where appropriate, and signatures checked for allocation effects.
Read how 100 Go Mistakes and How to Avoid Them explains contract →
Build Python Web Apps with Streamlit
An API is a defined interface through which software components programmatically exchange data or invoke functionality.
- How it is used
- Defines how separated frontend and backend components interact and how an app accesses external services.
- How deep it goes
- Works through three Python backend functions and introduces web request shapes, while directing readers to each external API’s documentation for specifics.
- Examples
- Uses a restaurant menu, unit-conversion functions, and a public joke endpoint with a missing-key response.
- What you can do after
- Build it from scratch as a small Python backend interface, or evaluate an external service’s documentation before calling its API.
Read how Build Python Web Apps with Streamlit explains contract →
LLMs in Production
An API is a defined interface through which software applications request capabilities or data from another software system.
- How it is used
- Positions APIs as both a quick route to hosted LLMs and the service boundary for a self-deployed model.
- How deep it goes
- Shows a minimal client call and outlines service-planning concerns, without specifying a complete request schema or endpoint contract.
- Examples
- Uses a Python OpenAI chat-completion call, a hosted-model access dispute, and an LLM service architecture.
- What you can do after
- Evaluate/understand it by weighing hosted API access against ownership and planning an LLM service around requests and inference.
Grokking AI Applications
A defined interface through which software programs invoke operations or exchange data.
- How it is used
- Enables GenAI applications to communicate with external software, expose their own capabilities, and automate data or action workflows.
- How deep it goes
- Explains endpoints, parameters, authentication, responses, and HTTP exposure, without descending into protocol internals.
- Examples
- Uses Langflow endpoints, Gmail and Outlook actions, CRM updates, messaging, smart devices, and a FastAPI email service.
- What you can do after
- Apply it via Langflow or FastAPI to expose GenAI logic as a callable service for external systems.
API Design Patterns
An application programming interface is a defined interface through which software programs interact with a system's functionality or data.
- How it is used
- Defines computer-to-computer interaction and exposes reusable functionality through local interfaces or networked web APIs.
- How deep it goes
- Explains contracts, web API trade-offs, composition, expressiveness, and quality criteria, but defers detailed resource-oriented design.
- Examples
- Uses encryption services, translation operations, language detection workarounds, downloadable libraries, and web API changes.
- What you can do after
- Evaluate/understand API designs by checking programmatic usefulness, expressiveness, simplicity, predictability, and compatibility.
Effective Platform Engineering
An API is a defined software interface through which programs or users access capabilities or data provided by a system.
- How it is used
- Uses APIs as the first delivery boundary for self-service platform capabilities and cross-team collaboration.
- How deep it goes
- Explains API-first architecture, team boundaries, evolution, and consumer value without detailing protocols, schemas, or implementation mechanics.
- Examples
- Uses capabilities exposed before user interfaces, alpha-user experiments, developer portals, and platform integrations as concrete applications.
- What you can do after
- Apply API-first design to expose reusable platform capabilities, add interfaces incrementally, and assess consumer value through usage.
The Well-Grounded Python Developer: How the pros use Python and Flask
An application programming interface is a defined set of operations and rules through which software components communicate and access functionality.
- How it is used
- Connects application code to reusable functions, modules, operating-system services, and local or remote server functionality through predictable interfaces.
- How deep it goes
- Defines APIs as contracts, explains input and hidden implementation, and works through Python function signatures; defers detailed remote database access.
- Examples
- Uses `print("Hello World")`, the `print` signature, and evolving `full_name` parameters to make interface choices concrete.
- What you can do after
- Build it from scratch by defining clear Python function interfaces with suitable parameters, names, and documentation.
Read how The Well-Grounded Python Developer: How the pros use Python and Flask explains contract →
Machine Learning System Design
A defined interface through which software components request functionality or exchange data.
- How it is used
- Defines the interface callers rely on when integrating an ML system and comparing it with third-party API baselines.
- How deep it goes
- Works through ML-specific design choices and practices, but defers general API design and REST-versus-RPC instruction.
- Examples
- Contrasts prediction functions with hidden choices and optional parameters, then adds model-version selection.
- What you can do after
- Apply it by shaping a simple external API, keeping internals flexible, and making prediction options explicit.
Web Components in Action
A defined programming interface through which a software component exposes operations or data to other components.
- How it is used
- Uses a component’s public interface to configure it and let it work with other components.
- How deep it goes
- Develops component APIs through properties, methods, attributes, callbacks, reflection, and access conventions.
- Examples
- Shows video controls through methods and properties, plus a search component configured with API-key and search-term setters.
- What you can do after
- Apply it by configuring a Web Component through JavaScript setters or HTML attributes.
Effective Conversational AI
An application programming interface (API) is a defined interface through which one software system or component requests capabilities, data, or operations from another.
- How it is used
- Connects conversational assistants to external services for task fulfillment, customer-data retrieval, or LLM text generation.
- How deep it goes
- Explains API inputs, responses, errors, and platform integration steps without descending into implementation code.
- Examples
- Illustrates password resets, an insurance member-ID voice flow, and an LLM-assisted bank-account balance request.
- What you can do after
- Apply it via an assistant platform to connect external services while planning for user effort and API failures.
Introduction to Generative AI, Second Edition
An application programming interface (API) is a defined programmatic interface through which software clients access a system's capabilities.
- How it is used
- Enables AI assistants and agents to retrieve external information or use tools while responding to requests.
- How deep it goes
- Explains API use through inputs, outputs, and Toolformer’s training process, without specifying how to implement an API.
- Examples
- Uses weather and calendar access, travel recommendations, a possible payment API, and calculator, search, and translation tools.
- What you can do after
- Evaluate/understand when an assistant needs API access and why access alone does not ensure a reliable action.
Read how Introduction to Generative AI, Second Edition explains contract →
Shipping Go: Develop, deliver, discuss, design, and go again
A defined interface through which software components or users interact with an application or service.
- How it is used
- Uses APIs as exposed service contracts that let callers depend on behavior rather than an implementation.
- How deep it goes
- Defines Go interfaces through method signatures and works through interchangeable services, testing, and configuration-based selection.
- Examples
- Uses a Go Greeter interface, a Translator contract, and a configured choice between static and remote translation services.
- What you can do after
- Build it from scratch by declaring a Go method contract and supplying interchangeable service implementations to a caller.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains contract →
ASP.NET Core in Action, 3e
A web API is an HTTP-accessible application interface that exposes operations or data to clients.
- How it is used
- Serves operations or data to mobile apps, browser SPAs, and backend services through HTTP.
- How deep it goes
- Defines API paradigms and client contexts, then addresses HTTPS configuration without detailing endpoint implementation.
- Examples
- Uses mobile applications, browser SPAs, backend services, and a multi-client ASP.NET Core server as examples.
- What you can do after
- Builds RESTful or HTTP APIs with ASP.NET Core and selects a suitable paradigm for different clients.
Automating API Delivery
An API is a defined set of functions and protocols forming a shared boundary through which software systems communicate and exchange information.
- How it is used
- Defines the shared software boundary for communication, while framing consumer-facing APIs as managed products.
- How deep it goes
- Defines API functions, protocols, forms, and product distinctions, but stops short of implementation internals.
- Examples
- Uses REST, SOAP, RPC, GraphQL, WebSocket, and internal Permissions APIs as concrete forms or applications.
- What you can do after
- Evaluate whether an interface is merely an integration boundary or a consumer-oriented API product requiring lifecycle investment.
The Art of Code
A public API is an externally accessible software interface whose operations and behavior are exposed for use by other systems or clients.
- How it is used
- Defines a stable boundary for systems or clients that depend on exposed operations and behavior.
- How deep it goes
- Details contract contents and durability risks, but stops short of implementation-level API construction.
- Examples
- Uses OpenAPI specifications, Javadoc, written contracts, and the contrast between exposed database entities and separate response models.
- What you can do after
- Build it from scratch by defining a narrow, documented interface that hides internals and communicates lifecycle expectations.
Google Anthos in Action
An API is a defined interface through which software components communicate and access capabilities or data.
- How it is used
- Uses standard service contracts to define boundaries while decomposing legacy applications into smaller services.
- How deep it goes
- Connects contracts to breaking-change detection and isolated domain testing without specifying contract formats.
- Examples
- Names authentication, authorization, and logging as capabilities teams may extract into separate services.
- What you can do after
- Apply standard contracts to identify potentially breaking service changes and test business-domain services independently.
Grokking Data Structures
An API is a defined set of programmatic operations and interaction rules exposed by a software component.
- How it is used
- Defines how clients interact with a data type without depending on its implementation.
- How deep it goes
- Specifies method signatures, behavior, and side effects, then illustrates how an implementation can restrict an underlying collection’s interface.
- Examples
- Uses a light switch, bag operations, linked-list search, a stack wrapper, and dictionary operations to make contracts concrete.
- What you can do after
- Build it from scratch by specifying permitted operations and their behavior while keeping internal nodes inaccessible to clients.
Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
An application programming interface is a defined interface through which software can programmatically interact with a service or system.
- How it is used
- Provides the entry point for configuring AWS services and letting applications use them.
- How deep it goes
- Explains API access paths and an SDK call pattern, while leaving direct HTTP authentication and serialization to higher-level tools.
- Examples
- Shows a web application calling AWS services and a DynamoDB putItem call that adds a user.
- What you can do after
- Apply it via an AWS SDK by supplying parameters, invoking an operation, and checking for errors.
Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains contract →
Learn Haskell by Example
An application programming interface is a defined set of operations and data representations through which software components interact.
- How it is used
- Defines HTTP and JSON operations for a todo-list server and its command-line client.
- How deep it goes
- Builds typed endpoint declarations and middleware decisions, while deferring explanations of DataKinds and TypeOperators.
- Examples
- Uses a todo-list service with entries, add, and toggle endpoints plus an HTML root page.
- What you can do after
- Build it from scratch as a typed Servant API with validated requests and derived client functions.
Advanced Algorithms and Data Structures
An API is a defined interface through which software requests operations or data from another software component or service.
- How it is used
- Defines the operations and guarantees that data structures expose to external clients.
- How deep it goes
- Distinguishes client-facing guarantees from internal invariants, data models, and algorithms.
- Examples
- Uses priority queue operations and a shared ordering interface for multiple retailers.
- What you can do after
- Build it from scratch by specifying operations, behavior, implementation details, and performance.
Read how Advanced Algorithms and Data Structures explains contract →
Microsoft Azure in Action
An API is a defined interface through which software components request functionality or data from other software.
- How it is used
- Connects applications to defined functionality or data, including partner access to a shop’s NFT images.
- How deep it goes
- Defines APIs and endpoints through inputs and HTTP URLs, then distinguishes Cosmos DB APIs by data model without specifying an interface schema.
- Examples
- Uses a power-calculation endpoint, partner access to NFT images, and Cosmos DB APIs for product, customer, and activity data.
- What you can do after
- Evaluate/understand an API as a software interface and distinguish an HTTP endpoint from a data-model-specific Cosmos DB API.
Django in Action
An API is a defined interface through which software components exchange requests, responses, or data.
- How it is used
- Connects external systems and alternate frontends to project data and application logic.
- How deep it goes
- Explains REST methods, payloads, versioning, Django views, Ninja routes, routers, and schemas.
- Examples
- Uses mobile apps, SPAs, JSON and XML payloads, HTTP CRUD methods, Django Ninja endpoints, and versioned URLs.
- What you can do after
- Build REST APIs in Django using views or Django Ninja, including routes, schemas, CRUD actions, and versions.
Rust Servers, Services, and Apps
An API is a defined interface through which software components communicate and request functionality or data.
- How it is used
- Connects application frontends with backend services and supporting distributed infrastructure.
- How deep it goes
- Develops APIs from architectural role through REST routes, handlers, data models, persistence, requests, and serialized responses.
- Examples
- Uses Actix REST services, tutor-management routes, command-line HTTP requests, authentication forms, and create-update-delete operations.
- What you can do after
- Build it from scratch with Actix, expose REST APIs, connect frontend requests, and interpret serialized backend responses.
Read how Rust Servers, Services, and Apps explains contract →
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
A defined software interface through which one system invokes operations or accesses capabilities of another system.
- How it is used
- Frames the stable inputs and outputs that module users, command wrappers, and provider users rely on.
- How deep it goes
- Explains interface design through variable naming and provider planning, then distinguishes single-response JSON from streaming JSONL without specifying every output field.
- Examples
- Uses mismatched subnet variable names, `show` and `plan` output, and a provider configuration with an account lookup and post resource.
- What you can do after
- Build it from scratch by defining provider resources, data sources, and functions around intended user actions before implementation.
Read how Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu explains contract →
Digital Twins in Action
An API is a defined interface through which software components access operations or data provided by another component.
- How it is used
- Provides on-demand access to internal and external data for digital twin ingestion.
- How deep it goes
- Compares integration styles and works through a Python image request, then addresses contract changes without implementing an API server.
- Examples
- Uses a NASA GIBS image request and a per-decision LLM API cost comparison.
- What you can do after
- Apply it via Python requests to retrieve dated imagery, and monitor external API contracts for breaking changes.
Data Pipelines with Apache Airflow, Second Edition
An API is a defined interface through which software applications programmatically access data or functionality.
- How it is used
- Uses APIs to retrieve workflow data or trigger Airflow DAGs from outside Airflow.
- How deep it goes
- Shows endpoints, authentication, request inputs, and responses, while leaving cloud request-and-response internals to clients and operators.
- Examples
- Demonstrates authenticated Citi Bike ride queries and POST requests that trigger Airflow DAG runs.
- What you can do after
- Apply it via curl and Airflow’s REST API to retrieve records or trigger DAG runs, while checking authentication and possible result limits.
Read how Data Pipelines with Apache Airflow, Second Edition explains contract →
gRPC Microservices in Go
An API is an interface that exposes an application's core functionality to other software modules or external consumers.
- How it is used
- Defines callable service operations and application-port actions so other services or components can use core functionality.
- How deep it goes
- Works through .proto messages, stub generation, and Go port signatures, but does not detail protocol internals.
- Examples
- Uses a Payment creation request and response, an Order API port, and mocked database and payment calls.
- What you can do after
- Build it from scratch with .proto definitions and generated stubs, or implement Go port interfaces for application boundaries.
Functional Programming in Scala, Second Edition
An application programming interface is a set of operations and abstractions through which software components are programmed or composed.
- How it is used
- Uses abstract operations and laws to design reusable functional libraries before committing to concrete implementations.
- How deep it goes
- Develops APIs through types, primitives, combinators, laws, interpreters, and iterative usability checks, rather than stopping at interface definition.
- Examples
- Uses Par operations, JSON parser construction, parser combinators, and automatically generated property-based tests as concrete API settings.
- What you can do after
- Build it from scratch by selecting primitives, deriving combinators, specifying laws, and refining the interface against implementations and usage.
Read how Functional Programming in Scala, Second Edition explains contract →
AI Agents in Action, Second Edition
An API is a defined interface through which software applications communicate with services or other software components.
- How it is used
- Defines how clients, services, agents, and tools exchange requests and results across an interface.
- How deep it goes
- Works through a FastAPI endpoint, request model, response format, and missing-output error, alongside MCP tool schemas.
- Examples
- Uses an image-generation POST endpoint returning PNG bytes and MCP tools described by parameter schemas and return types.
- What you can do after
- Apply it via FastAPI to expose an agent through a POST endpoint with a defined request and response.
Read how AI Agents in Action, Second Edition explains contract →
React in Depth
An API is a defined interface through which software applications exchange requests and responses with another application or service.
- How it is used
- Routes goal-tracker reads and writes through a server and enables client-side geocoding in a weather app.
- How deep it goes
- Defines REST and CRUD, then implements geocoding routes; leaves broader API design beyond scope.
- Examples
- Uses goal-tracker session, user, and things endpoints plus coordinate-to-city geocoding in Next.js and Remix.
- What you can do after
- Build it from scratch by implementing geocoding routes that read coordinates, call a service, and return JSON or a 404.
Refactoring to Rust
An API is a defined interface through which software components expose operations and exchange data.
- How it is used
- Shapes the names, operations, and data that crate users can access while concealing implementation structure.
- How deep it goes
- Explains re-exports, module visibility, and crate boundaries with code, stopping short of broader API design guidance.
- Examples
- Uses DayKind re-exports and a forest crate that hides enter_area behind user-facing entry functions.
- What you can do after
- Operate/configure Rust visibility and re-exports to expose stable names while restricting internal helpers.
Delivering Machine Learning Projects: From design to deployment
An API is a defined interface that enables software components to communicate and invoke available data or functionality.
- How it is used
- Uses an API access layer to decouple production data pipelines from their underlying databases.
- How deep it goes
- Explains the abstraction’s benefits and recommends a controlled, documented API, but does not detail its implementation.
- Examples
- Describes an API address that invokes a query and a database upgrade managed through API calls.
- What you can do after
- Evaluate how an API layer can isolate production systems from database implementation changes.
Read how Delivering Machine Learning Projects: From design to deployment explains contract →
Modern C, Third Edition
A library interface is the specified set of declarations and calling conventions through which software accesses library functionality.
- How it is used
- Defines what a function does and supplies the clear semantics needed for portable use of C library functionality.
- How deep it goes
- Distinguishes interface specification and purpose from code organization and implementation details.
- Examples
- Illustrates library interfaces with printf, puts, and strtod, and contrasts interface comments with implementation comments.
- What you can do after
- Understand which details belong in an interface specification versus implementation code and comments.
Related concepts
- endpointhas part · An endpoint is a network-accessible address or interface through which a service exposes a resource or operation and handles requests and responses.
- HTTPuses · HTTP is a standardized application-layer protocol that defines request-and-response messages for transferring resource representations between networked systems.
- MCPcontrasts with · The Model Context Protocol is an open standard protocol that defines how AI applications connect with external tools, data sources, and other contextual resources.
- LangChainused by · LangChain is an open-source software framework for building applications that compose language models with prompts, data sources, tools, and other components.
- MCP serverused by · An MCP server is software that implements the Model Context Protocol to expose capabilities or information to compatible clients.
- empty interfaceincludes · any is a type or type constraint that permits values of arbitrary concrete types without requiring a more specific interface or representation.
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.