Review: JavaScript Algorithms and Data Structures Masterclass
It's a bit of a running joke in web dev Twitter that everyone has a bunch of unfinished coding classes and they keep buying more. I'm here to tell you that it is possible to finish one! I have done it. It took me a little over two years (off and on) but I finally finished Colt Steele's JavaScript Algorithms and Data Structures Masterclass course on Udemy. This post is my review of the course. So if you're thinking about purchasing it and wondering whether it's worth the time and money, I encourage you to read on!
Course Overview
JavaScript Algorithms and Data Structures Masterclass is a virtual crash course on selected bits of formal computer science course material, namely (as you can likely infer from the course title) algorithms and data structures.
An algorithm is nothing more than a process for doing something, like finding a single piece of data within a larger data set (for example, all instances of the letter "i" in the string "animosity"), or sorting a data set (for example, sort the contents of the array [9, 2, 1, 4, 6, 7, 3, 8, 5] in ascending order, like [1, 2, 3, 4, 5, 6, 7, 8, 9]). When coding a sorting algorithm, the strategies for determining where 9 goes in the sorted array as opposed to 1, and how to get those values to where they need to go is what you achieve with code. This is something this course teaches you about.
A data structure is a format for structuring different data. An example might be an order ticketing system in the kitchen of a restaurant. If you take three food orders, you might be expected to complete and deliver the orders sequentially, so you need to complete the first order before moving onto the second order and then the third order. A data structure that could help you achieve this is a Queue, and for any Queue you should be able to add items (like food orders) to the end of the Queue and remove items from the beginning of the Queue. When coding a data structure, these are the kinds of methods you achieve with code, and that is also something the course teaches you about.
There are two main reasons you would learn about algorithms and data structures:
- Understanding these computer science fundamentals makes you a better programmer, improves your craft, and overall introduces you to a more analytical way of thinking and solving problems
- Questions about algorithms and data structures are common interview questions at places like Google or Facebook for programming jobs
The second point here is typically the main motivator. There are a lot of sentiments to be expressed about how technical interviews are formatted, but this post won't get into them. The point of this course is to focus on the computer science topics that are commonly asked about when candidates are interviewing for well-paying jobs at big tech firms.
Prerequisites
There are three things you need going into this course to be successful:
First you need a basic understanding of JavaScript. The course itself will strengthen your JavaScript skills, but it does use a lot of standard language features that you should know how to perform on your own. You'll be writing a lot of functions, expressions, and methods on objects, so you should be able to do some basic functional programming. Aside from creating data structures, the course also examines the use of arrays and objects as built-in data structures, so being able to perform dot and bracket notation to access data within arrays and objects is a must. From crawling through built-in objects and arrays and the data structures you compose (like Linked Lists or Queues) to the sorting and searching algorithms, you need to know how to do some basic iteration in JavaScript. This means you should understand the various Loops in JavaScript, notably while Loops, do...while Loops, and for Loops. Finally, a basic understanding of JavaScript Classes would be beneficial.
The second thing you'll need is a place to do the programming in the course. Naturally in order to access the course you'll need a Udemy account and to have purchased the course. But to actually write and run the algorithms and data structures, you need to be able to write and run JavaScript. If you have a machine set up with Node.js, you're probably in good shape to run things in your terminal. But Colt also shows you how to write and run the course programs in Chrome developer tools. In fact, the bulk of the programming in the course videos is done as Chrome Devtools snippets.
The last thing you'll need to complete this course is a real drive to learn. I'll be honest, algorithms and data structures are not the most interesting things in the world. Colt does what he can to keep the material engaging, and he does explain things very well, but I definitely struggled to stay motivated all the way through the course.
Course Structure
So with the prerequisites lined up, what does the actual course content look like?
It starts out with a nice, thorough examination of Big O Notation, which is how the performance of programming operations is measured, both in terms of number of operations (time complexity) and how much memory a program uses (space complexity). This is a great and natural starting point, because Big O Notation gets referenced in every single unit after. It's key to understanding what makes one sorting algorithm run more quickly than another in certain applications, or why certain data structures are better fits for certain kinds of data than others.
Colt then covers some general problem solving strategies. This isn't really specific to programming, and is instead more of a framework for approaching any challenges, but can be specifically applied to white boarding or technical screening interviews. This gets followed by a deep dive into recursion and following a program's runtime through call stack tracing. There are optional challenges along the way where you can apply those problem solving strategies and practice your technical screening approach.
Colt then gets into algorithms. He first covers searching algorithms, which involve figuring out the most efficient way to extract a piece of data from an array or a string. He then dives into sorting algorithms, which are different methods for sorting the data within an array. The first three sorting algorithms are the Quadratic Sorting Algorithms: Bubble Sort, Selection Sort, and Insertion Sort. Then the course moves onto some more advanced sorting algorithms: Merge Sort, Quick Sort, and Radix Sort.
The course then digs into a handful of commonly taught data structures. Colt briefly covers native JavaScript data structures, like arrays and objects, but then he guides you through constructing non-native data structures. These start out simple, with Singly Linked Lists, Doubly Linked Lists, Stacks, and Queues, but then get progressively more complicated, with Binary Search Trees, Binary Heaps, Hash Tables, and Graphs. You program these as JavaScript Classes, and write each of the methods within them - like adding data to a Stack, removing data from a Queue, traversing a Tree, or reversing a Singly Linked List.
The course sort of culminates with an examination of Dijkstra's Algorithm for the second to last section. This algorithm, which figures out the shortest path between two points on a Weighted Graph, builds upon several of the data structures and sorting algorithms covered in earlier sections of the course. As such it really requires a good handle on everything taught throughout the course.
The final section of the course (as of the time of writing) focuses on Dynamic Programming, specifically the Fibonacci Sequence. Colt walks through the characteristics of a dynamic programming challenge, and goes from an unoptimized recursive solution to the Fibonacci Sequence through two vastly improved solutions, one that improves the time complexity and another that improves the space complexity. And that's the end of the course. There are optional challenges at the end of the course, but by Colt's admission many of them are not finalized.
Overall Thoughts
So what's my final verdict? Was this course worth it? Am I now a master practitioner of algorithms and data structures?
I am absolutely not a master of the course material, but I do think the course is worth it for anyone looking to sharpen their programming skills and preparing for technical job interviews. Overall, I come away with a much better understanding of the broader topics, and the exercises provided are a great starting point if I wanted to drill on things like recursion or sorting algorithms. Truthfully, these topics don't come into play a whole lot in the daily professional programming that I do, so they aren't something I really have committed to memory.
I gained a much better understanding of Big O Notation from this course than I did from my coding bootcamp. I still struggle with recursion, but I now know more about how to follow recursive function calls through the stack trace. I'll probably never remember how to construct any of the sorting algorithms (or most of the more advanced data structures) from scratch in a technical interview, but I definitely feel more at home with them.
This course also made me a much stronger JavaScript developer. The coding examples embrace Class Constructors in a way I haven't really encountered elsewhere, and I have a vastly improved understanding for how an array performs certain operations. It turns out it's way more taxing for an array to insert or delete anything at the beginning of the array than at the end, because the array then has to re-index everything that follows. Something to consider when reaching for .push() vs. .unshift() or .pop() vs. shift().
I am also much more at home working in the Google Chrome Dev Inspector. I'm still by no means an expert in setting breakpoints and analyzing the call stack, but writing and saving code snippets in your browser (that then transfer between your Chrome instances across devices if that's how you have things set up!) and debugging/walking through a recursive function call stack definitely gives you an appreciation for how powerful a tool Chrome is and makes you a better debugger.
Finally, let's be real for a moment. No one really takes a crash course on algorithms and data structures if they're not hunting for a job, so I want to speak to that aspect of taking this course. I bought this course on January 1, 2021 because I saw a New Year's sale on Udemy. For a bit of context, I launched v.1.0.0 of this portfolio site just a month before, on December 2, 2020. My mind was made up at that time that I would work on getting a new job and advance my career. I did a bunch of tech interviews throughout 2021, got a couple of offers from some wonderful companies, and signed my offer letter from Sprout Social on January 5, 2022.
I cannot attribute all of my success to this course. As a matter of fact, in the take home technical challenges, I did another one of Colt's courses, Learn Webpack to help me deliver a bundled, minified, and purged technical submission. I was also writing a ton of blog posts around that time - at least one a week, exploring array methods, solutions to Leetcode challenges, JavaScript fundamentals like Undefined vs. Null, and a whole series on JavaScript Promises. The truth is, I was really focused and working hard on that job search and learning in a very open way on this blog.
So while I was successful in getting a new job that I love, the JavaScript Algorithms and Data Structures Masterclass was just one part of my push to get that new job. That said, it did play a big part and it helped me gain a lot of confidence in topics that came up in technical interviews. This course is really like eating your programming vegetables. It's not always glamorous or fun, and it's terrifically hard to get motivated to jump back in sometimes, but it does make you a better programmer, and it really bolsters the tough mindset that I think you have to have to go into a programming job hunt and come out successful on the other side.
I also want to express my support for anyone who is going through a job search right now. It's rough, but keep going. I absolutely believe in you. Don't get discouraged if you get turned down. The effort and care that you put into your search will see you through this really tough process. If you're going so far as to invest in your programming skills by taking a course like this, then any company is going to be very lucky to have you. Comradery doesn't go very far when you're facing rejection for something you've put a lot of time and effort into, especially with technical challenges, but I've been where you are and I know you'll make it through.
There were rough days where I was going through it all: putting out blog posts, applying to positions that felt like major stretches, struggling to complete and submit technical challenges I could stand behind, making it to final interview rounds, only to be rejected after all of that effort and getting my hopes up. When that happened, the last thing I wanted to do was keep going with this dry and academic Udemy course, but I would take an afternoon to go outside and get a break from my screen, then come back and fire up one of these videos and get back into the cycle. Perspective is everything; I bought this course on January 1, 2021. From that time, it took me one year and five days to sign my offer letter, but it took me two years and fifteen days to actually complete the course.
So if you're looking to take the leap into a technical job search and JavaScript is the programming language you want to do those technical challenges in, I wholeheartedly endorse this course. Even though the material is pretty dry at times, Colt teaches it really well. He breaks down complex problems and concepts very clearly, and brings in humor, stories, and fun (but relevant) illustrations as he's able to. It clearly took a painstaking amount of time and attention to detail to prepare his slides to walk through some of the algorithm call stacks, but that care really shines through and makes the course videos a timeless and reliable resource for brushing up on algorithms and data structures.
My main problem with the course is that (as far as I'm aware) it's only available on Udemy. I have conflicted thoughts on that platform that I won't get into here except to say that it's at times a very buggy learning platform, which can get in the way of watching the videos or completing the challenges. With material this dry, any friction toward completing the task really does the course and the student who paid for it a disservice.
Bring Back Blogging Plug
Since we're still in January and this is one of my three posts as part of Bring Back Blogging, I want to take a quick moment to highlight another dope blog that I found through BBB, which is Light From Space. This little blog by Thomas Fuchs highlights Thomas's incredible astrophotography. Beyond being flush with beautiful images of the heavens, Thomas fills his posts with details about the various heavenly bodies he's capturing, as well as information about the photographs themselves - the gear used, the exposure and resolution, and the shooting location. Very interesting and lovely stuff.
From a tech standpoint, Light From Space appears to be powered by Ghost, which is a powerful, open source CMS built on React that I am very interested in.