Computer Science Fundamentals
Computer science fundamentals are the difference between an engineer who can code and an engineer who can debug. When a production incident hits and the response is 'why is this O(n²)?' or 'why is this hashmap performing worse than a list?', the engineers who ship the fix are the ones who never let their algorithm and data-structure knowledge get rusty. This track is a working refresher — not an interview cram, but a practical tour of the primitives every backend engineer relies on.
What this track covers
Big-O reasoning, arrays vs linked lists, stacks and queues, hashmaps (and why they degrade), trees and binary search trees, heaps and priority queues, tries, graphs, and the algorithm families you actually reach for in production code — searching, sorting, recursion, BFS/DFS, greedy, dynamic programming, two-pointer and sliding-window techniques.
Who this is for
Backend engineers preparing for interviews, engineers debugging performance problems that turned out to be algorithmic, and anyone whose university CS is now more than five years in the past.
Prerequisites
- Basic fluency in at least one language
- Willingness to sketch on paper — this track is easier with a pencil
Recommended learning order
// beginner
Start with the Big-O guide, then read through the data-structures guide from arrays to hashmaps. Do one exercise per structure — not twenty.
// intermediate
Move to trees, heaps and graphs. Add BFS/DFS and one classic problem per structure. This is where interview preparation and production intuition merge.
// advanced
Dynamic programming, greedy vs DP boundary, two-pointer and sliding window, and the harder graph problems (topological sort, shortest paths). At this level the material serves both interview prep and production performance work.
Common mistakes to avoid
- Memorising solutions instead of the underlying pattern — you fail every problem that is one twist away
- Assuming a hashmap is always O(1) — collisions and poor hash functions can push it toward O(n)
- Confusing average and worst case — quicksort is O(n log n) average, O(n²) worst
- Practising only leetcode-style puzzles and being unable to spot the same pattern in production code
- Skipping the fundamentals track because 'I passed the interview' — the material is more useful after the interview than before
Career relevance
CS fundamentals gate every high-signal engineering interview at competitive companies, and they resurface every time a production system hits an algorithmic performance wall. This is the most durable material on the entire site — the frameworks change, big-O does not.
Featured tutorials in this track
No tutorials published in this track yet — new content drops every week.