JavaScript Technology Writing

My Last O’Reilly Book

The editor for JavaScript Cookbook, 3rd edition, just sent me a draft to review and comment on. This is the last of the O’Reilly books that will feature my name on it. I wasn’t actively involved in it; my name is on it because they kept about 15% of my old content. New authors, Adam Scott and Matthew MacDonald, took on the majority of the work.

They did a good job, too. I particularly like the chapter devoted to error handling. The days of using an alert message to debug have been gone for decades, and JS developers now have sophisticated error-handling techniques and tools. It is no longer your Mom’s JS.

Good. I’m happy the language and its uses have evolved. But…

I sometimes miss the simpler days when an alert was your JavaScript best friend.

I’ve been working with JavaScript since it was first introduced over 25 years ago. Not just traditionally in the web page, either. I worked on a small project that used Netscape’s server-side JavaScript (LiveWire) in the 1990s. It was so very different from an application made with Node. as you can see for yourself from an old Dr. Dobb’s article on LiveWire.

Writing about JavaScript today requires a different mindset than writing about it years ago. Then, JavaScript was laughably simple. It’s simplicity, though, was also its strength. In its infancy JavaScript was so embraceable. You could literally toss a tiny blurb of JS into an HTML file, load it into a browser, and see an immediate implementation. You didn’t have to fiddle with compilation, installing special developer tools, or figure out a framework.

My first book on JavaScript, the JavaScript How-To for Waite Group Press was published in 1996. The hardest part of writing it was trying to find enough about JavaScript to actually fill a book.

JavaScript today, or ECMAScript if you want to be pure, is not so simple. And oddly enough, that’s its strength now: it is powerful enough to meet today’s very demanding web applications. And the hardest part of working on a book such as the JavaScript Cookbook is limiting yourself to the essentials, because you could easily write three or four books and still not envelop the world of JavaScript as it exists now.

When O’Reilly asked me to do a new edition of the Cookbook I knew I just didn’t want to take on that kind of burden again. It was hard to give up control of one of my favorite books, but after 25 years of working to deadlines and dealing with tech editors, I knew I just didn’t have the energy or patience to do the book justice. I knew it was time for me to hang up my drafts.

Thankfully, the new Cookbook team have done an exceptionally good job. I’m happy to have my name on the Cookbook, one last time.

If I write now, it’s solely for me: my ideas, my deadlines, my expectations. I may only write in this space. I may try my hand at self-publication.

Who knows? Maybe all I’ll do is write incendiary commentary in Facebook and Twitter and see how often I can get banned.


My Current Version of Learning Node

As we finished up Learning Node, 2nd, the Node.js Foundation released Node version 6. I quickly did a run through to see if I needed to modify the book text. Yes, indeed, I did.

One of the major changes was how new Buffers are created. This is a major change, considering how integral Buffers are to Node. I hastily re-wrote the section on Buffers in the book, noting that the existing examples demonstrate how to create a Buffer in Node 4.x, but not Node 6.x and later. I also provided additional examples for Node 6.x.

Another major change was how to refer to the fast lane version of Node.js, originally called “Node Stable”. Now, it’s referred to as “Node Current”.

I may have influenced this change. I filed bugs last year about the Node documentation.  One bug had to do with the confusion surrounding which version of Node should be the “default” API.

The Node.js Foundation recommends the LTS versions for production use, because of their long-term stability (hence the name). However, if you access API documentation for Node.js directly, such as searching for Buffer in Google, you’ll get the new Current version.

We went back and forth in the comments about the problems inherent with having the least stable API as the default documented API. I also repeatedly pointed out the problems when you have multiple “current” versions of Node (LTS and Stable), and how would people know which is the current version of Node.js?

To be honest, I didn’t see renaming Stable to Current to be one of the possible solutions. That’s a bit like sweeping dirt under the rug. Oh look! We can’t see the dirt now!

Back to finishing up the book. I quickly changed Stable to Current where applicable. What’s done is done. I hope the book does well.

This is my last book on Node. I may, in the future, write other books on technology, but not Node. Change is the byword for the Node community and that doesn’t translate well when it comes to writing books. I will, eventually, return to technical writing here at Burningbird in addition to my other writing, and I will write about Node. But no books.

And when I write on Node, it will be the current version. Whatever that may be.



Technology Writing

Learning Node, 2nd Edition is now live

Learning Node 2nd cover

Learning Node, 2nd Edition is now in production and should be hitting the streets within a few weeks. We had a bit of excitement when Node 6.0 was rolled out, just as we entered production. However, this edition of the book was specifically designed to accommodate Node’s rather energetic release schedule, and the book survived with only minimal changes.

In this edition, I focused heavily on the Node core API, rather than third-party modules. I figured the book audience either consists of front-end developers working with JavaScript in the browser, or server-side developers who have worked with other tools. In either case, the audience wants to know how to work with Node…not this module or that. Node, itself.

My one trip into the fanciful was the chapter on Node in other environments. In this chapter, I had a chance to introduce the reader to Microsoft’s new ChakraCore for Node, as well as using Node with Arduino and Raspberry Pi, and with the Internet of Things (IoT). I figured by Chapter 12, we all deserved a special treat.

The book’s Table of Contents:

1. The Node Environment
2. Node Building Blocks: the Global Objects, Events, and Node’s Asynchronous Nature
3. Basics of Node Modules and Npm
4. Interactive Node with REPL and More on the Console
5. Node and the Web
6. Node and the Local System
7. Networking, Sockets, and Security
8. Child Processes
9. Node and ES6
10. Full-stack Node Development
11. Node in Development and Production
12. Node in New Environments

A more detailed TOC is available at O’Reilly.

I had a good crew at O’Reilly on the book, and an exceptionally good tech reviewer in Ethan Brown.

Technology Writing

Node: References and Resources

Recovered from the Wayback Machine.

During my explorations of Node.js, I came across many excellent resources, references, tutorials, and various other online publications related to the technology. I had planned on incorporating this material into an appendix for Learning Node but decided it would make a better online resource than a book chapter.

Every person interested in Node should start with the Node.js web site, as well as the web site for npm, the application that manages Node module installations:

If you’re interested in Node in a Windows environment, you might a little extra help in getting set up. I recommend the following resources:

There’s an enormous number of resources for the Node.js newbie, including basic tutorials and entire online books. I know there are more than what I discovered, but the following is a good start:

One person, Felix Geisendörfer, has provided several excellent online resources for new and experienced Node folks:

As you learn Node, you’ll hear about the Node event loop. The following are a couple of good articles on the event loop:

REPL is the Node interactive stand alone application. REPL stands for Read-Eval-Print-Loop. Following are good REPL resources:

Modules are the heart and soul of Node.js. It can be an interesting experience finding Modules, because you need to look carefully among the many available to see which are the ones currently supported, and which have, more or less, been abandoned. Luckily, there are good Node module resources:

A good rule of thumb about which module to use is check for recent activity in the module’s repository. Are there outstanding issues? Pull requests that have gone unanswered for a long time? Also do a Google search, see who is using the module, for what, and how recently.

For more on npm, itself, do check out the Developer guide. Also spend some time understanding the differences between global and local installation of modules.

Node is based on the CommonJS model. If you want to learn more about CommonJS, I recommend Taking baby steps with Node.js–CommonJS and creating custom modules.

The heart of the module system is the package.json file. Nodejitsu provides an article and a couple of good cheat sheets related to package.json and npm:

Peter Krumin did a great series of articles on Node.js Modules you should know about. Several of my favorite are included in the list.

If you work with Node, and you write modules, chances are you’re going to become intimately involved with EventEmitter. The following are good EventEmitter resources and references:

Control flow is a big topic of interest for Node developers:

There are good frameworks for Node, but I focused on Connect/Express. I felt that Express was more Node-like, and requires less upfront time than the other frameworks. That’s not to say there weren’t challenges with Express, as it went from Express 2.x to Express 3.x and then back down to Express 2.x, but one adapts. I focused on Express 3 in the book.

Connect is the middleware layer for Express. TJ Holowaychuk provides an introduction to Connect 2 at Connect 2.0. The Express web site is at, though note that the documentation is still focused on Express 2. For the Express 2 developer, check out the Migrating from 2.x to 3.x guide. Mike Valstar writes specifically about Express error handling and 404 pages.

I grew fond of Redis when working with Node.js. The Redis site is at Redis is nicely documented, at the site and in the Little Redis Book.

Following are other articles and links of interest, in no particular order or grouping:

Hack Sparrow article on running Express application in a production environment Charlie Robbins provides a how-to on distributing Node.js apps with at More on the module at

Rasmus Andersson wrote a Template for setting up Node.js-backed web apps on EC2 at Another writing on setting up Node on Amazon EC2 from Ben Nadel at….

A XSS (Cross Site Scripting) Cheat Sheet can be found at Another cheat sheet, this time on SQL Injection at

Heroku provides instructions on how to create a self-signed SSL certificate at Another tutorial on the same subjec. at

I don’t cover backbone.js in the book, but an article on combing it with MongoDB, Mongoose, and Restify can be read at

A comparison of Redis and Cassandra More on Apache Cassandra at Redis is compared with Memcached at The Memcached web site is at

Guillermo Rauch’s Use Jade Blocks, not Layouts, at

Curl is your friend when testing RESTful applications. Some helpful examples at
The Ruby on Rails routing guide applies equally well to Node:

Charlie McConnell wrote an article on “How to use stream.pipe” at

One of the better, more thorough answers I’ve seen at Stack Overflow is the answer to “What is the Difference between proxy server and reverse proxy server” at….

Guillermo Rauch wrote a multipart tweet filtering proxy, beginning with Part 1 at….

Shravya Garlapati at LinkedIn, wrote a very helpful article, Blazing Fast node.js: 10 performance tips from LinkedIn Mobile….

The Async module can be found at More on the creation of Async at

The Step module is located at
There is promise support in Node with Q at, and deferred, as well as Futures

Yes, you can use Node modules with client-side JavaScript with help from RequireJS at And you can scrape web pages using Node, jQuery, and Jsdom, with a little help from this article….

Since Node is based on the CommonJS model, read more about CommonJS at An interesting article on Node, CommonJS, and custom modules by Jan Van Ryswyck can be found at….

A Nodejitsu article on using the Process module can be found at More on Node and processes by at

More on TCP Socket Programming in Node.js at A general article on TCP vs. UDP can be found at More on UDP Networking at

If you’re curious about the performance differences between using process.nextTick and setTimeout, you can view benchmark tests at


Learning Node: Well, one Rails aside

Recovered from the Wayback Machine.

After denouncing the use of Ruby and Rails terms to describe Node and Node modules, I must now confess that I did use a Rails resource in the section on MVC in Chapter 6.

The Rails Guide has an absolutely beautifully written overview on MVC and routing, Rails Routing from the Outside In, I used as inspiration for the design of the MVC section in Chapter 6.

However, in my defense I’ll note that most of this overview really doesn’t depend on knowing either Ruby or Rails in order to benefit from the writing. It simply and easily demonstrates a mapping between HTTP verbs, routes, controller actions, and database CRUD (Create-Read-Update-Delete) probably better than anything else I’ve ever read.