Over a million developers have joined DZone.

A Review of Learning Node.js LiveLessons

DZone's Guide to

A Review of Learning Node.js LiveLessons

· Performance Zone
Free Resource

Evolve your approach to Application Performance Monitoring by adopting five best practices that are outlined and explored in this e-book, brought to you in partnership with BMC.

One Minute Bottom Line

"LiveLessons are like being able to watch over an experienced programmer’s shoulder as they work. It's an integrated package of high-quality video, an experienced teacher, and great content, which creates an engaging learning experience." The video format may present some challenges, most of which can be solved by buying the companion book. So If you are looking to learn Node, buy the videos and book together for best results.

By: Marc Wandschneider

Published by: Addison-Wesley Professional

Reviewer Rating: 4/5 stars Only the limitations of the video format keep me from giving this a 5 star review.

There are 12 videos in the series:

   •   Getting Started – 52 min.
   •   A Closer Look at JavaScript – 68 min.
   •   Asynchronous Programming – 39 min.
   •   Writing Simple Applications – 51 min.
   •   Modules – 61 min.
   •   Expanding Your Web Server – 63 min.
   •   Building web Applications with Express – 78 min.
   •   Databases I: NoSQL (MongoDB) – 67 min.
   •   Databases II: SQL (MySQL) – 49 min.
   •   Deployment and Development – 78 min.
   •   Command-Line Programming – 39 min.
   •   Testing – 20 min.

Production Values

This video series may not be as high energy and glitzy as a code school production, but it covers far more ground in much more detail. With the exception of an editing gaff in the first video (The editor misses the author’s editing request; as a result we watch as node compiles silently for several minutes.), and a bit of non-normalized audio in lesson three. The production values are very high. Time was taken to produce quality graphics where others would have used a hand drawn whiteboard capture.

Marc’s Strength as a Teacher

As someone who has done a lot of user training over the last 20 years, It quickly becomes apparent that Marc Wandschneider is a skilled teacher and felt comfortable, not only with the material but with presenting, teaching and the camera. I would have liked to see him inject a little more humor into the first few video introductions like he did in the last few lessons, especially since this is the only place where we see him. The majority of the content is him thinking out loud as he codes (where we only see his screen).

While the book and the videos cover the same information, this is not a case of the instructor reading a monotone voice from his own book. The videos actually contain more information than the book does.

I like that he did not edit out his errors and typos, this not only makes him more human like the rest of us, but also provides a teachable moment. However, I would have liked to see him take a little more time to discuss the error and its possible causes. He is sometimes too quick to jump back to his editor before the viewer has a chance to really see the error message, or consider its cause.

Content and Ordering

While he ad libs some basic examples, it is clear he is working from a lesson plan with clear goals and objectives. All of the lessons contained high quality content, but a few stood out.
I was pleased to see Mac, Linux and especially Windows all receiving equal coverage throughout the series. Lesson One covers installing Node on all three platforms. Similarly, the deployment, command line and database lessons cover Windows and some workarounds for Linux utilities which may not be included with windows (e.g. setting up node to run as a windows service).
The coverage of basic debugging techniques in lesson one presented some better alternatives to peppering the code with console.log statements. I also liked that this material came early in the book, as writing and debugging async code does present some new challenges.

Marc’s coverage of JavaScript basics (which in other books would have been omitted or relegated to an appendix), while obviously not a complete JavaScript primer, does address the most common source of errors and differences between async and synchronous programming (e.g. Truthiness, NaN, error handling, prototype object usage).

Video five, which covers NPM and Node packages, contains the best explanation of the dependency management features and package loading rules of NPM I have seen anywhere. Marc clearly laid out the path that would be searched, how modules mapped to the file system, and how this allowed using multiple versions of the same package in the same application.
Several of the videos included a discussion of alternative coding styles seen in the wild (e.g. stream handling). This is especially important as he notes in a relatively young and fast moving language like node.

Anyone who is planning to develop an API could go a long way towards getting it right by watching the short sub lesson the author provides on the topic.

I liked the early focus on error handling and its importance in writing production-quality code, something that Node makes easier with the first argument to most functions being an error object, but would have liked to have seen testing treated the same way, rather than being relegated to the last video. I am a firm believer in the idea that you play like you practice. This editorial choice is all the more glaring given the author’s comment (in an earlier lesson) that the code written in a lot of books (lacking error handling) can lead to lots of error-prone code in production. This choice also stands out because Marc has done an excellent job of handling additional topics as they arose (e.g. refactoring, code organization, security, and API design).

There were several topics I initially thought were introduced too early. Writing and publishing a package was discussed in Lesson five, despite the fact that the viewer had, at this point, very little experience writing Node code, and even less writing code that was ready for public consumption (though the author did cover how to create private modules). Similarly I thought the introduction of the async module was too advanced a topic for the current user’s ability. However, in both cases I was wrong. Instead of confusing the student, they showed best practices for code reuse and organization. The use of the async module made the code easier to read and eliminated several layers of nesting (this was especially noticeable when I was reading the companion book on my tablet). I also questioned why he chose to use JSON and curl. Wouldn’t viewing the page in the browser have been more familiar and rewarding for the student? But again, these choices made it easier to write and test a single application that featured both a web application and an API. If I may so bold as to make a suggestion to address this issue, it would be to spend a little more time addressing the "why" question, not just the "how."

There are a few things I would have liked to have seen added to these lessons. While each lesson begins with an introduction to the lesson and the topics to be covered, I would have liked to have seen a short wrap up video at the end of each lesson. These could provide a recap of the lesson, but additional resources and exercises for the reader.

The book contains an introduction, which provides some background on the author and answers some important questions. Who is the author? What are his qualifications? What is node? Is this series of videos for me? Ideally, these could be offered for free on the book/video information page.
The author repeatedly restarts the server manually after making a code change. I would have liked to seen nodemon or supervisor introduced as a means of avoiding this.

In the deployment chapter, I would have liked to have seen the app deployed to one or more cloud providers (e.g. AWS, Heroku, Nodejitsu).

Limitations of the Video Format

The major weakness of these lessons results from the limitations of the video format. The downloaded videos do not have an easy way (at least not one that I found) to jump to a specific sub lesson. Most of the videos are around an hour long and comprised of several short segments. This makes finding a specific section or resuming where you left off harder than necessary. I just left the window open where I left off, which worked great until my machine restarted after performing a windows update. Perhaps, instead of a monolithic download the lessons could be broken up into smaller files and made available as a zip file. I would also suggest is renaming the video file’s so that they match the books’ chapter titles (rather than Lesson_01 etc.).

Since you can’t search the video by keyword like a book/eBook, I would have liked to seen the inclusion of a transcript or at least show notes. If the transcript included time codes for the start of each sub lesson, and links to additional web resources (e.g. documentation, the async module), not only would this improve the usability, but the accessibility as well.

You may need a large screen to view these videos. The majority of each video is a screen capture of the author’s desktop, and this may be too small for effective viewing on the smaller screen of a tablet or netbook.

The best way to overcome most of these issues is to buy the companion book – both are well worth the price.

Note: Live lessons are not available from Amazon, but can be purchased directly from informit.com.

Learn tips and best practices for optimizing your capacity management strategy with the Market Guide for Capacity Management, brought to you in partnership with BMC.


Opinions expressed by DZone contributors are their own.


Dev Resources & Solutions Straight to Your Inbox

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.


{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}