Plenty of developers will tell you they “never use math” at work. Then they spend an afternoon debugging why a query slowed to a crawl at 10 million rows, or why a game character clips through the floor. The math was there all along; it just wasn’t labeled as math.
You don’t need a pure math degree to be a good engineer. But a handful of topics come up again and again in real codebases, technical interviews and code reviews. If you’re a CS student heading into your first dev job, these are the ones worth refreshing now, while you still have time to practice.
1. Logarithms, Exponents and Big-O
If you only refresh one topic, make it this one. Big-O notation is how engineers talk about performance, and it’s built almost entirely on exponents and logarithms.
The key intuition: a logarithm answers “how many times can I halve this?” That’s why binary search is O(log n). Searching 1,000,000 sorted items takes about 20 steps, because 2²⁰ is roughly a million. Double the data, and you add just one more step.
Exponents run the other way. An O(2ⁿ) algorithm that handles 20 items fine can take hours at 50. Spotting the difference between O(n log n) and O(n²) in a code review is a practical, everyday skill.
What to practice: log rules (log(ab) = log a + log b), powers of two up to 2³², and estimating the runtime of nested loops by hand.
2. Scientific Notation and Very Large (or Tiny) Numbers
Developers deal with numbers across wild ranges. A database might hold 4.2 × 10⁹ rows, while a latency measurement might be 3.5 × 10⁻⁴ seconds. Scientific notation lets you compare these at a glance instead of counting zeros.
It also explains how computers store decimals. Floating-point numbers are essentially scientific notation in binary: a significand times a power of two. That’s why this happens in JavaScript:
0.1 + 0.2 === 0.3 // false
0.1 + 0.2 // 0.30000000000000004
Neither 0.1 nor 0.2 can be stored exactly in binary, so a tiny rounding error creeps in. Knowing this saves you from bugs in prices, measurements and any comparison of decimals.
What to practice: converting between standard and scientific notation, reading values like 1e-9, and comparing floats with a tolerance instead of ===.
3. Quadratic Equations in Game Physics and Graphics
Quadratics show up whenever something moves under constant acceleration. A jumping character, a thrown object or a falling particle all follow a parabola. If a character jumps upward at 10 m/s under gravity of 9.8 m/s², its height over time is:
h(t) = 10t − 4.9t²
Want to know when it lands on a platform 3 meters high? Set h(t) = 3 and you get 4.9t² − 10t + 3 = 0. Solve with the quadratic formula, x = (−b ± √(b² − 4ac)) ÷ 2a, and you get two answers: about 0.37 seconds on the way up and 1.68 seconds on the way down.
The discriminant (b² − 4ac) is the part developers lean on most. If it’s negative, there’s no real solution, which in a game means the jump never reaches the platform. The same check powers ray–sphere collision tests in graphics and ray tracing.
When you’re implementing this in code, it helps to verify your output against a quadratic equation solver that shows each step, including the discriminant and complex roots. That makes it much easier to spot whether a bug is in your math or in your code.
What to practice: the quadratic formula, reading the discriminant, and handling edge cases like a = 0 in your implementation.
4. Modular Arithmetic
The % operator is easy to use and easy to misunderstand. Modular arithmetic is behind hash tables, circular buffers, cryptography, and plenty of simple tasks like “is this number even?” or “wrap this index back to the start.”
One trap catches a lot of new developers: in JavaScript, -7 % 3 returns -1, not 2. If you’re wrapping an array index backwards, you need ((i % n) + n) % n to stay positive.
What to practice: remainders, wrapping indexes, and the basics of how hashing spreads keys across buckets.
5. Basic Statistics: Averages, Percentiles and Spread
Once your code is in production, you’ll read dashboards full of statistics. The most important lesson: the average often lies.
If 99 API requests take 50 ms and one takes 5 seconds, the mean is about 100 ms. That number describes no real user. This is why engineering teams track percentiles like p95 and p99, which tell you what your slowest users actually experience.
What to practice: mean versus median, percentiles, and standard deviation. These come up in performance monitoring, A/B tests and any feature built on data.
6. Linear Algebra: Vectors and Matrices
Linear algebra sounds academic, but it sits behind graphics, game engines, animation and most of machine learning. The good news is that you only need a few core ideas to get started.
A vector is just a list of numbers that describes a direction and size, such as a character’s position or velocity. A matrix is a grid of numbers that transforms vectors, rotating, scaling or moving them. Every time you use a CSS transform, rotate a sprite or move a camera in a 3D scene, matrix math is doing the work behind the scenes.
The dot product is one of the most useful operations. It tells you how closely two vectors point in the same direction. For vectors a = (3, 4) and b = (4, 3), the dot product is 3 × 4 + 4 × 3 = 24. Since both vectors have a length of 5, the cosine of the angle between them is 24 ÷ 25 = 0.96, so they point in almost the same direction.
That same calculation shows up everywhere. Game engines use it to work out lighting, by comparing a surface’s direction with the light’s direction. Search and AI systems use a version of it, called cosine similarity, to compare embeddings and decide which documents or products are most alike.
What to practice: vector addition, the dot product, vector length, and multiplying a 2×2 matrix by a vector by hand.
Final Thoughts
You don’t need to master every branch of mathematics before your first dev job. Focus on the topics that show up in real work: logarithms for performance, scientific notation for floating-point, quadratics for motion and collisions, modular arithmetic for hashing and wrapping, statistics for reading production data, and linear algebra for graphics and machine learning.
Refresh these now, practice them in small coding exercises, and you’ll walk into your first role able to explain not just what your code does, but why it behaves the way it does.
