Facebook Twitter Pinterest
  • Statt: EUR 32,00
  • Sie sparen: EUR 2,08 (7%)
  • Alle Preisangaben inkl. MwSt.
Nur noch 4 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Maintainable JavaScript ist in Ihrem Einkaufwagen hinzugefügt worden
+ EUR 3,00 Versandkosten
Gebraucht: Gut | Details
Verkauft von Deal DE
Zustand: Gebraucht: Gut
Kommentar: Dieses Buch ist in gutem, sauberen Zustand. Seiten und Einband sind intakt.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Hörprobe Wird gespielt... Angehalten   Sie hören eine Hörprobe des Audible Hörbuch-Downloads.
Mehr erfahren
Alle 2 Bilder anzeigen

Maintainable JavaScript (Englisch) Taschenbuch – 12. Juni 2012

5.0 von 5 Sternen 1 Kundenrezension

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
"Bitte wiederholen"
EUR 29,92
EUR 20,46 EUR 10,60
14 neu ab EUR 20,46 8 gebraucht ab EUR 10,60
click to open popover

Wird oft zusammen gekauft

  • Maintainable JavaScript
  • +
  • JavaScript: The Good Parts: Working with the Shallow Grain of JavaScript
  • +
  • JavaScript Patterns
Gesamtpreis: EUR 71,82
Die ausgewählten Artikel zusammen kaufen

Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.

  • Apple
  • Android
  • Windows Phone

Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.



Über den Autor und weitere Mitwirkende

Nicholas C. Zakas is a front-end consultant, author, and speaker. He worked at Yahoo! for almost five years, where he was front-end tech lead for the Yahoo! homepage and a contributor to the YUI library. He is the author of Professional JavaScript for Web Developers (Wrox, 2012), Professional Ajax (Wrox, 2007), and High Performance JavaScript(O Reilly, 2010). Nicholas is a strong advocate for development best practices including progressive enhancement, accessibility, performance, scalability, and maintainability. He blogs regularly at http: //www.nczonline.net/ and can be found on Twitter via @slicknet."


5.0 von 5 Sternen
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Stern
Siehe die Kundenrezension
Sagen Sie Ihre Meinung zu diesem Artikel


Von Jo Segers am 16. Dezember 2013
Format: Taschenbuch Verifizierter Kauf
This is a must read for any javascript programmer.

Its is written in a style that allows easy reading and everything is explained with good examples.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: HASH(0x98f2de94) von 5 Sternen 19 Rezensionen
42 von 42 Kunden fanden die folgende Rezension hilfreich
HASH(0x9be05c84) von 5 Sternen short and sweet (but if you've been around the JS block, you've heard a lot of this already) 31. Mai 2012
Von R. Friesel Jr. - Veröffentlicht auf Amazon.com
Format: Taschenbuch
"Maintainable JavaScript" by Nicholas Zakas (O'Reilly 2012) is a short-and-sweet little text on (as the cover says) "writing readable code". And by "readable code", Zakas means "code that other developers not named [YOUR NAME] will be able to read and make sense of and ultimately maintain". It goes beyond maintainable and readable code though--Zakas takes us on a tour of how to deliver high-quality JavaScript that is testable and maximally performant in production. If you look at Zakas' catalog, this subject is right in his wheelhouse, and the book reads like either a sequel to his 2010 "High Performance JavaScript (Build Faster Web Application Interfaces)" or else as an expanded version of Chapter 24 of his 2012 "Professional JavaScript for Web Developers" (3rd edition, and still my favorite JS text). It's an opinionated book about formatting style, about programming conventions, and about ways of helping you (and your team) write code that is a lot less likely to blow up on you down the line.

Right off the bat: the target audience for this book is not advanced JavaScript developers. If you are an advanced JavaScript developer (or even many mid-level JS devs) then these are concepts that you are already familiar with. You've already dabbled in a style guide. You already know to minimize global variables. You already know to use feature detection. And there's a good chance you're *at least* linting, if not testing, if not doing both of those things *automatically* as part of your build. If that sounds like you, then you might want to take a pass. But before you do, give the table of contents a second glance. (If nothing else, you'll feel really validated.)

So who *is* it for? It's for novice and intermediate level JavaScript developers that want to get a better sense of what "readable" and "maintainable" code looks like. It's for folks that are plowing through the other "slim" JavaScript books in the O'Reilly catalog (e.g., "JavaScript: The Good Parts", or "JavaScript Patterns"). It's for technical managers who don't have a JavaScript background. It's for folks that want to start a book club for front-end devs and have spirited debates about ASI and how many spaces to indent when an expression continues on the next line.

As I worked through Part I ("Style Guidelines"), my initial impression was that Zakas was writing a how-to for writing JavaScript style guides. We have 44 pages of in-depth discussion on where to put curly braces, how many blank lines to use (and where), and what a proper comment looks like. Esoteric rationales to inform what (on the surface) seem like so much pedestrian banalia. ("Who cares what I name my local variables?") But by the end, there is a well-reasoned case made for all of the recommendations that will go on to appear in Appendix A.

Where the book becomes more interesting is in Parts II ("Programming Practices") and III ("Automation"). Again: the chapters that comprise Part II are going to seem like review for many seasoned JS devs: keep your JS and your mark-up loosely coupled; avoid global variables; keep configuration data separate from business logic; use feature detection instead of browser detection. As much of these may seem like review (especially if you've been keeping up with Zakas' blog posts), don't get cocky and skim it, either--there are some gems in there. (In particular I'm thinking of the chapter on Event Handling that spawned an interesting post by Ben Nadel.)

The chapters in the Automation section were my favorites. Zakas builds up a solid Ant-based build system over the course of 7 chapters that includes validation and linting, file concatenation and gzipping, minification, documentation, and automated testing. As I've become highly interested in the build process, I was riveted by these chapters. Zakas at least touched on every topic in the automation/build topic that I would have wanted to see. But that being said: I would have loved to see more on this subject. He provides a lot of excellent starter material, and Appendix B is a rich list of other jumping-off points, but it also seemed... shallow? Like he was just scratching the surface? This seemed especially true of the chapters on documentation and testing.

All in all? I would strongly recommend this to folks that are new to JavaScript, but only a mild nudge to seasoned folks.
4 von 4 Kunden fanden die folgende Rezension hilfreich
HASH(0x98b7e45c) von 5 Sternen Good reference to develop clean and maintainable javascript code. 5. Juli 2012
Von Manju - Veröffentlicht auf Amazon.com
Format: Taschenbuch
"Maintainable JavaScript" by Nicholas Zakas (O'Reilly 2012) is a very useful book for programmers who have just started writing javascript code or, for intermediate developers who would like to develop clean and maintainable code. The book is written in a very simple language that is easy to understand and follow.

As the title of the book suggests, the book is aimed at capturing the essential aspects of writing javascript code that is easy to maintain. I liked the flow of the book but I felt that the first few chapters in part 1 could be skipped if the reader is aware of the material.

In part 1 of the book (Style Guidelines), Zakas has given in-depth analysis of styling guidelines to follow that are sometimes skipped when writing large pieces of Javascript code. He touches upon styling guidelines such as: naming conventions, adding comments in the code, understanding the usage of semi-colons etc.,. Some good example use cases and the methodology of using the style guides is presented so that these ideas stick in your mind and become part of the programmers habits.

In part 2 (Programming Practices) - I especially liked the chapter 6 on `avoid global variables' since I have used global variables in my JavaScript but did not think through the caveats of using them. Similar to part 1 of the book, I liked the use cases that the author proposed to describe advantages and disadvantages of several programming aspects that are described in the section. In addition,one of the best described chapters in this section is the material on throwing your own errors (helping you to debug JavaScript code) which I do most of the time using firebug tool on Firefox. Even though this method works I might have to start using some of the techniques described by Zakas in the book, using fascade design pattern on top of objects that are not yours (very interesting outlook) etc.

Part 3 - I like this section a lot especially the material on minification, compression of JavaScript files as the script code adds time delay in loading of the page on the browser. Compression, minification techniques described by the author will definitely help with improving the load performance of the page in the browser.

Some of other things that would have helped me or any other intermediate JavaScript developer is inclusion of example or exercise files for some sections in `part 2'. Examples and exercise files would have helped the understanding of chapters 10, 11 and some sections in part 3 like chapter 17.

It is also interesting to know that author did make an attempt to include Html5 changes for JavaScript in some chapters of part 2 of the book.

I would recommend this book if you are an intermediate developer like me or novice developer for JavaScript code and would like to work towards methods for improving your code and writing a maintainable javascript code as this is book easy to understand and follow.
2 von 2 Kunden fanden die folgende Rezension hilfreich
HASH(0x98b79a08) von 5 Sternen A worthy sequel to Douglas Crockford's Javascript: The Good Parts. 4. September 2012
Von attebury - Veröffentlicht auf Amazon.com
Format: Taschenbuch
It's easy to blaze your own coding trail, perhaps particularly so with Javascript. This book provides a comprehensive glimpse into the workflow and practices of an experienced Javascript developer. It's a good read whether you're blazing your own trail or trying to clear one for a group.
Maintainable Javascript provides a useful mix of intermediate and advanced Javascript concepts and practices based on widely accepted theory and grounded in the author's real world experience.

The book is broken into 3 sections.
1. Style Guidelines
2. Programming Practices
3. Automation

Style Guidelines
A nice survey of style guidelines found in several libraries and well-known approaches to coding Javascript including JSLint and JSHint.

Programming Practices
Presents a great deal of information from both the author's experience and general theory. I learned something even in the areas in which I was already familiar.

Convincing arguments for automation with helpful examples.

Maintainable Javascript reads like a worthy sequel to Douglas Crockford's Javascript: The Good Parts.

I reviewed this book as an ePub on the iPad for O'Reilly's Blogger Review Program.
2 von 2 Kunden fanden die folgende Rezension hilfreich
HASH(0x98b7b630) von 5 Sternen Every lead js developer should have this book handy 19. Juni 2012
Von kevinw - Veröffentlicht auf Amazon.com
Format: Taschenbuch
Some of the book was familiar to me as I feel experienced with JavaScript. The second half of the book is where I really learned some things new. In particular, the build process section was of high interest to me and I really learned a lot from it. I usually keep this book open in .pdf format for quick reference when I need it. If you're serious about your JavaScript, care about your code and having your team stay organized then you should have this book in close reach.
HASH(0x98b7b7e0) von 5 Sternen Highly Recommended 14. März 2013
Von JML - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I don't normally write reviews but felt this book was so good that I felt compelled to spread the word. I'm primarily a java developer who had worked extensively with JavaScript in the first 5 of my 10 years as a web developer. I have always held a special regard for javascript knowing full well that despite its imperfections it is perhaps the one common language that can bring developers of any and all programming language backgrounds together to develop and innovate for the one true universal interface that is the web. This is one of those books that brings out the good in the language and one that I wish I had when I was first starting. It is however enlightening enough, that even an intermediate (dare i say advanced) skill level programmer can still benefit.

With the advent of html5 technologies, my passionate interest in javascript has been rekindled over the past year and this book (along with the Good Parts) were my first two reads. While both were very good books, I enjoyed this one a bit more - perhaps because of its underlying theme of clean coding practices which I'm finding more and more is also a strong interest of mine. Essentially, programming is more an art than a science as some say, and how you express yourself makes all the difference. And if you don't know already, javascript is an excellent language for writing powerfully expressive code - provided one knows what they are doing and does so correctly. I think it was in this book that the author says (and I 100% agree) that when in a structured organizational setting, every line you write is not for yourself but for the next person who will maintain. This book helps you to learn how to harness javascript's true potential to write such powerfully expressive code (both for yourself and those maintaining your work).

The author makes some references to having worked with java and I found myself appreciating some of the parallels he sometimes explicitly/implicitly drew, which made it easier to absorb and relate to the material. Aside from that, he has a very good talent for writing technical material. It's difficult to describe what exactly it is about his style, but you will no doubt appreciate after reading some comparables out there. I also enjoyed how the book was 200 pages of solid information (as opposed to the typical 500 page plus reference).

Will definitely be reading a sequel to this book if and ever there should be one.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.