What do you think?
Rate this book
JavaScript: The Good Parts
Most programming languages contain good and bad parts, but JavaScript has more than its share of the bad, having been developed and released in a hurry before it could be refined. This authoritative book scrapes away these bad features to reveal a subset of JavaScript that's more reliable, readable, and maintainable than the language as a whole—a subset you can use to create truly extensible and efficient code. Considered the JavaScript expert by many people in the development community, author Douglas Crockford identifies the abundance of good ideas that make JavaScript an outstanding object-oriented programming language-ideas such as functions, loose typing, dynamic objects, and an expressive object literal notation. Unfortunately, these good ideas are mixed in with bad and downright awful ideas, like a programming model based on global variables. When Java applets failed, JavaScript became the language of the Web by default, making its popularity almost completely independent of its qualities as a programming language. In JavaScript: The Good Parts , Crockford finally digs through the steaming pile of good intentions and blunders to give you a detailed look at all the genuinely elegant parts of JavaScript, including: The real beauty? As you move ahead with the subset of JavaScript that this book presents, you'll also sidestep the need to unlearn all the bad parts. Of course, if you want to find out more about the bad parts and how to use them badly, simply consult any other JavaScript book. With JavaScript: The Good Parts , you'll discover a beautiful, elegant, lightweight and highly expressive language that lets you create effective code, whether you're managing object libraries or just trying to get Ajax to run fast. If you develop sites or applications for the Web, this book is an absolute must.
153 pages, Paperback
First published January 1, 2008
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 30 of 556 reviews
October 12, 2010
A short, dense book, describing a subset of Javascript and distinguishing which parts of the language "should" be used and which not. The author wrote JSLint, a widely-used tool for enforcing his preferences on your scripts. The preferences he wrote into JSLint are reflected here.
Some of his opinions seem obsessive and eccentric (it's not OK to write "i++"?), but others are invaluable. For example, you should make a habit of following the Kernighan & Ritchie style of braces: that is, you should write opening braces ("{") at the end of a line rather than the beginning of the next line, because if you ever write this:
return
{
a: 1
};
... it will silently return "undefined" and ignore your actual return value. Such precautions, which defend against dangers the novice hasn't imagined, are born of years of deep Javascript experience. They're this book's primary worth.
The book claims to be for developers new to Javascript, but some basic concepts are not very well explained. For example, the book provides a brief and incomprehensible description of the relationship among Javascript objects, prototypes, and functions, which will not enlighten someone not already familiar with Javascript. It then shows workarounds for implementing a cleaner object model, which is welcome; but if you don't immediately understand the need for the workaround, read a different Javascript book than this one.
A large portion of the book is occupied by flowcharts describing the syntax of the language. (E.g., one page is a flowchart describing how to format floating-point numbers.) If I were a finite-state automaton who wanted to know how to recognize floating-point numbers, this would be useful for me. Since I am a human being who can already read and write floating-point numbers, it's an inexplicable waste of space. I'm baffled that the author thought such diagrams served any purpose, and that O'Reilly allowed him to include them and assigned someone to lay them out for publication. If anyone can explain this to me I'd be grateful.
In all, a useful 30-page paper whining to be released from a 200-page book. Worth the read, but skip the flowcharts. Evaluate the author's recommendations for yourself. Use his JSLint tool, but take its output with a grain of salt.
Some of his opinions seem obsessive and eccentric (it's not OK to write "i++"?), but others are invaluable. For example, you should make a habit of following the Kernighan & Ritchie style of braces: that is, you should write opening braces ("{") at the end of a line rather than the beginning of the next line, because if you ever write this:
return
{
a: 1
};
... it will silently return "undefined" and ignore your actual return value. Such precautions, which defend against dangers the novice hasn't imagined, are born of years of deep Javascript experience. They're this book's primary worth.
The book claims to be for developers new to Javascript, but some basic concepts are not very well explained. For example, the book provides a brief and incomprehensible description of the relationship among Javascript objects, prototypes, and functions, which will not enlighten someone not already familiar with Javascript. It then shows workarounds for implementing a cleaner object model, which is welcome; but if you don't immediately understand the need for the workaround, read a different Javascript book than this one.
A large portion of the book is occupied by flowcharts describing the syntax of the language. (E.g., one page is a flowchart describing how to format floating-point numbers.) If I were a finite-state automaton who wanted to know how to recognize floating-point numbers, this would be useful for me. Since I am a human being who can already read and write floating-point numbers, it's an inexplicable waste of space. I'm baffled that the author thought such diagrams served any purpose, and that O'Reilly allowed him to include them and assigned someone to lay them out for publication. If anyone can explain this to me I'd be grateful.
In all, a useful 30-page paper whining to be released from a 200-page book. Worth the read, but skip the flowcharts. Evaluate the author's recommendations for yourself. Use his JSLint tool, but take its output with a grain of salt.
January 8, 2010
Crockford's book is already considered one of the classic JS books and I agree. Not because its complete (it only touches ECMAScript core, not even DOM), or particularly good at making things seem simple (it probably makes them look overcomplicated). Its because it approaches JavaScript in a completely different way than probably any other book you've read. It broadens your horizons as a JS developer, makes you think differently. And as soon as you finish it, you haven't only learned a few facts about how the language works (these might even be very few), your way of thinking about it was evolved.
It's one of the few books (esp. at the time it was written) that approached JavaScript with respect (and constructive criticism), and not as a toy language suitable only for silly effects and form validation. This makes it perfect for hardcore programmers trying to learn the language, but I would never recommend it to a programming newbie.
On the downside, apart from the aforementioned drawbacks, it doesn't provide rational arguments for everything the author tries to promote as a best practice and not all of those are that obviously a "best practice" (I remember having objections with some), some of them seem just his own personal preference.
It's one of the few books (esp. at the time it was written) that approached JavaScript with respect (and constructive criticism), and not as a toy language suitable only for silly effects and form validation. This makes it perfect for hardcore programmers trying to learn the language, but I would never recommend it to a programming newbie.
On the downside, apart from the aforementioned drawbacks, it doesn't provide rational arguments for everything the author tries to promote as a best practice and not all of those are that obviously a "best practice" (I remember having objections with some), some of them seem just his own personal preference.
January 6, 2015
Returning to serious JS programming after a long hiatus. When you pick up the rhino book (O'Reilly's definitive tome on JS) and thumb through it, you notice that it is written from the perspective of JS being introduced to the industry. It's all functional programming, browser-oriented, and thought of as an API to "make the monkey dance", rather than a serious programming language.
This book takes the opposite view in nearly every way. It's written from the perspective of someone who has lived with Javascript from the outset and knows where it comes from. It's almost like reading the best practices of a person who has raised a child with a complicated mental condition, someone who has taken the time and care to find out the child's behaviour problems, how to avoid them, and then focussed on what the child knows and does well, and somehow brought that child into a lifestyle that works for everybody involved.
I'll admit, I do not have this kind of love for Javascript. If I had my druthers, the entire specification would have been burned to the ground and started again with something closer to python. HOWEVER, as needs must, the devil will drive, and this book does an excellent job of shaking hands with the devil.
In some ways, though, it's a book on the philosophy of Javascript, on a particular perspective and ruleset that engenders good practice. To explain further, I would simply be quoting from the Introduction, since Crockford does an excellent job of explaining exactly what he's doing with this book and why. It's a slim volume, and like another O'Reilly title, "Mastering Regular Expressions", it's got one of the highest value-for-word ratios of any book in the field.
Sometimes I get asked by people coming into the industry, or trying to move from traditional programming into web development, what they should concentrate on to learn what they need to know in order to do quality web work. For front-end work, I used to point them in the direction of jQuery and Underscore to begin, and then on to Angular or another of the equally handy dev environments. I think from now on, I'm going to say "read this first, before you do anything." It's really that good.
This book takes the opposite view in nearly every way. It's written from the perspective of someone who has lived with Javascript from the outset and knows where it comes from. It's almost like reading the best practices of a person who has raised a child with a complicated mental condition, someone who has taken the time and care to find out the child's behaviour problems, how to avoid them, and then focussed on what the child knows and does well, and somehow brought that child into a lifestyle that works for everybody involved.
I'll admit, I do not have this kind of love for Javascript. If I had my druthers, the entire specification would have been burned to the ground and started again with something closer to python. HOWEVER, as needs must, the devil will drive, and this book does an excellent job of shaking hands with the devil.
In some ways, though, it's a book on the philosophy of Javascript, on a particular perspective and ruleset that engenders good practice. To explain further, I would simply be quoting from the Introduction, since Crockford does an excellent job of explaining exactly what he's doing with this book and why. It's a slim volume, and like another O'Reilly title, "Mastering Regular Expressions", it's got one of the highest value-for-word ratios of any book in the field.
Sometimes I get asked by people coming into the industry, or trying to move from traditional programming into web development, what they should concentrate on to learn what they need to know in order to do quality web work. For front-end work, I used to point them in the direction of jQuery and Underscore to begin, and then on to Angular or another of the equally handy dev environments. I think from now on, I'm going to say "read this first, before you do anything." It's really that good.
August 17, 2012
For an experienced developer who’s hacked things together while glancing at an online reference, JavaScript: The Good Parts seems like a good place to start learning the language properly. As the title indicates, the book consists of Crockford’s opinions about how to use JavaScript’s better features and avoid the bad ones. Being a relative JS novice, it’s hard for me to evaluate his judgements, but I’m glad to now have at least someone’s best practices to work with. Crockford’s descriptions of JavaScript’s odder (crummier) features were entertaining. My reading notes include items like, “typeof NaN === 'number' yields true. Derp.”
JavaScript’s syntax looks familiar to most programmers, but this can lead to incorrect assumptions about how it works. For instance, JavaScript uses curly brace-delimited blocks (like Java), but does not use block-level scoping. You can access object properties using a dot notation that looks like a method call (e.g., "object.foo"), but JavaScript doesn’t really support methods in the classical object-oriented sense. If studied carefully, this book can probably save you some time spent staring at Firebug while scratching your head.
This book is short and easy to read, but developers who've never touched JavaScript at all or who are new to programming for the Web should probably learn from some other book before reading this one.
JavaScript’s syntax looks familiar to most programmers, but this can lead to incorrect assumptions about how it works. For instance, JavaScript uses curly brace-delimited blocks (like Java), but does not use block-level scoping. You can access object properties using a dot notation that looks like a method call (e.g., "object.foo"), but JavaScript doesn’t really support methods in the classical object-oriented sense. If studied carefully, this book can probably save you some time spent staring at Firebug while scratching your head.
This book is short and easy to read, but developers who've never touched JavaScript at all or who are new to programming for the Web should probably learn from some other book before reading this one.
February 15, 2012
I don't think the importance of JavaScript in our current world can be overstated. Nor can the work of Douglas Crockford to legitimize JavaScript by extracting and promoting subsets of the language which are brilliantly designed. In the case of JSON, he recognized JavaScript's object notation as a wonderful and concise way to describe data structures. In my opinion, JSON is vastly superior to XML in every way.
I came to this book after watching Crockford's wonderful companion lecture at Google Tech Talks. It's about 45 minutes long if you skip the introduction and the Q&A at the end. It's full of dry humor and some very sound advice. I highly recommend you search for it and watch it now (it's on YouTube currently, under the title "JavaScript: The Good Parts").
However, this book was not quite what I was hoping it would be. It's short, which is always nice. And it certainly presents itself like a timeless classic (think, The C Programming Language aka "The White Book"). But I think it misses its true destiny by a wide margin. Unfortunately, The Good Parts is currently more like a miss-mashed collection of facts and techniques than a true learning narrative.
My case in point: Chapter 10 is entitled, "Beautiful Features" and is just over two pages long. It describes the impetus for the book and Crockford's previous experience creating of a subset of JavaScript containing just the good parts. He made the subset sound very nice, indeed, and I was really looking forward to learning the subset. I figured this was going to be the big payoff for slogging through the previous 9 chapters of dense language specifics and techniques.
But when I turned the page, I found that Chapter 10 is the end of the book! (If you don't count the appendixes.) There was no concise summary of the JavaScript subset containing only the good parts. And then in stunned silence, I realized that the previous nine chapters were the good parts. I had completely failed to extract the small, beautiful language from the assorted facts I had been presented.
I don't believe the failing is all mine. The book isn't quite right. But I do believe it could be fixed.
Chapter 10 should be the very first chapter. The second chapter should be a summary of the "good parts" subset. And the rest of the book should be a teaching guide to the subset - teaching it from the ground up as if the Good Parts was a new, exciting programming language all its own. But it doesn't read that way at all.
This book is still a very important read-through for anyone who writes JavaScript on a frequent basis. You're likely to learn many things about JavaScript you never truly understood before. This book would work as a reference, and I do keep it around for that purpose. But truthfully, it's usually far easier to look up specific topics on the web when I'm actually developing.
I believe this book could have ushered in a whole new age of JavaScript understanding to developers new and experienced alike. It could have become a time-worn classic in the way that The White Book is. But it's currently not. Currently, it would only confuse beginners and is too unfocused for even advanced programmers. What a shame.
By the way, Appendix A, "Awful Parts" is great. It should stay exactly as it is: an explanation of the horrific JavaScript features that are most definitely NOT the good parts. :-)
I came to this book after watching Crockford's wonderful companion lecture at Google Tech Talks. It's about 45 minutes long if you skip the introduction and the Q&A at the end. It's full of dry humor and some very sound advice. I highly recommend you search for it and watch it now (it's on YouTube currently, under the title "JavaScript: The Good Parts").
However, this book was not quite what I was hoping it would be. It's short, which is always nice. And it certainly presents itself like a timeless classic (think, The C Programming Language aka "The White Book"). But I think it misses its true destiny by a wide margin. Unfortunately, The Good Parts is currently more like a miss-mashed collection of facts and techniques than a true learning narrative.
My case in point: Chapter 10 is entitled, "Beautiful Features" and is just over two pages long. It describes the impetus for the book and Crockford's previous experience creating of a subset of JavaScript containing just the good parts. He made the subset sound very nice, indeed, and I was really looking forward to learning the subset. I figured this was going to be the big payoff for slogging through the previous 9 chapters of dense language specifics and techniques.
But when I turned the page, I found that Chapter 10 is the end of the book! (If you don't count the appendixes.) There was no concise summary of the JavaScript subset containing only the good parts. And then in stunned silence, I realized that the previous nine chapters were the good parts. I had completely failed to extract the small, beautiful language from the assorted facts I had been presented.
I don't believe the failing is all mine. The book isn't quite right. But I do believe it could be fixed.
Chapter 10 should be the very first chapter. The second chapter should be a summary of the "good parts" subset. And the rest of the book should be a teaching guide to the subset - teaching it from the ground up as if the Good Parts was a new, exciting programming language all its own. But it doesn't read that way at all.
This book is still a very important read-through for anyone who writes JavaScript on a frequent basis. You're likely to learn many things about JavaScript you never truly understood before. This book would work as a reference, and I do keep it around for that purpose. But truthfully, it's usually far easier to look up specific topics on the web when I'm actually developing.
I believe this book could have ushered in a whole new age of JavaScript understanding to developers new and experienced alike. It could have become a time-worn classic in the way that The White Book is. But it's currently not. Currently, it would only confuse beginners and is too unfocused for even advanced programmers. What a shame.
By the way, Appendix A, "Awful Parts" is great. It should stay exactly as it is: an explanation of the horrific JavaScript features that are most definitely NOT the good parts. :-)
December 10, 2014
As an experienced JavaScript programmer, I was looking around for introductory books for my friends who are just starting their programming journeys so this book came up in the usual lists of modern JavaScript books.
This book was a huge disappointment. The authors ability to turn even simple concepts into confusing railroad diagrams coupled with explanations that do not make any sense even to someone well versed in the subject is absolutely astounding.
It feels like the book doesn't quite know what it wants to be. It starts with a disclaimer of not being intended for beginners and then proceeds to spend a long time explaining the syntax for white-space, strings, numbers, if statements and while loops - concepts anyone with even a few hours of programming experience would be familiar with. Once it gets to more advanced material, it equally fails by introducing the concepts in a way that is unintelligible even to someone who already understands the ideas in depth.
Novices should steer clear from this one while those with already some programming or JavaScript experience would be much better served by something like Effective JavaScript by David Herman.
This book was a huge disappointment. The authors ability to turn even simple concepts into confusing railroad diagrams coupled with explanations that do not make any sense even to someone well versed in the subject is absolutely astounding.
It feels like the book doesn't quite know what it wants to be. It starts with a disclaimer of not being intended for beginners and then proceeds to spend a long time explaining the syntax for white-space, strings, numbers, if statements and while loops - concepts anyone with even a few hours of programming experience would be familiar with. Once it gets to more advanced material, it equally fails by introducing the concepts in a way that is unintelligible even to someone who already understands the ideas in depth.
Novices should steer clear from this one while those with already some programming or JavaScript experience would be much better served by something like Effective JavaScript by David Herman.
October 8, 2012
I don't understand the consistently high rating this book gets. While the concept is excellent - filet-o-javascript - the execution has serious failings.
It starts well with the early chapters but as soon as it reaches the the more challenging stuff - clousures and prototypical inheritance - I found myself having to reach for the superior 'Object-Oriented JavaScript' to understand what was being described each time.
I don't care how many times you re-read it - per the author's admonition at the beginning of the book - it just lacks the necessary explanatory power.
Also there is a distinctly condescending tone that is a bit off-putting.
I did like the railway diagrams. But in such a small book (with overly generous margin and end of chapter whitespace) was there really any need to have them gathered as an Appendix as well as a chapter?
It serves well as a checklist of the bits of JavaScript to use and which to avoid but that's about it.
It starts well with the early chapters but as soon as it reaches the the more challenging stuff - clousures and prototypical inheritance - I found myself having to reach for the superior 'Object-Oriented JavaScript' to understand what was being described each time.
I don't care how many times you re-read it - per the author's admonition at the beginning of the book - it just lacks the necessary explanatory power.
Also there is a distinctly condescending tone that is a bit off-putting.
I did like the railway diagrams. But in such a small book (with overly generous margin and end of chapter whitespace) was there really any need to have them gathered as an Appendix as well as a chapter?
It serves well as a checklist of the bits of JavaScript to use and which to avoid but that's about it.
May 22, 2013
My new JavaScript reference. This book takes a stand in defining the good features of JavaScript banning the rest as evil or not useful. It even introduces a linter that enforces the above! It does all of this in 150 pages or so. The "good" parts are actually described in the first 100 pages. That's it.
The book is not for complete novices to programming: e.g. the while loop is explained in 2 lines. Syntax diagrams are used to explain every construct. However, if you have programmed in other languages but know nothing about JS, you should be able to follow along just fine.
The "not recommended" parts of the language are still presented in 2 chapters (with explanations about the nature of their evil): the "bad parts" and the "awful parts."
In summary, this is a perfect tech book: terse, clear, packed with useful information, and does not insult your intelligence. It is so good that it made me reconsider my (wrong) assumptions about the language. I look at JavaScript differently now.
The book is not for complete novices to programming: e.g. the while loop is explained in 2 lines. Syntax diagrams are used to explain every construct. However, if you have programmed in other languages but know nothing about JS, you should be able to follow along just fine.
The "not recommended" parts of the language are still presented in 2 chapters (with explanations about the nature of their evil): the "bad parts" and the "awful parts."
In summary, this is a perfect tech book: terse, clear, packed with useful information, and does not insult your intelligence. It is so good that it made me reconsider my (wrong) assumptions about the language. I look at JavaScript differently now.
August 2, 2012
Many programming books are funny because their authors make jokes. Why's (Poignant) Guide to Ruby comes to mind. Javascript: The Good Parts, however, is the first programming book that has ever made me laugh out loud when the author wasn't telling a joke. Case in point:
Chapter 5, on Inheritance, was the most helpful in terms of understanding how to write large applications in a way that provides most of the niceties (clean syntax, encapsulation, etc.) that we've come to expect from high-level languages.
I just wish he'd gotten there sooner. Despite being a relatively short book, and despite its title, Good Parts spends more time than I expected on explaining the bad patterns. I suppose it's worthwhile for readers to have a deeper understanding of the language as a whole, but — for example — I know a lot more now that I ever knew before about classical constructors in Javascript, and yet I will probably never use them if I follow Crockford's advice.
I also found the overall organization to be a little strange. The appendices take up nearly a third of the book, and provide some of the most illuminating surprises (including the quotation above), yet — they are appendices. Meanwhile, what appears to be a normal programming book (a narrative littered with code examples) becomes a method reference in Chapter 8 and switches to big-picture prose for the final two chapters.
So: read chapters 1 through 5, plus appendices A and B. Skim the rest, or keep it handy as a reference.
undefined and NaN are not constants. They are global variables, and you can change their values. That should not be possible, and yet it is. Don't do it.Any developer who has ever written Javascript is likely to have been confounded by a number of its pitfalls, and in many cases I think one's first instinct is to assume that you've done something wrong. Crockford clarifies that Javascript's heritage as the language of the web browser gives it a number of unique deformities, and he labels them as such pretty unambiguously. I like that. Honesty makes it easier for developers to move forward and write better code.
Chapter 5, on Inheritance, was the most helpful in terms of understanding how to write large applications in a way that provides most of the niceties (clean syntax, encapsulation, etc.) that we've come to expect from high-level languages.
I just wish he'd gotten there sooner. Despite being a relatively short book, and despite its title, Good Parts spends more time than I expected on explaining the bad patterns. I suppose it's worthwhile for readers to have a deeper understanding of the language as a whole, but — for example — I know a lot more now that I ever knew before about classical constructors in Javascript, and yet I will probably never use them if I follow Crockford's advice.
I also found the overall organization to be a little strange. The appendices take up nearly a third of the book, and provide some of the most illuminating surprises (including the quotation above), yet — they are appendices. Meanwhile, what appears to be a normal programming book (a narrative littered with code examples) becomes a method reference in Chapter 8 and switches to big-picture prose for the final two chapters.
So: read chapters 1 through 5, plus appendices A and B. Skim the rest, or keep it handy as a reference.
June 20, 2012
(4.0) Opened my eyes to how JavaScript really works, but had some bad bugs
I've been using JS for a while now, just throwing stuff together and getting things working, copying patterns observed elsewhere. At times I saw some unfamiliar structures (particularly of the anonymous functions that return functions getting invoked immediately variety, etc.), but chose to ignore them. All the while I assumed it was actually an OO language. How wrong I was.
This was quite helpful for someone familiar with the language, the syntax, many of the uses for which JavaScript is put....but who never bothered to actually figure out how to build reusable components ("classes") in it. This will educate. Yes, Crockford's very opinionated in his style and what to use/not use in the language. But unless you really know what you're doing, it seems to make sense to adopt his conventions/opinions by default to start off with.
Had some problems with bugs in the book. I visited the errata page several times, only to find that the author/editor had made changes based on user submissions that actually INTRODUCED errors into the print edition that I was reading (and in fact, in one case, the errata show a change and then a subsequent reversal of that change...can't remember now which version was actually right). So I naturally assumed at first that I didn't understand the code, but eventually learned that there were some bad bad errors in the code. A lot of this comes from the nature of JS, its functional nature, that encourages nesting of anonymous function definitions...and hence the usual nesting of parentheses, curly braces etc. that make functional programming difficult to read (in my mind).
I also appreciate that he calls out the bits of JavaScript that are bad, awful. Cause they are. I really appreciate that frank perspective and I'll try to avoid using most of the bad/awful stuff.
I've been using JS for a while now, just throwing stuff together and getting things working, copying patterns observed elsewhere. At times I saw some unfamiliar structures (particularly of the anonymous functions that return functions getting invoked immediately variety, etc.), but chose to ignore them. All the while I assumed it was actually an OO language. How wrong I was.
This was quite helpful for someone familiar with the language, the syntax, many of the uses for which JavaScript is put....but who never bothered to actually figure out how to build reusable components ("classes") in it. This will educate. Yes, Crockford's very opinionated in his style and what to use/not use in the language. But unless you really know what you're doing, it seems to make sense to adopt his conventions/opinions by default to start off with.
Had some problems with bugs in the book. I visited the errata page several times, only to find that the author/editor had made changes based on user submissions that actually INTRODUCED errors into the print edition that I was reading (and in fact, in one case, the errata show a change and then a subsequent reversal of that change...can't remember now which version was actually right). So I naturally assumed at first that I didn't understand the code, but eventually learned that there were some bad bad errors in the code. A lot of this comes from the nature of JS, its functional nature, that encourages nesting of anonymous function definitions...and hence the usual nesting of parentheses, curly braces etc. that make functional programming difficult to read (in my mind).
I also appreciate that he calls out the bits of JavaScript that are bad, awful. Cause they are. I really appreciate that frank perspective and I'll try to avoid using most of the bad/awful stuff.
September 16, 2017
I have mixed feelings about this book.
While the book navigates through the most important and interesting part of the JavaScript language, it sometimes falls into verbose explanations of general programming syntax, and jumping between these essentials of programming and some advanced stuff like prototypes or closures makes it frustrating to read. Not to mention those "railroad diagrams" that were supposed to get the reader to understand the syntax, except that they don't.
The important thing is that YOU SHOULD NOT READ IT IF YOU DON'T KNOW YOUR SH*T IN JAVASCRIPT!!
Aside from touching some topics that we don't usually get to face while starting our programming journey with this weird language, the information this book provides is sometimes outdated and if you don't know how to check your info you will learn something wrong. Keep in mind that this book was written back in 2008, so the language it discusses probably follows the ECMAScript 3, and now we live in the ES8/2017 era.
While the book navigates through the most important and interesting part of the JavaScript language, it sometimes falls into verbose explanations of general programming syntax, and jumping between these essentials of programming and some advanced stuff like prototypes or closures makes it frustrating to read. Not to mention those "railroad diagrams" that were supposed to get the reader to understand the syntax, except that they don't.
The important thing is that YOU SHOULD NOT READ IT IF YOU DON'T KNOW YOUR SH*T IN JAVASCRIPT!!
Aside from touching some topics that we don't usually get to face while starting our programming journey with this weird language, the information this book provides is sometimes outdated and if you don't know how to check your info you will learn something wrong. Keep in mind that this book was written back in 2008, so the language it discusses probably follows the ECMAScript 3, and now we live in the ES8/2017 era.
July 23, 2022
Topic that is made obsolete by the progress of the JavaScript, unnecessarily verbose examples for the smallest of concepts, unbelievably dry language except for jokes hidden in console logs (looking at you, like meow Bix meow baby) did not make a fun reading-learning experience.
The most educative aspect was about seeing how much Javascript has progressed, since the book focused on missing block scopes, and lack of modularity, both solved in the current versions. Still, would you read a book about this?
I learned some stuff from the book, but still I don't recommend it. The only reason somehow it still gets mentioned around is probably the mentors who are asked advice on what to read is not able to come up with a good answer except what they had read.
The most educative aspect was about seeing how much Javascript has progressed, since the book focused on missing block scopes, and lack of modularity, both solved in the current versions. Still, would you read a book about this?
I learned some stuff from the book, but still I don't recommend it. The only reason somehow it still gets mentioned around is probably the mentors who are asked advice on what to read is not able to come up with a good answer except what they had read.
January 22, 2020
JavaScript is too much fun. Reading the book was like watching a good mystery drama, full of unexpected twists and turns. And just when you think you've figured it out... oh no, another surprise is coming your way.
All joking aside, this book can teach you JavaScript essentials in a short and comprehensive manner.
All joking aside, this book can teach you JavaScript essentials in a short and comprehensive manner.
January 5, 2018
I had wanted to read this book for some years, as I have written more JavaScript code in my life than I care to admit, and in that time have given much thought to the topic of good coding practice in this language. From time to time, I have also been asked for book recommendations from people wanting to learn JavaScript, and on hearsay, this is what I usually pointed them to.
Now I finally have read it for myself, and can vouch for its quality. It is targetted at experienced programmers who are new to JavaScript. People new to programming entirely would struggle with this book. This is essentially a style book - how to write readable, reliable code in a language with more than its fair share of misfeatures. It is a short, well written book, with a good natured humor for its subject that makes it fun to read.
I did not entirely agree with every last one of the author's points, but all of them are worth consideration. For example, this book seems unnecessarily paranoid of JavaScript's variable hoisting - once you know how it works, it's really no problem. I was won over to a few points of style that I had not considered before, like the badness of '=='.
The most interesting part of the book was Crockford's style concerning object orientation (chapter 5: Inheritance). That part could have done with a more in depth treatment and some exploration of the style's application to a real world scenario or two.
The chapter on regular expressions was the weakest, I felt, because the examples used to teach them were of dodgy and error-prone things to use them for. I'm not sure I would call regular expressions a "good part" of JavaScript at all - a necessary part, yes, but as the old joke goes: you have a problem; you decide to use regular expressions; now you have two problems.
The appendix on JSLint was interesting but repetetive of the content of the chapters. It probably could have been shortened or merged with the main content of the book.
Short and to the point, this book can be read in a day or two, and that scores points with me. In 2018 this book is still one that I will selectively recommend, but it is also seeming a little dated. It would be nice to see a second edition to treat the changes to JavaScript that have happened since 2008 - there are a few good parts there, too.
Happy coding.
Now I finally have read it for myself, and can vouch for its quality. It is targetted at experienced programmers who are new to JavaScript. People new to programming entirely would struggle with this book. This is essentially a style book - how to write readable, reliable code in a language with more than its fair share of misfeatures. It is a short, well written book, with a good natured humor for its subject that makes it fun to read.
I did not entirely agree with every last one of the author's points, but all of them are worth consideration. For example, this book seems unnecessarily paranoid of JavaScript's variable hoisting - once you know how it works, it's really no problem. I was won over to a few points of style that I had not considered before, like the badness of '=='.
The most interesting part of the book was Crockford's style concerning object orientation (chapter 5: Inheritance). That part could have done with a more in depth treatment and some exploration of the style's application to a real world scenario or two.
The chapter on regular expressions was the weakest, I felt, because the examples used to teach them were of dodgy and error-prone things to use them for. I'm not sure I would call regular expressions a "good part" of JavaScript at all - a necessary part, yes, but as the old joke goes: you have a problem; you decide to use regular expressions; now you have two problems.
The appendix on JSLint was interesting but repetetive of the content of the chapters. It probably could have been shortened or merged with the main content of the book.
Short and to the point, this book can be read in a day or two, and that scores points with me. In 2018 this book is still one that I will selectively recommend, but it is also seeming a little dated. It would be nice to see a second edition to treat the changes to JavaScript that have happened since 2008 - there are a few good parts there, too.
Happy coding.
February 9, 2012
This book is fantastic. There are at least 400 pages-worth of information crammed into those 176 pages. This book is definitely not written with the beginner programmer in mind. Even for an intermediate programmer such as myself, I often needed to read sentences three or four times in order to understand them. (Not because the writing was sloppy, but because of having to scour the depths of my brain to remember the meaning of terms like "lexical scope" and "prototypal inheritance").
I love this book for the same reason I love programming. Programming is an endeavor which demands exactitude. And one of the main problems that Crockford identifies with JavaScript is that it is much too forgiving of sloppiness, which can lead to errors or security risks. So the purpose of the book is to prove that if you peel away the Bad Parts of JavaScript, you reveal a shining core of Good JavaScript. Crockford teaches us how to avoid the pitfalls and write reliable, fast, and powerful code using the language of the Web which is, for better and worse, not going away any time soon.
One of the Best parts about the Good Parts is that they are all you need to write any program conceivable in JavaScript. Fortunate for us, and a testament to the fact that JavaScript is a totally legit language, the Bad Parts are avoidable, and not terribly hard to avoid either. Just a few more lines of code. And honestly, I've never been the type of programmer who sacrifices readability for density, so I'm happy to do a little extra work in order to build the most stable program possible. Crockford seems to agree. We are on a wavelength, I tell you.
So anyway. Read this book after you've gone through a few online tutorials on JavaScript, but don't wait too long after you've started coding, so that bad habits don't sneak in and solidify too much.
I love this book for the same reason I love programming. Programming is an endeavor which demands exactitude. And one of the main problems that Crockford identifies with JavaScript is that it is much too forgiving of sloppiness, which can lead to errors or security risks. So the purpose of the book is to prove that if you peel away the Bad Parts of JavaScript, you reveal a shining core of Good JavaScript. Crockford teaches us how to avoid the pitfalls and write reliable, fast, and powerful code using the language of the Web which is, for better and worse, not going away any time soon.
One of the Best parts about the Good Parts is that they are all you need to write any program conceivable in JavaScript. Fortunate for us, and a testament to the fact that JavaScript is a totally legit language, the Bad Parts are avoidable, and not terribly hard to avoid either. Just a few more lines of code. And honestly, I've never been the type of programmer who sacrifices readability for density, so I'm happy to do a little extra work in order to build the most stable program possible. Crockford seems to agree. We are on a wavelength, I tell you.
So anyway. Read this book after you've gone through a few online tutorials on JavaScript, but don't wait too long after you've started coding, so that bad habits don't sneak in and solidify too much.
May 5, 2013
An enjoyable read that takes you on a whirlwind tour of pitfalls of Javascript. I gained a deeper appreciation of the language, understand it more thoroughly, and felt that the pace was good.
I can recommend this book to an experienced programmer who is already familiar with a lot of concepts in programming languages, and simply needs a fast intro to Javascript. If you're not as comfortable though, you will get lost. The exposition is short... but sweet.
Lastly, one bad point I can think of is that objective and insightful discussions of Javascript's problems are intermingled with the author's personal opinions that are sometimes rather obsessive. One paragraph you find out that [3, 15, 8].sort() returns [15, 3, 8], and the next you're presented with arguments for why you shouldn't use i++ or why you should always put a space after "if" in if() clause.
I can recommend this book to an experienced programmer who is already familiar with a lot of concepts in programming languages, and simply needs a fast intro to Javascript. If you're not as comfortable though, you will get lost. The exposition is short... but sweet.
Lastly, one bad point I can think of is that objective and insightful discussions of Javascript's problems are intermingled with the author's personal opinions that are sometimes rather obsessive. One paragraph you find out that [3, 15, 8].sort() returns [15, 3, 8], and the next you're presented with arguments for why you shouldn't use i++ or why you should always put a space after "if" in if() clause.
March 4, 2014
This book is like the Invisible Cities or Molloy of programming books. It really pares stuff down in an eccentric way, so that on first glance the author comes across as a masochistic pedant (++ and -- are bad parts?!), but on second glance he is more like an advanced alien lifeform revealing new dimensions of consciousness to you.
JavaScript is a really weird language. Nobody told me that when I started to learn it. But it's expressive and adaptable, and when it works for something, it really, really works. It's kind of a lot like English now that I think about it.
JavaScript is a really weird language. Nobody told me that when I started to learn it. But it's expressive and adaptable, and when it works for something, it really, really works. It's kind of a lot like English now that I think about it.
January 7, 2010
This is a must-read book if you use Javascript seriously. When I put the book down, I'd learned and understood a few critical ideas about using Javascript that are changing the way I program. In particular, I found the section related to object creation (prototypal inheritance, implications for using the new keywords, etc.) I also greatly enjoyed the appendices -- I eat up lists like the awful and bad parts of Javascript, and the introduction to JSLint is going to be very fruitful. Not everything in the book was new to me, but what was more than justified reading this once and then reading it again.
March 7, 2010
This book caught my eye last week because of how comically skinny it is, given the title. Nevertheless, i just flipped through it as i'm about to code some javascript and i'm glad i did. It is dense in little gotchas that i've been tripping over.
June 26, 2016
I wasn't overly impressed with this, A few good things but other books are better laid out and more user friendly
February 19, 2022
A must-read for JavaScript developers. Ch 1-4 are essential. Crockford writes in an accessible style. I read this book over a period of years, but only finally re-read it cover-to-cover.
Some of it is in need of an update, Ch 5 could eliminate the sections on Object specifiers and functional inheritance, and focus on native classes. Ch.9 "Methods" can be removed, as its just a reference for array, function, string methods, which have expanded since this books release.notably, the JSON appendix can be removed, as Crockford helped get JSON built into the language spec. Ch 9, "Style" is basically about his JSLint project, which has also become 'nearly-standard' with projects like ESLint taking much from his first attempts.
The Appendix A: Awful Parts, should be a chapter, not an appendix. The syntax diagrams in Appendix D should be featured more prominently in the beginning of the book.
Chapter 7: Regular Expressions could be omitted to keep the book more concise.
Some of it is in need of an update, Ch 5 could eliminate the sections on Object specifiers and functional inheritance, and focus on native classes. Ch.9 "Methods" can be removed, as its just a reference for array, function, string methods, which have expanded since this books release.notably, the JSON appendix can be removed, as Crockford helped get JSON built into the language spec. Ch 9, "Style" is basically about his JSLint project, which has also become 'nearly-standard' with projects like ESLint taking much from his first attempts.
The Appendix A: Awful Parts, should be a chapter, not an appendix. The syntax diagrams in Appendix D should be featured more prominently in the beginning of the book.
Chapter 7: Regular Expressions could be omitted to keep the book more concise.
October 29, 2019
A good book to understand how the language has evolved historically. Includes some good historic design patterns. Crockford also got things right on why non JavaScript developers hate the language:
JavaScript is most despised because it isn’t some other language. If you are good in some other language and you have to program in an environment that only supports JavaScript, then you are forced to use JavaScript, and that is annoying. Most people in that situation don’t even bother to learn JavaScript first, and then they are surprised when JavaScript turns out to have significant differences from the some other language they would rather be using, and that those differences matter.
January 24, 2020
This book was clearly written by someone who wanted JavaScript to conform to their idea of how a programming language should operate, rather than someone who had taken the time to thoroughly learn the language and leverage its idiosyncrasies. Almost everything is a “mistake” or a “bad part,” but you can avoid these mistakes and bad parts if you use this language in this very strict sense. The book overall was very dogmatic and, quite honestly, annoying. Why write a book where you’ll spend more time trashing a language than giving insight into how to use it better? With very little exception, this turned out to be an unsavory read.
March 23, 2020
I'm old enough to remember when JavaScript wasn't cool, and back then Crockford's pivotal work opened many peoples eyes to the potential of this language, which is now the most ubiquitous in the history of computer science. While the book is now out of date at the detail level, it's still feels like a fresh look, and I still found it inspiring. Crockford's cantankerous and opinionated narrative walks the edge of being a rant, but he is saved every time by the fact that his options, while they may be strongly held, are accurate and informed by the deep experience that only a master can possess. This is truly a classic!
November 29, 2017
Not bad actually, but that’s all. If you completed the series “You Don’t Know JS” then do not waste your time on this book, otherwise just start to read YDKS, of course! :)
January 18, 2018
Simply amazing. Must read for folks, thinking of JS as of some crappy c++ spinoff for web.
October 1, 2018
The first book that answered the questions and briefly explained what javascript really is, why do I need it, why it is special, and how to use these features.
October 22, 2019
Author has great writing style.
It's interesting to read solutions and workarounds, and it's dreading to read about limitations of the language that caused those workarounds.
It's interesting to read solutions and workarounds, and it's dreading to read about limitations of the language that caused those workarounds.
April 1, 2018
concise, witty, poetic. not entirely relevant today, but still insightful and fun to read.
July 13, 2020
Great book about JavaScript programming language! I do recommend it to everyone who is working with JavaScript, want to better understand the language and/or just getting starting with it.
Displaying 1 - 30 of 556 reviews