The Learn Node.js Master Package Video Course By Wes Bos Is Awesome
Last night, I finally finished my first Wes Bos video course: Learn Node.js. I opted for the Master Package, which is twice as beefy as the Starter Package. So, it's taken me a few weeks to get through it, putting in a half-hour here and an hour there, when I had time outside of work. Overall, this course is amazing. The quality is super high; the pace is on-point; and, the technical details are well balanced. Wes had an obvious flare for teaching; and his dedication and joyous attitude permeiate all aspects of the training material, creating a wonderful user experience (UX) for the student (that's me!).
| |
|
|
||
| |
 |
|
||
| |
|
|
When you land on any of Wes Bos' marketing sites, the first thing you notice is that they are "real" marketing sites. Meaning, they look great and are well crafted. He's clearly put a lot of time and effort into building his personal brand. And, when you start his video courses (Learn Node, in my case) you can immediately see that this level of polish doesn't stop at the pay-wall.
Everything about the course is refined. From the layout of his screen, to the CSS and SVG graphics of the site you build [in the course], to the font and color choices of his IDE (Integrated Development Environment) - it all looks professional. This holistic approach to quality gives the course a real-world persona, demonstrating that the value-add is not just theoretical, but concrete and transferrable to your own work.
Take, for example, rendering JSON (JavaScript Object Notation). In many of the iterations, Wes dumps API-response JSON to the screen in order to showcase the data before implementing the view template. Instead of just showing us - the students - a plain-old String, he uses a Chrome plug-in that pretty-prints the JSON, in the response, for easier consumption. This might sound like a trivial detail; but, that's just it. The course has loads of trivial details that all work together in order to craft an effective teaching platform.
One teaching technique that I found particularly helpful was how Wes used code-comments. When approach a problem, Wes would often write out the workflow using comments first. Then, he would talk about why the steps were meaningful. Then, he would go back and implement the code described by the comments. This "progressive zooming" into the solution was easy to follow and helped to create a strong mental model.
Depending on your experience-level with Node.js, some parts of the course may be more or less relevant. Thankfully, the video player that Wes uses allows the user to pick an appropriate play-back speed. The player allows for everything from 0.75x play-back speed all the way up to 2.5x play-back speed, using 0.25x increments. So, you can hurry over the materials that feels familiar and then slow down for the materials that feel new and require closer attention.
I chose to purchase the Master package rather than the Starter package so I could get access to all of the Learn Node modules. The basic demo site is built in the Starter package (the first 7 modules); but, the Master package offers more value, covering topics like user management and permissions, AJAX-based interactions, sending email, geolocation and mapping, advanced MongoDB aggregation, and application deployment. Just go with the Master package, it's a good investment in your skills.
I personally appreciated learning more about Pug (formerly known as Jade) - the default view-rendering engine used by Express.js. When I first started using Express.js (just a few months ago), Pug felt janky and hard-to-read. And, to be honest, it still feels like that to me; but, at least Wes showed me a number of ways in which I can leverage Pug in order to make shared views and helper libraries. Hopefully now, I can be more effective with this commonly-used templating language.
And, as someone who lives and breathes SQL, learning more about MongoDB was also helpful, especially when it came to the more advanced features. The aggregation pipeline looks like a beast; but, at least now I have a sense of what it can do and how it works.
If I had one criticism of the course, it was the use of the Singleton design pattern. This is not unique to this course and is a pattern that I see being used everywhere in the Node.js community. In this pattern, you require a module and depend directly on the "require" itself in order to initialize and return a globally-shared instance. For example, requiring the "mongoose" module, believing that other code has already populated the mongoose module with the necessary Schema definitions by the time you require it (creating Connascence of Timing). Coming from a non-Node.js background, I prefer an Inversion of Control (IoC) approach where your module is provided with its dependencies so that it can be remain loosely coupled to the application at large.
Of course, this is a common approach in Node.js, so teaching it makes sense - it prepares you do work in other Node.js applications and with other Node.js developers; it just strikes me as odd that this pattern is so prevalent. Perhaps this sentiment is just a reflection of my unfamiliarity with the Node.js community.
At the end of the course (well, at any time really), you can download a "Certificate of Completion" that you may need in order to put-in for corporate reimbursement:
| |
|
|
||
| |
 |
|
||
| |
|
|
This is just a fun little detail; but, it once again goes to show the high quality of thought that was put into every aspect of this course. Wes really hit it out of the park!
Learn Node is a polished and thorough video course that demonstrates how to build Node.js applications using Express.js, MongoDB, AJAX, and Pug (formerly Jade). If this is the kind of work you're getting into, I would definitely recommend this course if you want to get up-to-speed quickly. Wes is an excellent teacher with a natural teaching style that makes complex concepts easy to understand. Based on the quality of this course, I'm thinking of checking out some of Wes' other video courses.
Reader Comments
@All,
Several people on Twitter asked me how deep this course dives into Node.js itself, so I anted to leave a note here in that respect.
I would say that the context for the video course is Node.js; but, that the content of the course is definitely more focused on building web-applications with Express.js, Mongoose, and Pug (templating). It goes into those topics much more in-depth than it does for Node.js itself. For example, the course doesn't talk about things like Streams or the Cluster module or the File system module. It does talk about Node.js related functionality; but, primarily as a means to clarify or facilitate the Express / Mongoose aspects of the course.
Hey Ben, First i wanna thank you for taking the time and writing this review, it was a really nice read (and thanks for Wes for blasting it hehe)
I saw this course and was definitely intrigued by it though i did not jump on right away because i'm a front end developer and i felt like it was a bit out of my scope, but then again any knowledge is good knowledge in my book.
I guess my question is more about the "now what?" aspect of this course.
Where/how do you perceive yourself after having completed this course? I've been struggling to find work i've been doing web development now for 2 years (self taught) and yet somehow recruiters always say i don't have enough experience. everyone where i live is looking for intermediate/senior devs and no one wants to take on junior devs.
I know it's a matter of time and work. eventually with my freelance projects and other projects i constantly try to do (while balancing another full time job) i'll have enough experience and projects to show i can take on a job.
but how valuable would this course be to a recruiter let's say?
I know it's kinda vague as a question but i hope you can understand where i am going with this. and id love to hear what you have to say about it.
thank you so much!
Great review Ben, thanks for writing it up.
I'd highly recommend the https://javascript30.com/ course by Wes.
@All,
Just wanted to link to a follow-up post looking at something interesting that I learned from Learn Node:
www.bennadel.com/blog/3285-using-element-classlist-to-manipulate-css-classes-on-the-dom.htm
... using the .classList DOM property to more easily manipulate CSS classes.
@Fayek,
That's a really tough question. I personally have only had a few jobs in my life (I tend to stay in places for a long period of time). So, I don't have much hands-on experience with job searches or with doing the "Freelance" life-style (I've only worked at full-time jobs). But, I can say that where I work, we have hired some people from those freelance sites. People who essentially went from Contract to Full time work with us. So, maybe that is a route you can explore - especially since it doesn't involve recruiters - it's more direct to consumer.
As far as what Learn Node means to a recruiter, it probably doesn't mean much. But, I am not sure how much any non-work item means to recruiters. But, if you put it on your resume, it can't hurt, I suppose.
Sorry, I wish I had better feedback - but I just don't have much hands-on experience with job searching.
@Christopher,
Yeah, I saw the description for that one -- looks fun. I'll be sure to see what other stuff I can grab out of Wes' goodie back.
Hi, Ben. Great Review!
I was wondering what you meant with this
```
In this pattern, you require a module and depend directly on the "require" itself in order to initialize and return a globally-shared instance. For example, ...........loosely coupled to the application at large.
```
Can you explain it? What'd be your way of doing things? Thanks!
@Tomas,
I tend to think of a module as exposing Classes, not instances. This is not always the case, but for the most part (for example, many utility libraries don't need to be instantiated). But, for things that contain "business logic" or "behavior" that you may need to swap or test later, I would expose that as a Class. Then, I would have something in the application bootstrapping that gathers up the classes, instantiates them, and injects them into one another.
For example, imagine that I needed to talk to a 3rd-party API, and I created an HTTP client / gateway for that API. And, I needed to make that client available to some service. I would - in my server.js file (or the like) - have something like:
```
// Require modules -- gets Class constructors.
var APIClient = require( "api-client" );
var MyService = require( "my-service" );
// Instantiate classes and inject dependencies.
var apiClient = new APIClient( config.apiKey, config.apiSecretKey );
var myService = new MyService( apiClient );
```
So, essentially, I have to provide dependencies to a class when I instantiate it. Then, all of this stuff just gets cached in-memory.
I would do the same for route-handlers as well. Router handlers (or collections of handlers) are just "classes". And they can be injected with services as well.
Now, doing this all by hand is janky (though very possible). On the Angular side of the JavaScript divide, I do this all with Angular's dependency-injection. I'm planning to see what kind of DI (Dependency-Injection) systems exist for node. I'm pretty sure there's one for TypeScript; but, I haven't put aside time to look through it yet.