liveBook · Manning

Performance optimization

Also called performance tuning

Performance optimization is the systematic modification of a system or its operation to improve performance measures such as speed, responsiveness, throughput, or resource efficiency.

How 10 Manning books explain it

Modern C

How it is used
Frames optimization as both compiler transformation and a safety-conscious performance practice.
How deep it goes
Explains observable-behavior constraints, type-dependent transformations, and measurement bias through worked examples and practical safeguards.
Examples
Uses constant arithmetic and combined additions, followed by timed loops and a sample of repeated measurements.
What you can do after
Evaluate and understand compiler transformations and timing results while recognizing safety and measurement limitations.

Read how Modern C explains performance optimization →

Vibe Engineering

Performance optimization is the modification of software to improve responsiveness, throughput, or resource efficiency under a defined workload.

How it is used
Guides performance changes toward measured hot paths under expected traffic and service requirements.
How deep it goes
Works through workload measurement, implementation alternatives, benchmarks, and trade-off review, including pitfalls in LLM-generated changes.
Examples
Compares sequential and parallel account lookup and instruments a word service before caching its dictionary.
What you can do after
Evaluate optimization proposals against workload measurements, benchmark results, and operational trade-offs.

Read how Vibe Engineering explains performance optimization →

Starting Data Analytics with Generative AI and Python

Code optimization is the systematic modification of algorithms, code, or data-processing pipelines to improve execution speed, performance, or resource utilization.

How it is used
Addresses analytics pipelines that become too slow or resource-intensive as data volumes and computational demands grow.
How deep it goes
Defines optimization versus scaling and demonstrates vectorization, timing comparison, and skepticism about generated code.
Examples
Uses a bootstrap confidence-interval function and a consecutive-letter check to illustrate performance gains and suspect optimization claims.
What you can do after
Apply it via NumPy vectorization, then compare execution time and check the revised function’s behavior.

Read how Starting Data Analytics with Generative AI and Python explains performance optimization →

Acing the Frontend Interview

Performance optimization is the process of improving a system's speed, responsiveness, throughput, or resource efficiency.

How it is used
Frames performance optimization as a frontend interview skill spanning CSS practices and system-design questions.
How deep it goes
Provides actionable CSS techniques and interview probes, but does not walk through a measured bottleneck and its results.
Examples
Uses a React interview scenario, a CSS optimization question, probing follow-ups, and a technique-and-benefit table.
What you can do after
Apply it via browser DevTools coverage and CSSNano, and explain why chosen CSS changes help performance.

Read how Acing the Frontend Interview explains performance optimization →

Fast Python: High performance techniques for large datasets

How it is used
Uses optimization to improve Python data-processing performance and storage efficiency without assuming that adding machines is viable.
How deep it goes
Emphasizes profiling before changes, then identifies data-structure complexity, memory use, lazy processing, and execution architecture as optimization concerns.
Examples
Uses a NOAA climate-data ingestion scenario and a Dask sort_values task graph to illustrate bottleneck investigation.
What you can do after
Diagnose performance bottlenecks with Python profiling tools and inspect distributed operations using Dask task graphs.

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

Fast by Default

The discipline of designing, operating, and evolving software so that fast and reliable behavior is built in as a default outcome.

How it is used
Frames performance as a continuous design, delivery, and operations responsibility rather than a late-stage repair task.
How deep it goes
Explains a reactive failure cycle, System Paths, and four sustaining practices without descending into tool-specific implementation details.
Examples
Uses an evolving dashboard with filter-driven fetches, chart re-renders, sequential requests, caching gaps, and incomplete result states.
What you can do after
Operate performance as a shared workflow by measuring impact, fixing root causes, enforcing visibility, and reviewing production behavior.

Read how Fast by Default explains performance optimization →

Modern C, Third Edition

Optimization is the transformation of a program's implementation to improve execution or compilation while preserving its required observable behavior.

How it is used
Explains how C compilers may change execution while preserving observable states.
How deep it goes
Works through constant computation and addition transformations, including observable intermediate values, type-dependent constraints, and long-jump interactions.
Examples
Uses constant-valued floating-point calculations, consecutive additions, and a recursive descent parser’s nesting-depth diagnostic.
What you can do after
Evaluate transformations against observable behavior and diagnose a long-jump diagnostic affected by optimization.

Read how Modern C, Third Edition explains performance optimization →

100 Go Mistakes and How to Avoid Them

A compiler optimization is a transformation that improves generated program code while preserving its required behavior.

How it is used
Guides targeted Go performance work while prioritizing correctness and clarity over unnecessary complexity.
How deep it goes
Explains allocation-reduction options, compiler inlining and map lookup behavior, and benchmark pitfalls through concrete examples.
Examples
Uses a byte-slice map lookup, a mutex fast-path refactoring, and a population-count benchmark.
What you can do after
Diagnose misleading benchmarks and inspect inlining decisions with go build -gcflags.

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

React in Depth

Performance optimization is the improvement of software execution efficiency, such as by reducing unnecessary computation or rendering.

How it is used
Improves React responsiveness by reducing unnecessary state-driven renders and repeated calculations.
How deep it goes
Explains memoization mechanics, component behavior, profiling impact, and Provider selectability, but not a complete optimization taxonomy.
Examples
Demonstrates memoized and unmemoized to-do lists, repeated addition, and selective Provider data flow.
What you can do after
Apply it via React memo() and function memoization, then inspect render costs with browser performance tools.

Read how React in Depth explains performance optimization →

AI for Everyday IT

Performance optimization is the practice of improving a system's execution speed, resource efficiency, or throughput.

How it is used
Uses performance optimization to identify slow stored procedures and guide more scalable code choices.
How deep it goes
Measures average elapsed time, CPU use, and logical reads for stored procedures, while noting averages may miss execution-time variability.
Examples
Compares array lookups with Maps and ranks stored procedures by average execution time.
What you can do after
Diagnose performance bottlenecks with stored-procedure metrics and request more scalable code structures.

Read how AI for Everyday IT explains performance optimization →

Also covered in

What to know first

Related concepts

Questions about performance optimization

What is performance optimization?

Performance optimization is the systematic modification of a system or its operation to improve performance measures such as speed, responsiveness, throughput, or resource efficiency.

Which Manning books explain performance optimization?

Modern C, Vibe Engineering, Starting Data Analytics with Generative AI and Python, Acing the Frontend Interview, Fast Python: High performance techniques for large datasets, Fast by Default, Modern C, Third Edition, 100 Go Mistakes and How to Avoid Them and 2 more.

What should I know before learning performance optimization?

Manning books that teach performance optimization usually introduce performance, contract, caching and language model first.

What is the difference between performance optimization and volatile qualification?

Performance optimization is the systematic modification of a system or its operation to improve performance measures such as speed, responsiveness, throughput, or resource efficiency. In C, volatile qualification marks an object whose accesses may have externally observable effects or whose value may change independently of ordinary program execution.

What kinds of performance optimization are there?

Kinds of performance optimization include skippable reset pattern and inlining.

What is performance optimization also called?

Performance optimization is also called performance tuning.

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.