Very good. Not for begginers as it states, more like the contrary. Read the first edition, when I can I will read the second edition. ( )

While the book describes itself as "A Modern Introduction to Programming", I think most people who need to be introduced to programming would have a very difficult time with this book. Some few, however, could probably pick up this book and run with it, all the way to . . . the next book (whichever book that may be).

Eloquent JavaScript should give the reader a firm grounding in JavaScript per se and some interesting, very useful programming techniques -- which is a very important thing to get. Unfortunately, that will get the reader almost nowhere in terms of doing actual, "real-world", practical work with JavaScript. When one is done reading Eloquent JavaScript, then, one needs to pick the next book to read to get one closer to getting things done, and if one wants to be sure to get the most out of Eloquent JavaScript one probably needs at least a light touch of experience with programming before reading it (at least on the level of toy programming or undergraduate academic programming).

The author, Haverbeke, starts out with some explanation of the very foundations of programming in general, and moves from there through an almost seamless path to the simplest, most basic introduction to JavaScript the language, which those who are already familiar with the simplest and most pervasive flaws of the language's design will find firmly supporting their distaste for many of its features (e.g. numeric types and, in fact, anything that gets near anything the JavaScript language calls a basic type system). This includes some treatment of writing and using functions to accomplish practical ends in one's programs, and this is where things start to get a little interesting in JavaScript, including some stuff about recursion and a lead-in to the realization that almost everything in JavaScript (including functions) is an object (in an object-oriented sense) in some rather interesting ways. The next chapter after that about functions starts out showcasing some interesting and weirdly useful features of JavaScript that people who are not already familiar with a number of other languages may not recognize as quite so rare and interesting, dealing with data structures and the most basic form of objects (in the object oriented sense) in JavaScript. One of the more interesting things about JavaScript is that, in essence, all data structures are objects in a nuts-and-bolts way that is somehow reminiscent of Ruby, but with an initially cleaner feel to it. That feeling, sadly, will not last, though some more very interesting stuff comes before the true tragedies of JavaScript. The book goes on to deal with error handling in JavaScript, which sneakily works some good common practices into the explanations in a way that should help ensure relatively inexperienced programmers internalize some intelligent practices, though I wonder whether the error handling chapter fully enough addresses the subject; it is difficult, at this late stage in my development as a programmer, to properly judge this from a newcomer's perspective.

In the chapter on functional programming itself, Haverbeke seamlessly draws the reader into a sparse but deeply practical treatment of functional programming techniques for JavaScript. Functional programming is, of course, programming paradigm with which many long-time professional daycoders have essentially no meaningful experience. This was, in fact, one of the more enjoyable chapters I've read in the dozens of programming books that I have consumed over the course of my life. I even learned a thing or two from it that I had not previously really, fully grasped before about approaches to programming in general. There is a lot of depth hidden within this chapter, including some insightful treatment of practical metaprogramming. I think what a reader learns from it will depend substantially on what the reader already knows, but this chapter alone should make the book worth reading for quite a few people.

Upon reaching the chapter about the object oriented programming paradigm in JavaScript, the book then quickly devolves -- necessarily, given the limitations and tragic flaws of the language's design -- into lengthy demonstrations of (and sample solutions for) many of the mind-numbingly frustrating obstacles in the way of getting things done in raw JavaScript. Implementing half or more of an object model oneself, defining some of one's own semantics for a language's flavor of object oriented programming, may be interesting and instructive and sometimes even practical. It may be quite nice for some more advanced programming, too, but the fact that when working with raw JavaScript (i.e. without the support of libraries such as jQuery and Underscore.js) one absolutely must implement one's own object model facilities to get anything meaningful done in an object oriented fashion is, for a nominally object oriented language, something of an atrocity of language design. For someone with long experience doing object oriented programming in a number of different languages with different approaches, one might come away from this chapter weeping for the squandered potential of JavaScript and the horrors one might have to endure in dealing with that lack of completeness if not for the existence of things like jQuery and Underscore.js (and the fact it seems that they are so widely used that one might as well consider them parts of the core language). Unfortunately, while a tour of the abbatoir that is JavaScript's deeply broken object oriented programming semantics and how to build upon it to achieve something usable might be very instructive, it is also something of a soul-crushing experience, and it leaves out something very important for the reader without even effectively pointing out that this is missing:

The reader desperately needs to pick up another book, or otherwise find some way to learn, how to do object oriented programming in JavaScript in a way that is actually applicable to the real world. For anything more significant than toy programs for fun, the reader should not just rely on the ability to implement one's own object model in JavaScript. The existing, idiomatic approaches that use existing, popular libraries are necessary to get along with the rest of the JavaScript world. On one hand, I can understand sticking to the fundamentals in a book like Eloquent JavaScript, but on the other that does not solve the problem of readers not necessarily knowing how important it is to learn how to use things like jQuery and Underscore.js before going out into the world and applying the depth of knowledge this book can help them attain.

The treatment of object oriented programming in this book gave me some traumatic flashbacks of implementing most of an alternative, somewhat prototype-based object model on top of closures in Perl a decade or so ago as a way to get things done on a project where I could not reasonably avoid object oriented programming, but desperately wanted to avoid the clusterfuck of Perl's built-in default object model. In some ways, the picture of object oriented programming in JavaScript painted by Haverbeke is worse than the situation in Perl, which I find deeply troubling.

For those of us who have done a fair bit of programming in other languages, the next chapter will not make them much happier than the preceding. Titled "Modularity", it shows how, just when one might have thought JavaScript could not possibly contain more deep disappointments after the harrowing experience of the chapter on object oriented programming, the reader is in fact not cynical enough. While to many the object oriented programming chapter may come across as a cautionary tale about how to completely ruin a language for sane object oriented programming purposes, thus requiring the software developer to essentially implement an important part of the language oneself, this chapter on modularity shows how there are sometimes not even such extreme measures available to bridge the chasms in a language's design. It turns out that the only tools for modularity in JavaScript are data structures, files, and functions. In fact, even files are remarkably subpar in their provision of modularizing facilities, because of the fact that the only way to make use of multiple files in a single program is essentially to treat them as though they are concatenated into a single file before code is executed, thus destroying the "modularity" implied by division into multiple files. This chapter does, of course, nicely address how one can use functions (which at least come with some modularizing scope boundaries, unlike files) to achieve something like namespaces to isolate different chunks of related functionality, but it does not go far enough to provide a fully isolated namespace in practice; it only gets as far as offering a way to conditionally/selectively dump namespaces into a program's global namespace. This is not particularly surprising, given the fact that a whole book could surely be written on the subject of how to solve the problem more fully than this, and still leave out some expansion on important points.

The chapter on regular expressions rests neatly within the realm of the thoroughly practical, and if the reader pays sufficient attention it may become clear that this actually seems to be one of the better-designed parts of the language. The next chapter deals with the basics of web programming, which makes some of the important details of that pursuit evident to the attentive reader and helps get things rolling toward real, useful software development with JavaScript at last, though it does not get the reader all the way there by any stretch of the imagination. Following that, the Document Object Model (DOM) gets its own chapter, and here the pain and weeping start again -- this time not because of problems with JavaScript, but because of the terrifyingly short-sighted (and perhaps a bit sadistic) mistakes of browser designers of years past, along with some sample work-arounds that should in "real world" JavaScript programming be mostly addressed through the use of popular libraries, at least most of the time, rather than by reinventing the wheel. Things condintue down that daunting, mildly depressing path with a chapter about browser events, though this chapter also guides the reader through the development of meaningful program design (if the reader's eyes have not glazed over to the extent that depthful reading of sample code has become an unreasonable request).

Finally, Haverbeke presents a chapter about HTTP, which gives some overview of the most commonly relevant features of the protocol and actually implements some nitty-gritty practicality to demonstrate the ideas thus conveyed, then the author strongly urges the reader to get more help in this area from other sources with at least one specific recommendation (maybe two, depending on how you define "specific recommendation"). That's a great finish, though I really wish he had provided similar hints about where else to go at various other stops along the way through this book as well. While I am an experienced enough programmer to find a good learning path to follow this book, people more new to things may have greater difficulty.

Overall, this is (in its first edition -- the edition I read) an incisive, important, instructive, and very interesting book about JavaScript and, to some extent, programming in general. It is so good in parts that, despite its shortfalls, it still rises to a solid four stars in my estimation. Call it a "must read", I suppose, if you have any interest in JavaScript; call it a "should read" if you have any interest in programming in general, but not JavaScript itself, though probably not a "read this first" selection. ( )

Javascript è piuttosto pervasivo nel mondo web. In questo libro Haverbeke cerca di dare un'idea dell'ecosistema alla base del linguaggio, senza nascondere sotto il tappeto le sue magagne (ogni linguaggio di programmazione ha punti di forza e di debolezza); i vari capitoli terminano sempre con esercizi da svolgere nella sandbox creata nel sito collegato, e ogni tanto il fluire dei capitoli è inframmezzato da un progetto di più ampio respiro. Detto questo, io mi sono trovato abbastanza a disagio. Il libro, o almeno i primi capitoli è pensato per chi ha solo una minima base di programmazione: ma chi come me proviene da un linguaggio come il C fa fatica a comprendere le differenze logiche di struttura, che non sono mai racchiuse in comode tabelle al termine del capitolo ma sono appunto sparse nel testo. Come si suol dire, "Your mileage may vary". Mi sono trovato meglio con la parte su HTML e HTTP, ma solo perché i metodi sono relativamente standard, e naturalmente li conosco da una vita. ( )

An excellent introduction to Javascript in particular and programming in general. It has a very clear style which introduces sometimes esoteric javascript features with no nonsense. I was particularly impressed by its chapters on the DOM (Document Object Model -- not even technically part of javascript yet very essential to its operation on the web) and event handling, two subjects used by nearly every web-based javascript script yet often sadly neglected by tutorials. Highly recommended. ( )

Interesting, but barebones coverage ( )