Customer Reviews

Developing with Google App Engine (Firstpress)

5 star:		(1)
4 star:		(0)
3 star:		(1)
2 star:		(2)
1 star:		(2)

 

 

I was really looking forward to reading this book. I've been working with the Google App Engine from the first week it was released, but as a Python newbie, I still thought I'd get a lot out of a book dedicated to GAE development.

Unfortunately, the book doesn't go far enough beyond the Google online documentation to be useful. The book is thin, but it also uses an incredibly large font size throughout. It's like a junior high school student trying to stretch a book report to meet the teacher's page number requirement.

There are plenty of topics that warrant discussion but are strangely absent. Performance profiling and the performance of the datastore are topics that many developers are struggling with but the book says little or nothing on these topics, and others.

I was looking forward to this book, but it didn't come anywhere close to my expectations.

On the cover, they claim 168 pages. I guess that's true if you count the table of contents, the dedication, chapter 9 that doesn't give you any actual information on the administration of applications, related titles, copyright, and a couple of blank pages in the total. I count more like 144 pages of big font.

I would have overlooked the length and been more generous with my rating, but what's there just isn't very good. It doesn't try to be any sort of a reference, but it doesn't flow, either. The author uses a bookmarking application to present concepts, but the order and presentation just don't work very well. It comes out as a bunch of random code snip-its, without good explanation.

I learned a lot more from Google's online "Hello, World" tutorial.

Take a look at Amazon's "Look Inside" feature and you should get a sense of what's wrong here: this is one very thin book written in very large font, and won't get you anywhere near to developing and deploying an app on GAE. As another review has said, it's shocking that Google's online 'Hello World' example is more instructive than anything presented here. Additionally, though the author has a background in scaling and it's mentioned several times, there's no practical information given on how to build a Digg-proof app beyond the fact that GAE will handle it somehow.

This book can be used (in conjunction with documentation from Google--[..] to create your first Google App Engine application in Python. Google App Engine is a powerful cloud computing platform and this book help you getting started. There are materials and steps are missing in the book that you can easily found them from Google. The author has put in good faith efforts while writing the book (most likely with very limited information while he was firs started) and the book has covered a good array of web application development topics: database connection, transaction, sending email, styling, user authentication, deployment, etc. The challenge is that when this book gone through the editing, design, layout, and printing process, Google has so much documentation and how-to videos posted on their website now.

Another missing part of this book is Java. For Java developers, they can use Eclipse plug-in and connect to database with JDO. All of these are missing since the book is solely focused on Python. If you are a Java developer and you should find some resources from Google. Yes, not everybody has to develop application using Python to work with Google App Engine.

The first impression of this book is not the best in terms of layout--fonts are too big, some screen shots are fuzzy, and several blank pages were padded at the end.

This is really awful.
Terrible organization, confusing composition.
Seems First Press wanted a GAE book out quickly.

This is a great book for quickly getting up to speed with Google App Engine. After a quick introduction to the basic concepts of cloud computing and where App Engine fits among other offerings like Amazon Web Services, the book dives into how to create a simple application, shows the App Engine event handling mechanism that enables massive scalability, and provides the basic setup for developing applications.

I liked the best how the author laid out the design of a simple (but non-trivial) application in chapter 3 that included the Garrett diagrams, entity-relationship diagrams, and requirements overview, then incrementally expanded on each portion of the application as the book progressed: UI and templates, the datastore, memory caching, integration with other services, and application management each has a dedicated chapter, and the chapters (and the application) build on the knowledge and code from the previous ones.

The discussions about the datastore take almost half of the book because it's such a rich topic. While the Google App Engine documentation provides overall information, it doesn't provide a simple cohesive example that's carried throughout. This book's discussion of datastore presents analogies and differences against relational databases and other storage technologies. The author paid particular attention to how to optimize datastore queries and calls, referential integrity, and why traditional database optimization techniques like normalization may be counterproductive in the datastore environment.

I liked the brevity of the text, and that neither the author or the publisher didn't feel the need to write lots of meaningless text or to include every full program listing in the body of the book. It's compact size makes it easy to find topics of interest if it's used as a reference.

I've been coding for App Engine since around September 2008 and I wish this had been available then. While Google's on-line documentation is somewhat complete, it lacks the cohesiveness and continuity that you find in something like this book, and it's missing details that can only be found by spending lots of time browsing and searching the developer groups. The author is a participant in those groups, and he distilled a lot of that information into this book.

The last chapter is about App Engine application administration; it's not as detailed as the rest of the book but based on the screen captures that's because it was written earlier in the life of App Engine. The Google team keeps updating the UI, profiling, and performance tools, and the screen captures show views from around October. The rest of the content is accurate and up-to-date, as the APIs and application layout haven't changed.

I'd recommend this book to anyone who wants to get going with writing App Engine applications and doesn't want to spend a lot of time hunting for information scattered throughout Google's on-line documentation. If "get it done fast" is in your schedule, this book is a great place to start.