Performance
Performance is the measurable effectiveness or operational behavior of a system under specified conditions, assessed through relevant qualities such as task results, speed, responsiveness, throughput, or resource use.
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
- Assesses model performance against project goals during design, experiments, reporting, and production monitoring.
- How deep it goes
- Works through selection risks, offline and online roles, experiment metric categories, and monitoring; avoids mathematical derivations.
- Examples
- Uses demand forecasting, airline ticket revenue, eCommerce experiment measures, and fraud-classification comparisons.
- What you can do after
- Evaluate/understand it by choosing goal-aligned measures, checking business effects online, and monitoring quality after deployment.
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 choices for processing growing datasets without assuming that additional machines will solve an inefficient implementation.
- How deep it goes
- Develops profiling, benchmarks, scaling intuition, and hardware explanations, but does not formally develop computational complexity theory.
- Examples
- Benchmarks NumPy row and column operations, compressed CSV loading, and Python list versus set membership.
- What you can do after
- Diagnose/debug with profiling and representative benchmarks, then choose changes according to measured time, memory, and scaling costs.
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 production monitoring and model evaluation against application needs.
- How deep it goes
- Details monitoring, load testing, optimization, and evaluation criteria without deriving performance models mathematically.
- Examples
- Uses JMeter or Locust load tests, Prometheus and Grafana monitoring, baseline comparisons, and Azure AI Studio evaluation runs.
- What you can do after
- Practice/perform task-specific evaluation and load testing, then monitor and tune deployed GenAI applications against measured results.
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 decisions about when to optimize C code and how to substantiate claims that an implementation runs faster.
- How deep it goes
- Works through repeated loop timings, statistics, measurement bias, and generated assembly; defers proofs of algorithmic complexity.
- Examples
- Compares timed C loops, calls to timespec_get, statistics collection, GCC and Clang assembly, and a table of per-iteration results.
- What you can do after
- Evaluate/understand performance claims using repeated timings, statistics, and inspection of compiled code without sacrificing correctness.
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.
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
- Guides decisions about which application bottlenecks to replace incrementally with Rust.
- How deep it goes
- Works through a Python integration and GIL-related threading change, while naming Criterion for benchmarking without supplying measurements here.
- Examples
- Uses Mandelbrot image generation, a PyO3 wrapper, and a Python thread executor to illustrate a targeted change.
- What you can do after
- Apply it via PyO3 to move a Python bottleneck into Rust and release the GIL during computation.
Latency
Performance is the observable efficiency or responsiveness of a software system.
- How it is used
- Uses performance measurement to find work that can be eliminated from latency-sensitive application paths.
- How deep it goes
- Develops a measure–optimize–remeasure workflow with complexity analysis and microbenchmarks, without treating asymptotic growth as measured latency.
- Examples
- Compares recursive, memoized, and iterative Fibonacci implementations using Criterion timings and a CPU-profiling workflow.
- What you can do after
- Apply it via Criterion and cargo bench to compare implementations, then use profiling to investigate where time is spent.
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 monitor training and validation performance and guide model refinement without directly optimizing those measures.
- How deep it goes
- Explains metric selection, K-fold score averaging, and Keras state updates, without deriving metric formulas.
- Examples
- Shows sparse categorical accuracy in R, fold-by-fold validation MAE for price prediction, and production engagement checks for a recommender.
- What you can do after
- Apply metrics via Keras to track predictions, compare validation runs, and monitor a deployed model.
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 algorithm choice and tests claims about the speed of compiled C code.
- How deep it goes
- Develops repeated timing, statistical comparison, and compiler inspection; defers complexity proofs and a full treatment of measurement science.
- Examples
- Compares timed C loops using volatile stores, opaque addition, and timespec_get, with per-iteration results and conclusive or inconclusive differences.
- What you can do after
- Diagnose/debug with repeated timing, statistical comparisons, and inspection of compiled code instead of trusting speed guesses.
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
- Guides targeted speed and efficiency decisions after correctness and clarity, rather than optimization of every code path.
- How deep it goes
- Traces slice reallocations and string copying, then benchmarks alternatives; stops short of a general profiling procedure.
- Examples
- Compares one-million-element slice conversions and three string-concatenation implementations using ns/op benchmarks.
- What you can do after
- Diagnose/debug with it by benchmarking alternatives, preallocating slices, and reserving strings.Builder capacity when sizes are known.
Read how 100 Go Mistakes and How to Avoid Them 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 →
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
- Frames responsiveness as a constraint to meet while minimizing infrastructure and energy-related resource use.
- How deep it goes
- Defines performance through speed and responsiveness, then contrasts it with clean code, sustainability, and efficiency without optimization internals.
- Examples
- Uses intermittent JDBC connection failures and saturated database-host CPU metrics to infer server overload.
- What you can do after
- Evaluate/understand performance tradeoffs by separating responsiveness from code readability and environmental impact.
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 →
Coding with AI
The degree to which software executes efficiently in terms of time and computational-resource use.
- How it is used
- Compares alternative implementations and checks AI-generated code before integrating it into an application.
- How deep it goes
- Demonstrates repeated elapsed-time checks and selection, stopping short of a formal benchmarking treatment.
- Examples
- Uses two punctuation-cleaning functions, a text file, elapsed-time output, and a faster-method selection.
- What you can do after
- Diagnose performance differences by timing competing Python functions and verifying the resulting code before use.
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
- Frames performance as a reason to choose appropriate collection-iteration behavior and type representations.
- How deep it goes
- Explains boxing and JIT optimization through approximate pseudocode, while leaving garbage-collection mechanics aside.
- Examples
- Illustrates performance costs with recursive rocket-stage counting and vector scaling using abstractly typed fields.
- What you can do after
- Apply it via Julia’s `IteratorSize` trait and parametric types to avoid costly length calculations and improve memory layout.
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 →
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 →
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.
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.
- profilingalternative to · Profiling is the measurement and analysis of a program’s runtime behavior and resource use to characterize performance and identify bottlenecks.
- administrative distancecontrasts with · Administrative distance is a router metric that expresses the relative trustworthiness of a route source.
- benchmarkmeasured by · A benchmark is a defined task, dataset, workload, procedure, or reference measure used to assess or compare performance or capability under specified criteria or conditions.
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.