liveBook · Manning

Performance

Performance is a measure of how effectively a person, process, model, or system achieves its objectives, including qualities such as output quality, speed, and resource efficiency.

How 55 Manning books explain it

Fabulous Adventures in Data Structures and Algorithms

Performance is the measured resource efficiency or execution speed of a computational system or algorithm.

How it is used
Compares algorithms and data structures by the time, memory, and scaling costs relevant to a problem.
How deep it goes
Works through growth rates, operation costs, amortization, worst cases, and concrete memory estimates rather than stopping at big O labels.
Examples
Uses immutable queues and deques, word lists, Game of Life, unification, and categorical samplers to expose different costs.
What you can do after
Evaluate/understand performance by separating growth rates, actual resource costs, workload phases, and worst-case behavior.

Read how Fabulous Adventures in Data Structures and Algorithms explains performance →

Machine Learning Platform Engineering

An evaluation metric is a quantitative measure of the quality, relevance, correctness, or safety of a model output or retrieval result.

How it is used
Judges model outputs during validation and helps detect degraded quality after deployment.
How deep it goes
Works through recommender RMSE, precision, and recall, but treats their production-ready design and validation as further work.
Examples
Uses top-50 movie recommendations, predicted-rating error, regression reports, and API request dashboards.
What you can do after
Apply it via validation code and tracked experiments, then monitor model quality separately from service health.

Read how Machine Learning Platform Engineering explains performance →

Cloud Observability in Action

A metric is a numerical observation, typically sampled over time, that describes a system property or behavior and may include identifying metadata and a timestamp.

How it is used
Supports dashboards, alerts, capacity planning, SLO assessment, and broad operational investigation.
How deep it goes
Explains structure, labels, collection, instrumentation, costs, storage, and correlation, but defers detailed SLO treatment.
Examples
Uses temperature labels, Kubernetes metrics, a Go echo service, Prometheus counters, Grafana dashboards, and a microservices alert investigation.
What you can do after
Apply it via Prometheus and Grafana to instrument services, collect measurements, visualize trends, and investigate operational behavior.

Read how Cloud Observability in Action explains performance →

Machine Learning System Design

A metric is a defined quantitative measure used to evaluate performance, behavior, or outcomes.

How it is used
Guides model assessment and business-aligned evaluation from system design through experiments and production monitoring.
How deep it goes
Develops selection criteria and evaluation stages, with worked business comparisons and monitoring categories rather than mathematical derivations.
Examples
Compares airline ticket forecasts by error and revenue, and groups e-commerce experiment measures into key, control, and auxiliary metrics.
What you can do after
Evaluate and select metrics that align model assessment, online experiments, and monitoring with business goals.

Read how Machine Learning System Design explains performance →

Grokking Data Structures

Performance is the measured efficiency of a system, including factors such as execution time and resource consumption.

How it is used
Guides algorithm and data-structure choices during design and checks whether an implemented solution meets time and memory needs.
How deep it goes
Develops time and extra-space bounds through growth classes and search examples; stops short of proving derived lower bounds.
Examples
Contrasts linear and binary search, two ways to reverse an array, and priority-queue insert and top costs.
What you can do after
Evaluate/understand algorithm choices through time and space growth, then profile implemented code for bottlenecks.

Read how Grokking Data Structures explains performance →

Fast Python: High performance techniques for large datasets

How it is used
Guides optimization of data-processing workloads as data volume and algorithmic costs grow.
How deep it goes
Works through profiling, scaling, implementation, and hardware effects while using complexity intuitions rather than formal theory.
Examples
Benchmarks station-distance calculations, Game of Life simulations, NumPy matrix operations, and compressed CSV loading.
What you can do after
Diagnose bottlenecks with Python profiling and evaluate time–memory trade-offs for a specific workload.

Read how Fast Python: High performance techniques for large datasets explains performance →

Generative AI in Action

Performance is the degree to which a system achieves operational objectives such as response speed, throughput, and resource efficiency.

How it is used
Guides monitoring, testing, and optimization of GenAI applications in production.
How deep it goes
Outlines monitoring, load testing, token management, caching, scaling, and cost controls without providing a detailed implementation.
Examples
Compares a fine-tuned translation model with a baseline using accuracy or fluency.
What you can do after
Evaluate and understand operational performance through continuous monitoring and simulated load tests.

Read how Generative AI in Action explains performance →

Modern C, Third Edition

Performance is the measurable efficiency of a program or operation, commonly including execution time and resource consumption.

How it is used
Guides optimization of C programs without sacrificing safety or correctness.
How deep it goes
Develops a measurement-and-inspection workflow with timing bias and statistics, while deferring complexity proofs.
Examples
Compares timed loops, timing-call and statistics-collection overhead, and compiler-generated assembly.
What you can do after
Evaluate performance claims using repeated measurements, statistics, and inspection of generated code.

Read how Modern C, Third Edition explains performance →

Quarkus in Action

A specification for exposing numerical measurements of application and system behavior.

How it is used
Uses numeric runtime measurements to monitor application behavior, visualize trends, and trigger threshold-based alerts.
How deep it goes
Defines metric types and dimensions, then implements collection and export; leaves the supplied Prometheus and Grafana deployment configuration unexplored.
Examples
Uses JVM uptime output, an Inventory service dashboard, and a counted car-registration method.
What you can do after
Apply it via Quarkus Micrometer to expose built-in and business metrics for Prometheus scraping and Grafana visualization.

Read how Quarkus in Action explains performance →

Fast by Default

A measure of how efficiently and responsively a software product or system operates.

How it is used
Frames performance as a user, business, and engineering priority that guides measurement, prioritization, and sustained quality work.
How deep it goes
Connects user and business effects to goals, platform metrics, cost analysis, and a repeatable profiling workflow rather than implementation internals.
Examples
Uses landing-page experiments, Largest Contentful Paint, API evaluation latency, mobile store reviews, and a data-table rendering limit.
What you can do after
Apply performance goals, field and lab measurement, cost framing, and daily profiling to identify, prioritize, and prevent regressions.

Read how Fast by Default explains performance →

Advanced Algorithms and Data Structures

An evaluation metric is a quantitative measure of the quality or performance of an algorithm's result.

How it is used
Guides choices among data structures and algorithms by comparing operation costs, resource use, deadlines, and result quality.
How deep it goes
Develops asymptotic time and space estimates, implementation-specific CPU profiling, and clustering evaluation; notes that profiling results need not generalize.
Examples
Compares BSTs with randomized treaps under different key distributions, estimates k-means costs, and tests cluster counts with the elbow method.
What you can do after
Evaluate/understand performance by matching complexity estimates, measured costs, and output-quality measures to the workload and its constraints.

Read how Advanced Algorithms and Data Structures explains performance →

Snowflake Data Engineering

Query performance is the efficiency with which a database query executes, including its latency and resource consumption.

How it is used
Guides data engineers in finding and improving slow or resource-intensive queries in Snowflake data pipelines.
How deep it goes
Explains query profiles, micro-partition pruning, clustering, search optimization, warehouse sizing, spilling, and concurrency through executable SQL.
Examples
Uses retail-sales aggregations, product and store filters, partition statistics, query history, and warehouses from extra-small through large.
What you can do after
Diagnose/debug with query history and query profiles, then apply SQL rewrites, clustering, search optimization, warehouse sizing, or concurrency controls.

Read how Snowflake Data Engineering explains performance →

Effective Platform Engineering

A success measure is a defined indicator used to determine whether an initiative has achieved its intended outcomes.

How it is used
Judges whether platform capabilities achieve intended outcomes and deliver value to developers, operators, and the business.
How deep it goes
Develops selection through outcomes, assumptions, costs, and metric categories, without prescribing a single calculation for every initiative.
Examples
Uses a 30% time-to-production reduction and indicators such as golden-path adoption, developer wait time, and incident resolution time.
What you can do after
Practice/perform it: define business-aligned platform measures early, track them over time, and use results to identify improvements.

Read how Effective Platform Engineering explains performance →

Refactoring to Rust

Performance is the efficiency with which an application executes, commonly characterized by resource consumption and execution time.

How it is used
Motivates incremental replacement of application bottlenecks rather than a full rewrite.
How deep it goes
Introduces Criterion benchmarking and shows GIL-release and thread-pool integration code.
Examples
Uses a Mandelbrot computation to contrast a Python thread pool with a Rust function that releases the GIL.
What you can do after
Apply it via PyO3 to move a Python bottleneck into Rust and release the GIL during computation.

Read how Refactoring to Rust explains performance →

The Cloud at Your Service: The when, how, and why of enterprise cloud computing

The extent to which a computing system meets expectations for operational characteristics such as speed and responsiveness.

How it is used
Frames performance as an operational concern for deployed cloud applications and provider oversight.
How deep it goes
Defines performance as application speed and introduces measurement and visibility without detailing implementation.
Examples
Compares average access times for one cloud-hosted web page across 18 U.S. cities.
What you can do after
Evaluate/understand cloud performance visibility when identifying problems and holding providers accountable.

Read how The Cloud at Your Service: The when, how, and why of enterprise cloud computing explains performance →

100 C++ Mistakes and How to Avoid Them

Performance is the degree to which software executes efficiently with respect to computational resources and hardware.

How it is used
Uses performance to assess C++ code alongside correctness, readability, and effectiveness.
How deep it goes
Explains profiling and optimization priorities, then works through buffering, operator semantics, and temporary-object examples.
Examples
Uses a loop that flushes each line and a class-object summation that creates temporaries.
What you can do after
Diagnose/debug performance issues by profiling hotspots and identifying unnecessary flushes or temporary objects.

Read how 100 C++ Mistakes and How to Avoid Them explains performance →

Latency

Performance is the observable efficiency or responsiveness of a software system.

How it is used
Focuses performance work on reducing latency by eliminating unnecessary computation.
How deep it goes
Develops a measurement-and-optimization workflow, connecting complexity analysis to benchmarking and CPU profiling.
Examples
Compares linear search with hash-table lookup and benchmarks recursive, memoized, and iterative Fibonacci implementations.
What you can do after
Diagnoses bottlenecks through measurement and applies Criterion to compare implementations.

Read how Latency explains performance →

Deep Learning with R, Third Edition

A metric is a numerical measure of model performance monitored during training or validation without necessarily being optimized directly.

How it is used
Uses metrics to measure success during training, validation, and production monitoring.
How deep it goes
Explains metric configuration and low-level state management, including stateless updates for JAX.
Examples
Shows sparse categorical accuracy and house-price mean absolute error averaged across four validation folds.
What you can do after
Apply metrics via Keras to configure monitoring and update or reset metric state in a custom loop.

Read how Deep Learning with R, Third Edition explains performance →

Modern C

Performance is the measured computational efficiency of a program, often expressed through execution time or resource consumption.

How it is used
Guides performance-critical algorithm selection and verifies implementation performance without sacrificing correctness.
How deep it goes
Works through timing, statistics, measurement bias, and generated-code inspection while deferring complexity proofs.
Examples
Compares timed volatile loops, a volatile store, opaque addition, and added timing and statistics operations.
What you can do after
Evaluate and understand performance claims using measurements, statistics, and inspection of generated code.

Read how Modern C explains performance →

100 Go Mistakes and How to Avoid Them

Performance is a measure of how efficiently a program performs its work, commonly including execution time and resource consumption.

How it is used
Uses performance to guide targeted optimization without sacrificing correctness and clarity unnecessarily.
How deep it goes
Explains allocation, copying, reflection, and contention costs, comparing alternatives with local benchmarks.
Examples
Compares slice initialization, string concatenation, and value comparison implementations.
What you can do after
Evaluate Go implementation choices using benchmark results, allocation behavior, and semantic trade-offs.

Read how 100 Go Mistakes and How to Avoid Them explains performance →

Build AI Drug Discovery Pipelines

Big O notation describes an algorithm's asymptotic growth in time or memory as input size or dimensionality increases.

How it is used
Profiles clustering algorithms to guide scalable compound-library processing under time and memory constraints.
How deep it goes
Defines asymptotic time and memory costs for three clustering methods, but stops short of formal derivations.
Examples
Compares clustering costs for millions of compounds represented by more than 1K features.
What you can do after
Evaluate clustering methods by estimating their time and memory growth before applying them to large compound libraries.

Read how Build AI Drug Discovery Pipelines explains performance →

Grokking Algorithms, Second Edition

Big O notation is a mathematical notation for describing the asymptotic growth rate of an algorithm's resource usage as input size increases.

How it is used
Compares algorithms by how their running time grows with input size, rather than by one timed run.
How deep it goes
Works through operation counts and common Big O classes; flags exact time conversions as simplified and defers average-case discussion.
Examples
Uses a billion-entry search comparison, a folded-paper grid, a phone-book search, and graph traversal.
What you can do after
Evaluate/understand how candidate algorithms scale and identify worst-case running times from their operations.

Read how Grokking Algorithms, Second Edition explains performance →

Learn Docker in a Month of Lunches, Second Edition

A metric is a quantitative measurement of a system, application, process, or outcome.

How it is used
Uses performance metrics to monitor containerized applications, reveal resource use, and help locate operational problems.
How deep it goes
Shows how to enable Engine metrics, inspect application endpoints, and declare custom metrics; leaves collection mechanics to Prometheus clients.
Examples
Uses Docker Engine output, Go and Java runtime endpoints, and Node.js access-log counter and client-IP gauge declarations.
What you can do after
Apply it via Prometheus client libraries to expose metrics, inspect HTTP endpoints, and visualize collected data with Grafana.

Read how Learn Docker in a Month of Lunches, Second Edition explains performance →

Vibe Engineering

Performance is a measure of a software system's resource efficiency and responsiveness under defined operating conditions.

How it is used
Guides decisions about whether efficiency improvements justify added complexity under expected workloads.
How deep it goes
Compares sequential and concurrent implementations with benchmark results, while identifying workload uncertainty and production-scale risks.
Examples
Uses an account-by-ID search and an AI-generated multithreaded alternative to compare benchmark results.
What you can do after
Evaluate performance optimizations against measured workloads and their complexity costs.

Read how Vibe Engineering explains performance →

Secure APIs

A metric is a quantifiable measure used to evaluate a property, outcome, or performance characteristic of a system or process.

How it is used
Uses aggregate measurements to understand API behavior, detect threats, and demonstrate security-process improvement.
How deep it goes
Explains aggregate behavior, performance and usage categories, concrete measurements, outliers, and security-process questions.
Examples
Uses requests per second, average response times, user request volume, Spectral errors, and Schemathesis findings as examples.
What you can do after
Apply OpenTelemetry and custom instrumentation to collect metrics, identify trends, and investigate API-use outliers.

Read how Secure APIs explains performance →

Writing for Developers: Blogs that get read

Performance is the measured operational behavior of a system, especially its speed, throughput, or resource efficiency.

How it is used
Uses quantified evidence to explain performance improvements, compare systems, and support engineering tradeoffs.
How deep it goes
Shows metrics through benchmarks, visualizations, and specified test setups, but does not develop a general measurement methodology.
Examples
Uses rewrite comparisons, Graviton2 benchmarks, Discord latency measurements, and metrics from large-scale device architectures.
What you can do after
Evaluate/understand performance claims by comparing baselines, setups, measurements, visual evidence, and tradeoffs.

Read how Writing for Developers: Blogs that get read explains performance →

The Art of Code

A monitoring metric is a measured numeric signal describing the state, activity, or performance of a running system.

How it is used
Uses performance and monitoring metrics to guide resource-efficient design and investigate system failures.
How deep it goes
Defines performance and efficiency and demonstrates metric correlation with logs, without specifying metric collection or instrumentation.
Examples
Uses an intermittent JDBC connection failure and database-host CPU saturation to illustrate investigation with metrics.
What you can do after
Diagnose/debug intermittent failures by correlating monitoring metrics with timestamped logs.

Read how The Art of Code explains performance →

PostgreSQL Mistakes and How to Avoid Them

Database performance is the efficiency and responsiveness with which a database system processes workloads.

How it is used
Guides prevention and investigation of PostgreSQL practices that waste resources or delay workloads.
How deep it goes
Connects SQL retrieval, configuration, sessions, autovacuum, logs, and workload symptoms without exhaustive tuning reference detail.
Examples
Contrasts SELECT * and SELECT id timings, full-table application filtering, slow-query logs, and frequent-checkpoint messages.
What you can do after
Diagnose/debug with logs and PostgreSQL statistics tools, then prioritize query, configuration, workload, or maintenance fixes.

Read how PostgreSQL Mistakes and How to Avoid Them explains performance →

The Art of AI Product Development

Efficiency is the achievement of an intended result with minimal expenditure of time, effort, or resources.

How it is used
Guides model selection, evaluation, and iteration against project goals and user needs.
How deep it goes
Combines standardized benchmarks with tailored metrics, feedback, and ongoing refinement, without specifying a universal score.
Examples
Uses MMLU and SQuAD benchmarks, task-specific quality measures, and a planner-platform example of quantified time savings.
What you can do after
Evaluate model quality with benchmarks and task-specific measures, then refine outputs using user feedback and corrective data.

Read how The Art of AI Product Development explains performance →

Grokking AI Algorithms, Second Edition

An evaluation metric is a quantitative measure of a model's performance on specified data or outcomes.

How it is used
Distinguishes solution quality, algorithm effectiveness, computational cost, and model evaluation across problem contexts.
How deep it goes
Defines several meanings, compares computational growth, and warns that training accuracy can misrepresent performance on unseen data.
Examples
Uses handshake analogies, knapsack combinations, brute-force benchmarks, and training-versus-unseen-data accuracy comparisons.
What you can do after
Evaluate algorithms and models by separating answer quality, computation cost, and generalization to unseen data.

Read how Grokking AI Algorithms, Second Edition explains performance →

Grokking Software Architecture

Performance is the measurable responsiveness and efficiency of a software system, including the time it takes to serve requests.

How it is used
Guides architectural choices by making responsiveness and efficiency explicit quality goals with real costs.
How deep it goes
Defines latency and throughput, then works through caching and its tradeoffs without detailing cache operations.
Examples
Contrasts Friendster's slow experience with faster social platforms and demonstrates caching with a database-backed dashboard.
What you can do after
Apply caching with Redis or Memcached to reduce repeated database work, while weighing added complexity and freshness.

Read how Grokking Software Architecture explains performance →

The Design of Web APIs, Second Edition

Performance is the efficiency and responsiveness with which an API processes requests and returns results.

How it is used
Guides API design decisions that reduce consumer wait times, data use, and provider infrastructure load.
How deep it goes
Explains design-level causes and remedies, while directing runtime bottlenecks to root-cause diagnosis rather than assuming redesign.
Examples
Uses slow shopping searches, ten sequential calls, and a shortened banking transfer flow.
What you can do after
Diagnose/debug with it by identifying the bottleneck before reducing unnecessary calls or data transfer.

Read how The Design of Web APIs, Second Edition explains performance →

Acing the Frontend Interview

Performance is the measured efficiency and responsiveness of a software system under specified workloads and operating conditions.

How it is used
Frames performance as a system-design and frontend-interview concern involving latency, responsiveness, scalability, and backend pressure.
How deep it goes
Explains performance through caching layers, consistency trade-offs, and an LRU implementation, while deferring broader measurement methods.
Examples
Uses client, CDN, and application caches plus a TypeScript LRU cache as concrete performance examples.
What you can do after
Evaluate performance trade-offs and apply caching through HTTP controls, in-memory stores, cache policies, and an LRU implementation.

Read how Acing the Frontend Interview explains performance →

Machines that Think

The observable execution or result of a task, as distinct from the capacity underlying it.

How it is used
Uses task performance to assess practical language-model output while distinguishing observable results from underlying competence and understanding.
How deep it goes
Explains task-specific evaluation, training objectives, scaling, and philosophical limits without prescribing a complete evaluation procedure.
Examples
Uses translation, summarization, dialogue, and classification criteria, alongside a master copyist’s visually indistinguishable painting.
What you can do after
Evaluate and understand performance by selecting task-relevant criteria and separating output quality from claims about competence or understanding.

Read how Machines that Think explains performance →

Coding with AI

The degree to which software executes efficiently in terms of time and computational-resource use.

How it is used
Uses timing to compare implementations and verify AI-generated code during development.
How deep it goes
Compares repeated timings of two functions but does not demonstrate deeper profiling.
Examples
Times two Python text-cleaning functions on the same text and compares their observed speeds.
What you can do after
Evaluate which of two implementations runs faster and review generated code before choosing.

Read how Coding with AI explains performance →

AI Model Evaluation

A performance metric is a quantitative measure of how well a model or system achieves its intended task or objective.

How it is used
Evaluate whether an AI system delivers predictions quickly, reliably, and affordably under realistic product conditions.
How deep it goes
Groups measurements across frontend, backend, model serving, infrastructure, and orchestration, then combines them to locate bottlenecks and assess trade-offs.
Examples
Uses recommendation latency, shadow-traffic comparisons, layered dashboards, and alert thresholds to make performance measurable.
What you can do after
Evaluate candidate systems by comparing latency distributions and checking measurements against predefined performance thresholds.

Read how AI Model Evaluation explains performance →

Julia as a Second Language

Performance is the efficiency with which a program executes, commonly evaluated through measures such as runtime or throughput.

How it is used
Connects performance to collection design and parametric types in Julia programs.
How deep it goes
Explains asymptotic cost, boxing, compiler constraints, and memory layout, while treating dynamic execution as intuition rather than an exact implementation.
Examples
Uses a staged-rocket length calculation, vector scaling with abstract fields, and an array of parameterized points.
What you can do after
Evaluate and understand potential performance costs in collection operations and type design.

Read how Julia as a Second Language explains performance →

Python How-To

Performance is the measured efficiency or speed with which a program or function processes data and responds to requests.

How it is used
Guides data-structure choices, function monitoring, and practical responsiveness improvements.
How deep it goes
Explains Big O with measured examples and hash-table behavior, then stops short of broader benchmarking methodology.
Examples
Compares list and set membership, list and deque FIFO removal, and manually timed functions with simulated delays.
What you can do after
Apply it via timeit and decorators to measure functions and select containers with more suitable operation complexity.

Read how Python How-To explains performance →

Amazon Web Services in Action, Third Edition: An in-depth guide to AWS

A metric is a quantitative measurement of system behavior, resource use, or performance over time.

How it is used
Monitors AWS resources, diagnoses performance problems, protects availability, and supplies signals for capacity changes.
How deep it goes
Descends from console inspection to alarm thresholds and scaling parameters, while noting that EC2 memory requires a custom metric.
Examples
Uses EC2 resource graphs, RDS threshold tables, autoscaling alarms, and a scheduled Lambda website health check.
What you can do after
Diagnose/debug with it, configure alarms, and adjust EC2 capacity using CloudWatch metrics and scaling policies.

Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains performance →

The Well-Grounded Python Developer: How the pros use Python and Flask

A performance metric is a quantitative measure used to evaluate an application's speed or resource efficiency.

How it is used
Guides optimization by defining targets, establishing baselines, and deciding when further speed improvements are worthwhile.
How deep it goes
Explains targets, baselines, profiling, the 90/10 rule, and trade-offs, but names no specific profiling tools or measurement formulas.
Examples
Uses application feature targets, baseline comparisons, 90/10 optimization, and MyBlog database query-performance trade-offs.
What you can do after
Evaluate/understand whether application changes improve speed enough to justify their complexity and delivery cost.

Read how The Well-Grounded Python Developer: How the pros use Python and Flask explains performance →

Build Python Web Apps with Streamlit

A metric is a quantified measure used to describe or evaluate a phenomenon, process, or outcome.

How it is used
Uses quantified indicators to monitor business performance and support executive decisions.
How deep it goes
Defines metrics, names calculation and display as implementation steps, and adds comparison for meaningful interpretation.
Examples
Uses revenue, profit, growth rate, customer-acquisition cost, sales, gross margin, product category, and gender breakdowns.
What you can do after
Build it into an interactive Streamlit dashboard with calculated values, filters, date ranges, and visual comparisons.

Read how Build Python Web Apps with Streamlit explains performance →

Software Design for Python Programmers

Performance is the measurable operational behavior of software, commonly including response time, throughput, and resource consumption.

How it is used
Frames performance as a nonfunctional requirement and a way to prevent surprising users.
How deep it goes
Explains causes, consequences, data-structure choices, and refactoring, without descending into detailed runtime internals.
Examples
Uses a two-second book-search constraint and contrasts lists with comprehensions, slicing, tuples, and NumPy arrays.
What you can do after
Evaluate performance requirements and improve runtime behavior through efficient programming and data-structure choices.

Read how Software Design for Python Programmers explains performance →

Automating API Delivery

A performance metric is a quantitative measure of process or system performance used for comparison and evaluation.

How it is used
Uses metrics to visualize process waste, define improvement success, and monitor API health for diagnosis and response.
How deep it goes
Distinguishes process, infrastructure, and service-level metrics, with time ladders, queues, dashboards, alerting, and monitoring formulas.
Examples
Uses an Acme API design review, Jira-ticket queues, a Product Catalog API, process maps, time ladders, and an improvement-target table.
What you can do after
Apply via process mapping and API monitoring to set targets, detect abnormal behavior, and evaluate improvement results.

Read how Automating API Delivery explains performance →

Kafka for Architects

A performance metric measures how effectively and responsively a system performs under a workload.

How it is used
Uses measurable system behavior to monitor Kafka health, tune performance, and support reliability and service-level decisions.
How deep it goes
Defines representative latency, rate, batch, throughput, resource, and saturation measures without detailing metric formulas or implementation procedures.
Examples
Uses message-processing latency, byte rates, batch sizes, topic throughput, consumer-group throughput, buffer exhaustion, and network I/O.
What you can do after
Diagnose performance degradation and guide tuning, capacity decisions, alerting, and service-level evaluation.

Read how Kafka for Architects explains performance →

Grokking Concurrency

Performance is the measured efficiency or speed with which a system completes computational work, commonly characterized by latency and throughput.

How it is used
Frames performance as the goal of concurrency and the reason to measure latency, throughput, and hardware utilization.
How deep it goes
Defines latency and throughput with an analogy, then connects performance to multicore hardware without detailing measurement procedures or optimization internals.
Examples
Uses motorcycle and bus travel to contrast latency with throughput.
What you can do after
Evaluate system performance by distinguishing individual-task latency from task throughput and relating improvements to processing resources.

Read how Grokking Concurrency explains performance →

Data Pipelines with Apache Airflow, Second Edition

A metric is a quantified measurement used to characterize or analyze data or system behavior.

How it is used
Guides production monitoring of Airflow performance through numerical signals and dashboards.
How deep it goes
Defines four monitoring signals and measurement examples, but defers tracing and environment-specific setup.
Examples
Uses queue-to-execution delay, running-task counts, pool slots, zombie tasks, web responses, timeouts, and machine resource measurements.
What you can do after
Operate/configure Airflow monitoring with Prometheus, Grafana, StatsD, OpenTelemetry, and relevant exporters.

Read how Data Pipelines with Apache Airflow, Second Edition explains performance →

Machine Learning Algorithms in Depth

Time complexity is a measure of how an algorithm's execution time grows with input size.

How it is used
Uses runtime and memory complexity to choose algorithms, implement efficient code, and assess machine-learning procedures.
How deep it goes
Explains asymptotic examples and data-structure costs, but stops short of a general complexity-analysis procedure or formal proofs.
Examples
Uses array searches, comparison sorts, constrained linear-time sorts, stacks, queues, naive Bayes, and PCA as concrete cases.
What you can do after
Evaluate/understand runtime and memory costs when comparing algorithms and implementing machine-learning methods.

Read how Machine Learning Algorithms in Depth explains performance →

The Coder Cafe

A metric is a quantifiable measure used to characterize or evaluate a system, process, or outcome.

How it is used
Compares data-structure costs and evaluates whether hardware features improve an application's workload.
How deep it goes
Contrasts operation complexity with cache effects and SMT tradeoffs, then recommends benchmarking instead of relying on theoretical gains.
Examples
Uses array-versus-linked-list iteration and an i7-7700K eight-thread scaling estimate to illustrate practical tradeoffs.
What you can do after
Evaluate performance by benchmarking an application and weighing workload-specific gains against costs such as power use.

Read how The Coder Cafe explains performance →

WordPress Power Toolkit: Harness AI to build next-level websites

Web performance is the efficiency with which a website loads, responds, and delivers an interactive experience.

How it is used
Uses visitor and search data to identify website improvements and troubleshoot search visibility.
How deep it goes
Connects performance to visitor behavior and search reports but does not detail technical loading or response metrics.
Examples
Uses analytics reports, Search Console checks, query analysis, indexing checks, and Lighthouse quality reports.
What you can do after
Diagnoses website problems with analytics and Search Console by locating traffic patterns, visibility issues, crawling errors, and indexing failures.

Read how WordPress Power Toolkit: Harness AI to build next-level websites explains performance →

Vanilla Web

Performance is the speed, responsiveness, and resource efficiency of a software system during operation.

How it is used
Guides architecture and tool choices around user experience, conversions, and resource efficiency.
How deep it goes
Defines user-facing measures and compares raw DOM-operation costs, but stops short of a step-by-step profiling procedure.
Examples
Uses a table-row UI benchmark and checks for meaningful content, layout shifts, first-interaction response, and repeat-visit caching.
What you can do after
Evaluate/understand web performance using Core Web Vitals and user-task measurements rather than assuming a framework choice guarantees speed.

Read how Vanilla Web explains performance →

Deep Learning with Python, Third Edition

A measurement of business outcome or value used to judge the effect of a deployed model.

How it is used
Uses validation metrics to guide modeling decisions and estimate performance on production data.
How deep it goes
Works through fold averaging and epoch-by-epoch MAE tracking to identify when validation error stops improving.
Examples
Compares four housing-price validation scores and plots mean absolute error across training epochs.
What you can do after
Evaluate generalization more reliably by choosing a validation protocol and tracking mean validation error across training epochs.

Read how Deep Learning with Python, Third Edition explains performance →

Microsoft Azure in Action

Performance is the measured effectiveness of a system, commonly including response time, throughput, and resource efficiency.

How it is used
Frames performance as cloud capacity that can scale with demand instead of remaining tied to a fixed hardware budget.
How deep it goes
Defines performance through execution cost, storage latency, I/O timing, database scalability, and trade-offs, without detailing measurement methodology.
Examples
Uses image resizing, Premium file shares, HDD-versus-SSD storage, and Banning Books database selection as concrete performance examples.
What you can do after
Evaluate Azure storage, compute, and database options by comparing speed, scalability, cost, tuning, security, and recovery trade-offs.

Read how Microsoft Azure in Action explains performance →

Delivering Machine Learning Projects: From design to deployment

Model performance is the degree to which a machine learning model produces accurate, useful, or otherwise acceptable outputs under specified conditions.

How it is used
Frames performance as a stakeholder requirement before delivery commitments and as a basis for functional model testing.
How deep it goes
Details test scenarios, measurements, test data, and reproducible environments, but specifies no particular performance metric.
Examples
Uses a commissioned test environment, test data, leakage controls, and measurements across scenarios.
What you can do after
Evaluate models through reproducible functional tests with measurements matched to test scenarios.

Read how Delivering Machine Learning Projects: From design to deployment explains performance →

Microservices Patterns, Second Edition

Performance is the responsiveness and resource efficiency with which a software system performs its operations.

How it is used
Frames performance as a runtime requirement that architecture must address.
How deep it goes
Quantifies performance through request throughput and average response time.
Examples
Uses an FTGO target of 233 create-order requests per second at 356 milliseconds average response time.

Read how Microservices Patterns, Second Edition explains performance →

Designing AI Systems

A quantitative measurement of a system's operational behavior or task results.

How it is used
Supports systematic optimization of AI applications as they move from prototypes toward production systems.
How deep it goes
Identifies measurement as necessary for informed change but does not specify metric definitions, collection methods, or evaluation procedures.
Examples
Uses an isolated financial-services chatbot whose changes cannot be assessed reliably without performance metrics.
What you can do after
Evaluate system changes methodically instead of treating each production adjustment as a gamble.

Read how Designing AI Systems explains performance →

Also covered in

What to know first

Related concepts

Questions about performance

What is performance?

Performance is a measure of how effectively a person, process, model, or system achieves its objectives, including qualities such as output quality, speed, and resource efficiency.

Which Manning books explain performance?

Fabulous Adventures in Data Structures and Algorithms, Machine Learning Platform Engineering, Cloud Observability in Action, Machine Learning System Design, Grokking Data Structures, Fast Python: High performance techniques for large datasets, Generative AI in Action, Modern C, Third Edition and 47 more.

What should I know before learning performance?

Manning books that teach performance usually introduce language model, mean, machine learning and array first.

What is the difference between performance and administrative distance?

Performance is a measure of how effectively a person, process, model, or system achieves its objectives, including qualities such as output quality, speed, and resource efficiency. Administrative distance is a router metric that expresses the relative trustworthiness of a route source.

What kinds of performance are there?

Kinds of performance include application slowness.

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.