djf.log()

JavaScript Features To Forget

2020-05-12T00:00:00+00:00

The first demo of the language that was to become JavaScript took place almost exactly 25 years ago.

The language was released, as LiveScirpt, in a beta of Netscape Navigator in the fall of 1995, and renamed to JavaScript later that year. Sometime late that year I began work on the first edition (O’Reilly published it as the “beta edition”) of JavaScript: The Definitive Guide, and it was published in August of 1996, meaning that it is going on 24 years old now.

With the seventh edition coming out in just a few weeks, I want to take a trip down memory lane and blog about some old weird features of JavaScript and of the early web platform that we can now, mercifully, forget about. One of the reasons that the new 7th edition is thinner than the 6th edition is that I’ve removed the reference section. But in addition, I found that there was a lot of stuff that was simply no longer relevant to web developers in 2020. Web compatibility is forever (or for at least more than 25 years) so browser vendors may need to keep supporting old and obscure language and platform features for a long time to come. But there is no need for the rest of us to clutter our minds with them anymore.

So here are some JavaScript and Web platform features that no longer bulk up the page count of JavaScript: The Definitive Guide. I’m happy to say goodbye to them. (I feel myself winding up for a bit of a rant here, so be warned that this is not carefully researched; just my memories of how things were in the bad old days):

The arguments object has been completely obviated by the introduction of ...args in ES6. It was always difficult to explain the weird way it interacted with named arguments and to always caution about its performance implications. You may still see it in legacy code and you may be reminded of its presence if you try to name a local variable or function parameter arguments in strict mode, but now that we have rest arguments, it should be allowed to slink into oblivion.
We used to have to worry about the performance of repeated string concatenation. There was a period of where we all learned to push strings onto an array, and then use join() to concatenate everything at the end. Then JavaScript got fast and we were all “Well, actually” and unlearned that pattern. And now with template literals, who even uses string concatenation anymore!
document.write() was pretty much the main feature of JavaScript at the very beginning, before the DOM. (If you did not use JavaScript in the 20th century, you may not know that there was a time before the DOM, but it is true. There was a property you could set to change the background color of a web page, but no way to actually alter the document tree once the document had been parsed.) IIRC you could even insert scripts into a document with document.write(), but you had to be careful to break the closing </script> tag into two strings so that the HTML parser wouldn’t interpret it as the end of the currently-running script.
HTML didn’t have an <iframe> in the early days, but there was <frameset> and <frame>. The window.frames property was an array of the nested window objects that represented the frames in a document. It was possible to actually call the open() method of a document in a frame, and then use document.write() to dynamically generate an entire document inside that frame. That was kind of cool, actually. Because frames could be nested inside other frames, every Window object had a frames array that contained its children frames, and a parent property that referred to the containing window, and a top property that referred to the toplevel window. Earlier editions of my book dedicated long sections and complicated figures to explaining all of this.
There are all kinds of obsolete techniques for referring to particular elements within a document. The frames array was one, but, IIRC, there were also links and images arrays as well that were literally just a list of all the links and images in a document. IE (version 4, I think) went all-in and introduced document.all: an array of all elements in the document. (This was the beginning of the DOM and of “DHTML”—kind of like the first fish that crawled onto dry land.) document.all had all kinds of weird features: it was an array that also had methods for looking up elements by name or something like that. document.all was never standardized, but even the standard methods like document.getElementById(), document.getElementsByName(), document.getElementsByTagName() and document.getElementsByClassName() seem obsolete today, crushed into irrelevance by jQuery’s $() function and the standard document.querySelector() and document.querySelectorAll() methods that it inspired. Through the power of CSS selectors those two functions obsolete everything that came before.
The thing I hated most about Internet Explorer was that it used an attachEvent() method for registering event handlers. In my memory, they did this even though the standard addEventListener() had already been defined, and that really annoyed me. Events and event handling were one of the biggest sources of incompatibility on the web, and for years JavaScript programmers (and JavaScript book authors) had to deal with a lengthy list of differences between the IE event model and the standard event model. Event handling code had to be written twice: once for IE and once for Firefox. Book chapters about events were twice as long as they needed to be because there were two similar, but completely incompatible ways of dealing with them. One of the major features of jQuery was that it implemented its own event compatibility layer so you only had to know about jQuery events, and I suspect that this was an important reason for its popularity.
The original DOM API was defined during the era of magical thinking about XML. (People really seemed to believe for a couple of years that XML was going to solve all data problems. It was a strange time.) Somehow the W3C committed that defined the DOM API got infiltrated by Java people who felt it was appropriate to define a single API to be used by JavaScript programmers working with HTML documents and Java programmers working with XML data. That’s why we have weird things like Attr nodes (which are best ignored). One of the things that always bugged me about the DOM Level 3 API was that to remove an element e from the document, you couldn’t just write e.remove() as we would today. You actually had to write e.parentNode.removeChild(e).

Anyway, it is 2020 now and I promise that the new 7th edition of my book will not subject you to lengthy explanations of any of those old features that are best left forgotten.

Changes in the Seventh Edition of JavaScript: The Definitive Guide

2020-05-03T00:00:00+00:00

The seventh edition of my book, JavaScript: The Definitive Guide is scheduled for release less than a month from today. If you own the sixth edition, it is very much time for an upgrade. This post explains what has changed in this new edition.

Most importantly, this edition is up-to-date and covers the very newest ES2020 features like ?. and ??. The sixth edition covered ES5, which means that I have added documentation of all the language features of ES6, ES2016, ES2017, ES2018, ES2019 and ES2020 for this update.
The first thing you’ll notice when you see the new edition is that O’Reilly has changed the cover. The old cover style still seems iconic to me, but this new style does seem like a nice modernization of the O’Reilly brand.
The second thing you’ll notice when you pick the book up is that it is significantly thinner. The 6th edition was a 1096 page brick; the 7th edition is about 400 pages slimmer: still a substantial book, but not absurdly so. The main reason for this reduced page count is that I’ve removed the reference section. In 2020 it is faster to look reference information up on MDN than it is to flip through a printed book. It simply doesn’t make sense to include that material in this new edition.
The cover of the 6th edition includes the tagline Activate Your Web Pages. I don’t remember when that was added, but it feels very dated (like, “DHTML”-level dated) to me. For the 7th edition I asked O’Reilly to change this to Master the World’s Most-Used Programming Language and the new cover positions this as a subtitle. (The “most-used” claim is from the 2019 Stack Overflow developer survey which found “For the seventh year in a row, JavaScript is the most commonly used programming language”.)
“Master the world’s most-used programming language” isn’t just marketing copy for the cover, though. It reflects a real change in focus for the book. The web platform has become way too large to be documented definitively by any one book. And, with the rise of Node, JavaScript isn’t just the language of web browsers anymore. So starting with this seventh edition I will be documenting the JavaScript language definitively, and providing an in-depth (but not definitive) introduction to the use of that language with Web APIs and Node APIs.

The 6th edition devoted about 290 pages to the language itself, 410 pages to the Web platform, and a meager 10 pages to Node. The 7th edition has 400 pages on the language, 160 pages on the Web, 60 pages on Node, and 30 pages on the JavaScript ecosystem of tools and language extensions. The cuts to the web documentation are not as deep as they seem, however. Much of the reduction in page count was achieved by removing material that is no longer relevant in 2020, such as coverage of document.write(), attachEvent(), and pretty much all mentions of Internet Explorer. There was a lot of material on CSS that I’ve removed, and the entire chapter on jQuery is gone (it is still available as a pocket reference though).
The 7th edition has a number of rewritten and new chapters:
- Chapter 6, Objects, and Chapter 8, Functions, are not completely rewritten but they include a lot of new material covering all the ES6 extensions to object literal syntax, arrow functions, parameter defaults, rest parameters, the spread operator, and so on.
- Chapter 9, Classes, is entirely rewritten. The chapter begins the old fashioned way: it demonstrates how to create a JavaScript class by directly defining methods on the prototype object. I believe that it is still important to understand how classes actually work in JavaScript. But after some initial examples of this technique, the chapter switches to using the modern class keyword.
- Chapter 10, Modules, is new. When I wrote the 6th edition, JavaScript had no module system and my discussion of using immediately-invoked function expressions as modules was simply tacked on to the end of the classes chapters. This new chapter documents both the module system used by Node and the ES6-standard modules that are now (finally!) supported by all browsers.
- Chapter 11, The JavaScript Standard Library, is a new chapter that covers maps, sets, typed arrays, dates, errors, JSON, and internationalization. The existing chapter on regular expressions from the 6th edition has been updated and turned into a (long) section of this chapter. This chapter also covers three APIs that are not formally part of the JavaScript language, but that are implemented by browsers and by Node: the console API, the URL class, and the setTimeout() and setInterval() functions.
- Chapter 12, Iterators and Generators is new, and documents exactly what the title says. This chapter teaches you how to use Symbol.iterator to make your own classes iterable so that they work with the for/of loop. And it also explains generator (defined with function*) and the yield and yield* keywords.
- Chapter 13, Asynchronous JavaScript is a detailed discussion of asynchronous APIs and explains how to use events, callbacks, Promises, and async and await. Promises are a revolutionary addition to JavaScript, but using them correctly can be hard unless you understand them thoroughly. This chapter goes deep in an attempt to definitively explain Promises.
- Chapter 14, Metaprogramming is a grab-bag of advanced language features that may be of primary interest to those writing libraries for use by other programmers. It explains property descriptors, object extensibility, template tag functions, proxy objects, the Reflect API and well-known symbols.
- Chapter 15, JavaScript in Web Browsers is by far the longest chapter in the book, introducing the Web platform in 160 pages. It includes the content from the 6th edition that is still relevant, plus new material covering web components, fetch(), history.pushState() and more. This chapter concludes with an extended example that implements a multi-threaded Mandelbrot set viewer app. The example demonstrates web workers (and includes a Promise-based WorkerPool utility class), inter-thread communication with postMessage(), the transfer (without copying) of array buffers between threads, history management with pushState() and popstate(), keyboard and pointer events, scripted CSS transforms, the URL() class, and generators.
- Chapter 16, Server-Side JavaScript with Node, is a detailed introduction to Node that starts with the fundamentals: events, buffers, and streams. This is followed by practical sections on working with files, making HTTP requests, serving HTTP responses, and concurrent programming with threads and child processes.
- Chapter 17, JavaScript Tools and Extensions, concludes the book with an introduction to some important parts of the JavaScript ecosystem: eslint, prettier, Jest, npm, code bundlers, Babel, JSX and Flow. I couldn’t document everything, so this chapter is a curated—but not particularly opinionated—list of some of the most popular JavaScript tools and extensions. This chapter is intended not as a recommendation for particular tools and technologies, but as an exhibition of the kinds of tools that professional JavaScript programmers regularly use.

It is a really good book! You can order it here.

Back Cover Copy for JSTDG7

2020-04-27T23:00:00+00:00

Here’s the marketing copy I wrote for the back cover of the book:

JavaScript is the programming language of the web and is used by more software developers today than any other programming language. For nearly 25 years this best seller has been the go-to guide for JavaScript programmers. The seventh edition is fully updated to cover the 2020 version of JavaScript, and new chapters cover classes, modules, iterators, generators, Promises, async/await, and metaprogramming. You’ll find illuminating and engaging example code throughout. This book is for programmers who want to learn JavaScript and for web developers who want to take their understanding and mastery to the next level. It begins by explaining the JavaScript language itself, in detail, from the bottom up. It then builds on that foundation to cover the web platform and Node.js.

Topics include:

Types, values, variables, expressions, operators, statements, objects, and arrays
Functions, classes, modules, iterators, generators, Promises, and async/await
JavaScript’s standard library: data structures, regular expressions, JSON, i18n, etc.
The web platform: documents, components, graphics, networking, storage, and threads
Node.js: buffers, files, streams, threads, child processes, web clients, and web servers
Tools and language extensions that professional JavaScript developers rely on

I’ll have lots more to say (not marketing copy) about the new book future post. Meanwhile, though, I want to drop this screenshot from Amazon’s US site:

Thank you to everyone who has pre-ordered my book and has made that image possible.

The weeks leading up to a book’s publication are a particularly important time for pre-orders because it generates publicity and helps the publisher know what size print run to schedule.

So if you already know that you want to own the new edition of this book, now would be a great time to order it.

JSTDG7 Cover Image

2020-04-27T00:00:00+00:00

I’ve started a new blog to celebrate the fact that after 9 years there will finally be a new seventh edition of JavaScript: The Definitive Guide!

That is the same rhino that has been on the cover of all previous editions. But it looks grumpier to me with this new all-white cover style that O’Reilly has switched to.

The early release version is available online from the publisher today, and the print version should start shipping in early June.