Skip to main content

Data Structures and Algorithms: Binary Search

Jonathan Lee Martin's Pro-tier deep-dive: about 1.1 hours coding six different binary search algorithms in JavaScript, where each solution teaches a craftsmanship lesson.

Quick answer​

Binary Search is a 1.1-hour, Pro-tier, advanced course taught by Jonathan Lee Martin. Rather than survey many algorithms, it goes deep on one: you code six different binary search implementations, each chosen to illustrate a software-craftsmanship idea. It is a narrow, deliberate deep-dive, the opposite of a broad survey, and it pairs with the same instructor's merge sort course. Worth it if you want to think about how to write algorithms well, not just make them work.

Is it worth your time?​

The idea of implementing the same algorithm six different ways sounds repetitive, but that is the point: each version teaches a distinct lesson about writing clean, correct, well-shaped code. If you already understand what binary search does and want to level up how you write algorithms, this depth-over-breadth approach is genuinely instructive.

The honest caveat is that it is narrow and assumes a lot. It is marked Advanced, it does not teach the concept of binary search from scratch, and at 13 lessons it is a focused exercise rather than a curriculum. If you want broad algorithmic coverage, this is the wrong shape of course.

What you'll learn​

Across 13 lessons you implement binary search six different ways in JavaScript. The variety is intentional: each implementation surfaces a different craftsmanship lesson, from edge-case handling to readability to how you structure a recursive versus iterative solution. The takeaway is less "how binary search works" and more "how to write any algorithm thoughtfully."

It is a deep-dive by design. The breadth lives in the broader Data Structures and Algorithms course; this one trades range for depth on a single, well-chosen problem.

Who it's for, and who should skip it​

It fits developers who already understand basic algorithms and want to sharpen how they write them, treating one familiar problem as a lens on craftsmanship.

Skip it if you need a broad introduction to data structures and algorithms; start with the general Data Structures and Algorithms course instead. Also skip it if you have never encountered binary search, since this does not teach the concept from zero.

Prerequisites​

Comfortable JavaScript and a basic grasp of what binary search is. The course is about implementing it well, not explaining the idea, so bring that understanding with you.

Where it fits​

It is a focused deep-dive that complements the Frontend Developer Path and the Fullstack Developer Path, best taken after the broad Data Structures and Algorithms course and alongside its sibling merge sort deep-dive.

Free or Pro​

This is a Pro course, so it requires a Scrimba subscription. Pro also covers the full career paths, the coding challenges, the Discord, and certificates. See current plans for what Pro costs in your region.

Strengths and limits​

What it does well: the six-implementations approach turns one familiar problem into a focused lesson on writing algorithms well, and Jonathan Lee Martin frames each version around a concrete craftsmanship idea.

Where it is limited: it is deliberately narrow, it assumes you already know what binary search is, and at 13 lessons it is an exercise rather than broad coverage.

View Data Structures and Algorithms: Binary Search on Scrimba (opens in a new tab)

Related Guides

Next step

All Courses

Docs
Last updated on