Attualmente non disponibile.
Ancora non sappiamo quando l'articolo sarà di nuovo disponibile.
Ne hai uno da vendere?
Passa al retro Passa al fronte
Ascolta Riproduzione in corso... In pausa   Stai ascoltando un campione dell'edizione audio udibile.
Maggiori informazioni
Visualizza l'immagine

Programming JavaScript Applications (Inglese)

5.0 su 5 stelle 2 recensioni clienti

Visualizza tutti i 2 formati e le edizioni Nascondi altri formati ed edizioni
Prezzo Amazon
Nuovo a partire da Usato da
Formato Kindle
"Ti preghiamo di riprovare"
Articoli disponibili visualizzati da altri clienti
click to open popover

Non è necessario possedere un dispositivo Kindle. Scarica una delle app Kindle gratuite per iniziare a leggere i libri Kindle sul tuo smartphone, tablet e computer.

  • Apple
  • Android
  • Windows Phone

Per scaricare una app gratuita, inserisci il numero di cellulare.



Dettagli prodotto

  • Copertina flessibile
  • Lingua: Inglese
  • ISBN-10: 1449320945
  • ISBN-13: 978-1449320942
  • Peso di spedizione: 499 g
  • Media recensioni: 5.0 su 5 stelle  Visualizza tutte le recensioni (2 recensioni clienti)
  • Visualizza indice completo
  • Garanzia e recesso: Se vuoi restituire un prodotto entro 30 giorni dal ricevimento perché hai cambiato idea, consulta la nostra pagina d'aiuto sul Diritto di Recesso. Se hai ricevuto un prodotto difettoso o danneggiato consulta la nostra pagina d'aiuto sulla Garanzia Legale. Per informazioni specifiche sugli acquisti effettuati su Marketplace consultaMaggiori informazioni la nostra pagina d'aiuto su Resi e rimborsi per articoli Marketplace.

    Se sei un venditore per questo prodotto, desideri suggerire aggiornamenti tramite il supporto venditore?

Recensioni clienti

5.0 su 5 stelle
5 stelle
2
4 stelle
0
3 stelle
0
2 stelle
0
1 stella
0
Consulta entrambe le recensioni cliente
Condividi la tua opinione con altri clienti

Principali recensioni dei clienti

Di F.Maccarrone il 18 febbraio 2015
Formato: Copertina flessibile Acquisto verificato
Premetto che non ho ancora finito di leggere questo libro, ma mancano una manciata di pagine...
Fantastico: per chi lavora sul JavaScript da almeno un annetto permette di avere una visione più avanzata ed aperta su quello che il JavaScript può davvero fare. Potenzia alcuni punti focali, dei quali si pensava di avere già il massimo controllo.
Consigliatissimo anche per chi lavora su JavaScript da pochi mesi...
Acquisto più che valido
Commento Questa recensione ti è stata utile? No Invio feedback...
Grazie del feedback.
Spiacenti, non siamo stati in grado di registrare il voto. Provare di nuovo.
Segnala un abuso
Di Christian il 25 agosto 2016
Formato: Copertina flessibile Acquisto verificato
If you need to start or extend your knowledge on javascript and software development, this is a good choice.
Very Good
Commento Questa recensione ti è stata utile? No Invio feedback...
Grazie del feedback.
Spiacenti, non siamo stati in grado di registrare il voto. Provare di nuovo.
Segnala un abuso

Le recensioni clienti più utili su Amazon.com (beta) (Potrebbero essere presenti recensioni del programma "Early Reviewer Rewards")

Amazon.com: 3.7 su 5 stelle 19 recensioni
22 di 22 persone hanno trovato utile la seguente recensione
3.0 su 5 stelle only if you're in the tiny "target audience" 14 luglio 2015
Di C. Kollars - Pubblicato su Amazon.com
Formato: Copertina flessibile Acquisto verificato
I found this book extremely frustrating, and cannot recommend it outside its tiny target audience.

This is really two books inside just one cover. One of the books is about the Javascript language, particularly some very advanced techniques, and some "mom and apple pie" about putting together large applications (loose coupling, modules, etc.). The other book is an overview of new technologies useful in constructing large applications. The two book parts largely separate by chapter (although there's no suggestion of it in the Table of Contents). There is just enough blending together of the two parts though to justify publishing both parts inside one cover.

The first part describes quite a few advanced language techniques, including some I've never seen written up in any other book. The downside is the techniques are presented largely without evaluation (at least "comprehensible" evaluation) and without example uses. The second part briefly describes and then evaluates each of several new technologies, ranging from very commonly described ones (node.js, templates, JSON, fat clients, etc.) to ones you may have never heard of before (Siren, HATEOAS, new API Media mime-types, etc.). The downside is the descriptions are so brief it can be difficult to figure out which contexts each technology fits into.

Both book parts are substantial; don't be fooled by the moderate page count. There are no redundancies or segues; there aren't even hardly any comments in the example code snippets. I find most books too wordy and generally applaud a more concise style, but I see here that if carried too far conciseness turns into incomprehensibility. Too often I felt like I was slogging through a math textbook for an advanced class I wasn't even taking, and worse a book in which the copious equations hadn't been proofread very well. Too often I couldn't determine whether my puzzling how to fit together the comments in the text with the example code snippet was because I was insufficiently familiar with some concept, or a victim of another writing error.

There are lots and lots of snippets of example code; I'd say the majority of the pages include at least one code snippet. Despite their volume though I found they added little or nothing because they were so hard to parse for meaning. There are virtually no comments in the snippets. There's never even an alternate font or boldfaced line or lines. As a result I often couldn't even tell which part I should be looking at. Sometimes a snippet is complete and standalone; sometimes it assumes (without comment or pointer) the environment from a previous snippet; and sometimes it references variables and functions that as far as I could see were never defined anywhere. Once in a while each snippet reprised the previous one except with a few more lines; most of the time though each snippet is de-novo. Most of the time the whole snippet is relevant to the immediately surrounding text; but once in a while the snippet also includes an unusual construct illustrating a different concept that was covered several pages (or even chapters) earlier.

The target audience seems to be only web application system architects who already work full time in the field. Few others will be able to even puzzle through the majority of the content. Just one example of the many topics I found maddeningly over-abbreviated: In the discussion of "modules" a comment about it sometimes making the most sense to "precompile" the client-side Javascript really caught my attention. (It's possible to "pre-compile" Javascript? For another machine? And send it over the network? - In general HOW? What browser/client support is required? Is it possible with an Apache server? ) ...next topic

For the right people, this book will be great, and its extreme conciseness will be a plus; for everyone else though this book will be at least irrelevant and maybe even an active downer. The message I personally came away with was "you're not good enough, why are you trying?". I wish I could say that if folks who are just a little under-prepared reread enough times and worked hard enough they'd eventually "get it", but I suspect the book is so focussed on its target audience that others can't use it to "catch up" no matter what. Targeting such a tiny audience and making everyone else "feel stupid" seems to me an odd strategy for selling lots of books :-)
1 di 1 persone hanno trovato utile la seguente recensione
2.0 su 5 stelle Can't Decide Who Its Audience Is - Too Complex for Beginners, Too Simple for Pros 23 marzo 2017
Di Just Some Guy - Pubblicato su Amazon.com
Formato: Copertina flessibile Acquisto verificato
I'm giving a rough review, but I want to start with a caveat - it's not a _bad_ book. It's well written, easy to read, and contains some good information. That said, here's the problem I have with it: The author doesn't seem to be clear who he wrote it for. It's too complex for beginners, and too simple for pros.

I'm an experienced JavaScript developer, but I'm now learning HTML5 and Node. This book looked like a sure thing. Unlike most O'Reilly books I've read, however, this book is more of a high-level overview than a deep technical resource.

First, I don't even know why HTML5 is in the title. It barely touches on anything HTML5-related at all. It does use HTML, but none of the new HTML5 features.

Second, I've already read a beginners Node book, and thank God for that. This book goes thru a couple chapters where examples use Node-specific features and APIs, but it doesn't explain them in a useful way for anyone who doesn't know Node already. Once it does try to explain Node in some detail, it barely scratches the surface - just a high level overview of the very basics. That would be OK if it dove deep into pro-level features, but it doesn't do much of that either. It shows how he would write some things in Node, and it recommends certain Node libraries, etc., but it didn't teach me much about how to actually build my own web app from scratch with Node.

The same is true of JavaScript. If you're new to JavaScript, don't even bother with this book. It is NOT for beginners. It assumes a lot of experience - so much so that even I was confused at times and I'm experienced. But for a pro, it doesn't really go deeply enough into anything technical with JS. There are lots of examples, sure - but it's more like, "Here's how wrote this thing that I wrote" - without a whole lot of depth.

Third, the title mentions "Modern JS Libraries" - but again it barely scratches the surface. Elliott gives a quick high-level overview of Backbone and several other libraries, but it's just an intro. I can't say I learned anything meaningful about writing an app with Backbone, Angular, or the other libs he touches on. I know their names and have the ability to go do more research, but that's about it.

The author is clearly very technically strong and experienced, but he assumes his readers are too. I've been a web developer for 20 years, and I have a broad range of experience - and again, thank God. He talks about a lot of things that assume deep technical and industry experience. If you're a beginner you will be lost. If you're a pro, you'll be frustrated that he starts to get somewhat deep on certain things but then quickly moves on. This is not a technical resource I'll bookmark and keep on the shelf by my desk. It's just not that deep, at all.

To be fair, what this book does to well is discuss, at a high level, many of the general considerations a team would have when building a web app and some of the problems they might face. Again, though, it's a overview, not a meaningful technical road map.

Final word: This really isn't a _bad_ book, it's just not the book I expected. I'm a JS pro and an intermediate server-side guy, and I closed it asking myself, "What did I really learn from this?" I did learn some things - but I didn't learn how to build a JS App with Node, HTML5, or Modern JS Libraries. I'll need to read several more books for that. #sigh
1.0 su 5 stelle Avoid, much better JS books out there 2 maggio 2017
Di M. Caveney - Pubblicato su Amazon.com
Formato: Copertina flessibile Acquisto verificato
I'll echo what a lot of other readers have said, namely that this is a very confused book. Elliott clearly understands the language well, but all this really is a a bunch of short, not very useful overviews of certain high-level concepts. This book COULD have been useful had it been a good deal longer, with more elaboration given to pretty much all of the material covered. I feel ripped off.
7 di 8 persone hanno trovato utile la seguente recensione
4.0 su 5 stelle You'll learn a lot and get a lot done by reading this book 15 ottobre 2014
Di David F. Kaye - Pubblicato su Amazon.com
Formato: Copertina flessibile Acquisto verificato
This a cook's tour--but with more stops along the way--of building applications entirely with JavaScript, with clear examples for both server-side (really Node.js) and client-side environments.

It is not a book for a beginner who is new to the language of JavaScript. But if you're already comfortable using and discussing constructors, prototypes, callbacks, closures, type coercion, and/or have an opinion about "functional" vs. "object-oriented" programming, then you're ready for this book.

Eric has a handful of strong opinions which I've variously held and abandoned (and grudgingly re-adopted) over time. Most useful to me, then, are examples demonstrating fundamental concepts, and Eric provides plenty of those.

The appendix on JavaScript style is also a great resource, for in it Eric condenses so much of the "best practice" tips you've probably seen scattered throughout the JavaScript universe of discourse.

The only caveat is the one common to all programming books. Some software dates faster than others. In the JavaScript world, this is especially the case. It shows up in the different versions of Express, for example, or the battle between emerging build tools (Grunt vs. Gulp vs. ...) and testing libraries (QUnit vs. Mocha vs...). Eric shows how to care for and feed your application using Grunt with JSHint, QUnit and browserify. This works well enough that you should be able to swap out what you don't need for newer/faster/better modules and tools in the future, by which time the second edition should be ready (right, Eric? :).
31 di 31 persone hanno trovato utile la seguente recensione
3.0 su 5 stelle Less About Large-Scale Architecture Than Promised 3 novembre 2014
Di frankp93 - Pubblicato su Amazon.com
Formato: Copertina flessibile Recensione Vine di un prodotto gratuito ( Cos'è? )
A good half of the book is less about what I would consider architecture concerns - tier-design, MVC, scaling/performance, redundancy, security, deployment, etc. - and more about relatively advanced features of JavaScript: Functions (polymorphism, functional programming, asynchronous callbacks), Objects, Modules.

Don't get me wrong, this is worthwhile material, presented clearly with realistic code. But the title implies something more and, once that language feature groundwork was established, I felt the book focused too narrowly on individual technologies such as Node.js and designing Restful APIs rather than illustrating large scale design principles as a problem-solving resource.

If you've studied JavaScript in depth you've likely covered a lot of this already. My personal favorite title 'JavaScript for Web Developers' by Nicholas Zackas certainly covers many of the same advanced language features, beginning from the ground up.

If you're moving from a lower-level developer role to a tech lead/architect role it's certainly worth your time to know what's presented here. But don't expect it to be definitive or all-encompassing - there's much more to learn.

Ricerca articoli simili per categoria