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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Also covered in
- Architecting an Apache Iceberg Lakehouse
- Acing the CCNA Exam: Volume 1 Fundamentals and Protocols
- High Performance Unity Game DevelopmentIn early access (MEAP)
- Practices of the Python Pro
- Quantum Programming in Depth
- Starting Data Analytics with Generative AI and Python
- How Large Language Models Work
- Geometry for Programmers
- Just Use Postgres!
- 100 SQL Server Mistakes and How to Avoid Them
- Troubleshooting Java, Second Edition
- Designing Deep Learning Systems: A guide for software engineers
What to know first
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- meanThe mean is a measure of central location equal to the arithmetic average of numerical observations, or the probability-weighted average of a random variable’s possible values.
- machine learningMachine learning is a field of computational methods in which systems learn patterns or relationships from data to make predictions, decisions, or other outputs.
- arrayAn array is an ordered collection of elements organized in one or more dimensions and accessible by position or index.
Related concepts
- machine learningmeasures · Machine learning is a field of computational methods in which systems learn patterns or relationships from data to make predictions, decisions, or other outputs.
- administrative distancecontrasts with · Administrative distance is a router metric that expresses the relative trustworthiness of a route source.
- data-oriented programmingproduced by · Data-oriented programming is an approach to structuring software around data representations and the operations, access patterns, and transformations applied to them.
- profilingalternative to · Program profiling is the measurement and analysis of software execution behavior and resource use to characterize performance and identify bottlenecks.
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.






















































