Learning discrete math doesn't require a textbook that costs forty dollars and a semester to parse through
I spent three weeks last year going back through the Discrete Mathematics Khan Academy modules because my team needed someone who could actually read a proof without getting lost in the notation. The module structure there is decent if you know which lessons actually matter and which ones are filler. Most people waste hours on the introductory video playlists that repeat the same definitions without ever showing you why those definitions exist in the first place. The site breaks into roughly six topic clusters: counting and combinatorics, probability basics, mathematical logic, set theory, graph theory introductions, and proof techniques including induction. The proof techniques section is where the material gets thin. The videos walk you through direct proofs and contradiction with examples from number theory, but graph theory proofs and structural induction get glossed over in about ten minutes each. I ran into a specific problem when someone on our team was trying to verify a claim about Euler paths using only the Khan Academy coverage. The lesson introduces the concept of Euler circuits with the classic Königsberg bridges example, which is fine for understanding what the problem looks like. But the practice exercises never push you past verifying whether a graph is Eulerian or Hamiltonian. They don't teach you how to construct a proof that a particular graph has no Euler path, which is what we needed for the code review. I ended up cross-referencing with a Rosen textbook chapter while using the Khan Academy modules for the definition review and basic example walkthroughs. That cut the lookup time from about an hour of scrolling through search results down to roughly twenty minutes.
The counting and combinatorics section is where this actually delivers
Most discrete math courses treat permutations and combinations as if they're separate topics. The Khan Academy material groups them together but then spends equal time on the binomial theorem, which slows down people who just want to calculate handshakes at a party or figure out how many ways you can distribute items. The lesson on Pascal's triangle connects the counting formulas to actual visual patterns, which helps when you're trying to remember which formula applies without looking it up. There is a section on the pigeonhole principle that works well for beginners but skips the generalization to multiple boxes. I encountered a case where the simplified version failed because the problem involved distributing 17 projects across 5 teams and asking whether at least one team gets four or more. The standard pigeonhole principle statement taught there would give you the answer 4, but the actual calculation requires ceiling(17/5), which rounds to 4, meaning at least one team gets 4 or more. The Khan Academy module doesn't explicitly work through this rounding detail, so I added a note in my own materials about always computing the ceiling function first before applying the principle. It saves you from making an off-by-one error on the exam.
Probability underpins everything else but the math gets weird fast
The probability modules assume you already know what an independent event is. If you don't, you will click through the conditional probability section without understanding why Bayes' theorem appears halfway through. The actual derivation gets a two-minute treatment before moving to practice problems that mostly involve coin flips and dice rolls. Real-world applications like medical testing false positives don't appear until the very end, and even then the numbers used are simplified to the point where they don't match actual sensitivity and specificity values you would see in practice. I had to pause the discrete math track entirely and fill in the probability gaps with a separate statistics module before returning. The gap shows up most clearly in the Markov chain introduction, where the transition matrices are presented without explaining how they relate to the conditional probability calculations from earlier. If you understand conditional probability first, the matrix multiplication makes sense as a compact way to represent repeated transitions. Without that foundation, you just memorize the algorithm and fail when the problem asks you to interpret what the resulting probabilities mean.
Get the Full Details
Proof by induction is covered but not deeply enough for computer science work
The standard presentation walks through proving summation formulas, which is fine for a first exposure. The weak induction example with arithmetic series is clear and the practice problems reinforce the template. Strong induction and structural induction, which you actually need for analyzing recursive algorithms and data structures, get mentioned in about five minutes total across two videos. The exercise sets skip structural induction entirely, leaving you to figure out how to prove properties of binary trees or parse trees on your own. When I was preparing materials for a junior developer bootcamp, I created a supplementary exercise set that connects induction to algorithm correctness proofs. The Khan Academy modules give you the mechanics but not the application context. A program verification proof requires stating a loop invariant, proving initialization, maintenance, and termination. The discrete math section doesn't cover loop invariants at all, which is a real gap if your goal is to write correct code rather than pass a math exam.
Set theory and logic move too quickly for actual fluency
The logic section introduces propositional calculus, truth tables, and basic predicate logic. It covers De Morgan's laws and logical equivalence transformations, which are useful for simplifying boolean expressions in code. The set theory portion handles unions, intersections, complements, and basic cardinality arguments. Both sections move fast enough that you finish the lessons feeling like you understand the operations, but you cannot yet manipulate arbitrary set expressions or convert between predicate logic forms without looking up the rules. The one edge case that trips people up involves nested quantifiers. The Khan Academy material states the difference between universal and existential quantifiers but does not work through examples where the order matters, like in the definition of continuity or limits. If you are taking a rigorous analysis course later, you will encounter this gap immediately. The workaround is to spend additional time on the practice exercises in the predicate logic section and create your own examples translating English statements into formal notation with mixed quantifier orders.
Graph theory exists but stays surface level
Vertices, edges, degree sequences, connectivity, and basic traversal algorithms get coverage. The breadth-first search and depth-first search explanations connect directly to the implementation patterns you use in coding interviews. The module stops short of weighted graphs, shortest path algorithms, and network flow, which means you will need supplementary material for any practical application in routing or optimization. I needed graph coloring proofs for a scheduling problem and found that the induction coverage here does not extend to chromatic polynomials or the four-color theorem references that typically follow. The material mentions planar graphs and Euler's formula V - E + F = 2, which is useful, but proving that planar graphs are 5-colorable requires combining the induction framework with discharging arguments, which absolutely does not appear in the Discrete Mathematics Khan Academy lessons. I filled that gap with a single chapter from Diestel's Graph Theory, which took about two hours to read through the relevant sections.
Practical usage pattern
The modules work best as a reference or first exposure tool rather than a complete course. Spend about forty minutes per lesson on the actual material, then immediately attempt every practice exercise before moving on. If you score below seventy percent on the exercise sets, revisit the lesson and watch the video a second time at one-and-a-half speed to catch the parts you missed. The material itself does not adapt to your performance, so you need to track your own weak points and return to them manually. The certificate system provides minimal value beyond checking off completion. Employers in technical roles do not recognize it, and the content depth does not match what a university course requires for credit. Use the site for definition review, basic example walkthroughs, and practice problem generation. Do not rely on it as your sole preparation for a midterm or technical interview. For counting problems specifically, the site's exercise generation creates random variants that help you recognize the pattern faster than working through static textbook problems. The set theory exercises are weaker because the automated grading cannot distinguish between equivalent but differently formatted set-builder notation responses. You will need to verify your answers against the solution explanations manually rather than trusting the instant feedback.
What it does not cover
Recurrence relations beyond basic linear homogeneous forms, generating functions, Burnside's lemma for counting under symmetry, advanced graph algorithms including Dinic's method or Edmonds' matching algorithm, model theory or computability foundations, and any application to cryptography or coding theory. If your goal is computational complexity or algorithm design, the discrete math track leaves significant gaps in the theoretical machinery you actually need. The site also does not provide written notes you can export, which slows down people who prefer to have a reference document while studying. The only downloadable content is the exercise sets in PDF format, and those are static images of the problem statements without worked solutions. I created my own summary sheets by copying the key definitions and theorem statements into a separate document, which took roughly three hours to compile across all the modules but paid off when I needed quick lookup during a closed-book exam.
Bottom line on time investment
A complete pass through all six topic areas, including practice exercises and review of incorrect answers, takes about eighteen to twenty-two hours. The content quality is sufficient for undergraduate introductory courses but insufficient for graduate-level preparation or professional certification exams that test proof construction beyond the template forms presented here. If you need deeper coverage, pair this with a textbook like Rosen or Grimaldi for the sections that move too fast, and use the Khan Academy modules primarily for the combinatorics and basic logic reviews where the video explanations actually add clarity over reading the text alone.
