Programming Google App Engine: The Book

PGAE 2015 is officially released!

2015-07-07T00:00:00Z

The new Programming Google App Engine books are out! You can now order the print and ebook editions, including PDF, ePub, and Mobi from O'Reilly, as well as the Kindle edition from Amazon.com. If you purchased the Early Release, you should now have the final ebook in your library on oreilly.com, and print pre-orders are on their way.

Haven't ordered yet? Check out these referral links:

Programming Google App Engine with Java: O'Reilly, Amazon
Programming Google App Engine with Python: O'Reilly, Amazon

I'm extremely pleased with how these turned out. The new language-specific versions are gorgeous and easy to use, and I'm excited to have new material on important App Engine topics. Thanks to the efforts of many people, these new books have had more technical and editorial review than ever before. Of course, any remaining errors are my own, and I'll track errata on the About page as well as update the text. (Fixes get pushed to the ebooks and the print pipeline automatically, because O'Reilly is amazing.)

Spread the word, post reviews, and send me feedback. Thank you for all of your support!

Slides and code from today's webcast; video soon

2015-04-21T00:00:00Z

Thanks to everyone who came to today's webcast, Building Scalable Web Apps with Python and Google Cloud Platform. I have posted the slides and a simple Flask code sample. The video of the webcast will be posted to O'Reilly's website later this week.

Post-production; upcoming Python webcast

2015-04-06T00:00:00Z

Post-production is well underway for the new PGAE books. This edition is getting substantial technical and editorial review to make sure everything is up to date and the new language-specific volumes are in good shape. I especially want to thank the many readers who have contributed Early Release feedback. Every piece of feedback has made these books better. Subscribers should be getting the most recent update this week. We're currently looking at a release date of the final print and ebook editions in June 2015.

I'm doing an O'Reilly webcast entitled Building Scalable Web Apps with Python and Google Cloud Platform on Tuesday, April 21, 2015. This will be a beginner/intermediate talk with a Python and App Engine focus, updating some material from my previous webcasts and mixing in some new stuff from the book—and maybe some stuff outside the scope of the book, time permitting. The webcast will be recorded. Register for updates and access to the live event and video. It's free!

PGAE 3rd ed. is draft complete!

2014-12-29T00:00:00Z

I just submitted the last set of major updates to both Programming Google App Engine books, and am officially declaring them "draft complete." There will be more testing and tweaking during post-production, and all of these changes will work their way through the Early Release pipeline until everybody has the final draft. After that, the print edition ships! Whew!

Prior to post-production layout adjustments, the latest PDFs are printing at nearly 400 pages for each of the Python and Java versions. It's come a long way since the 1st edition, which was 360-some pages covering both languages. Splitting the book into two volumes was a lot of work, but I'm convinced it was worth it. With these new editions, all of the material from the 2nd edition has been updated and cleaned up. Many new sections have been added, most recently an all new chapter introducing Cloud SQL, a new chapter and thorough updates for Python's ndb library, and an updated Python Django chapter. Naturally, I couldn't get to everything on my wishlist, but my ultimate wishlist encompasses all of Google Cloud Platform—not to mention all of web software engineering—so it's in everyone's best interest that I stop here and ship it.

A quick note about Blobstore: A while back I decided to remove the Blobstore chapter that was present in the 2nd edition, since the latest recommendation is to use Google Cloud Storage via the API client library instead (Python docs, Java docs). The Blobstore service is still available, and if you'd like to use it, you can read the Blobstore chapter of PGAE for free on this website.

There's still time to incorporate feedback! If you have the Early Release of PGAE Java or PGAE Python, you should be receiving the latest update soon. Let me know how you're liking the book. And many thanks to all of you who have sent in feedback during the Early Release process, I really appreciate it.

Lastly, the O'Reilly book on Google Compute Engine is now shipping! This book is a great companion to PGAE, especially if you plan to use multiple parts of Google Cloud Platform together. Congratulations to my author colleagues!

PGAE September Update

2014-09-18T00:00:00Z

Work on the new editions of the book continues, sporadically as always. My writing method follows a cyclical pattern: work intensely at the day job while feeling guilty about the book, panic, write 50 pages in a week, repeat. I've fallen behind my original schedule, but it looks like all of the updates to the existing material are about to wrap up soon. Then I can focus on adding all-new chapters up until the end of the drafting schedule.

The next Early Release update includes the completed introductory tutorial, extended chapters on configuration and request handling, and an all-new chapter on modules. I had originally intended modules to be a small section in the request handling chapter, but I decided it was too important a topic to cut short. Some readers might be interested in the newly added instructions on setting up SSL with a custom domain via Google Apps. And there are minor updates throughout.

The previous Early Release releases had some issues with missing diagrams. This is a technical issue with publishing that we hope to have resolved soon. Later chapters still have some out-of-date screenshots of the old App Engine Console that I'll be replacing soon.

There are several upcoming features of App Engine and Cloud Platform that haven't been officially released yet that I'd like to include in this edition. Of course, I can't say what they are, though I can mention one example, since it's already in public preview. The gcloud app command will be replacing the dev_appserver and appcfg commands, and if this leaves preview within our time window, I'll go through and update all of the example commands accordingly. You can try out the preview version today by installing the app component with gcloud components update app. During the preview, the command is called gcloud preview app. Of course, things may change a bit during the preview, and the dev_appserver and appcfg commands will continue to be available for the time being.

Thanks to everyone who completed the reader survey! I can't promise every requested feature will get into the text, but it's great to know what everyone is working on and what features would be useful.

Don't have the Early Release yet? Get the draft in progress as an ebook today, and receive all updates up to the final version for free:

Let me know what you think!

New PGAE for 2014, Early Release now available

2014-06-24T00:00:00Z

I'm pleased to announce that Programming Google App Engine is being revised for 2014, and you can purchase Early Release access starting today. For this revision, I'm splitting the book into two versions, one for Python and one for Java. The Early Release gets you ebooks of the draft in progress, and all updates up to the final text. You can also pre-order a print copy.

Go get your copy today:

Check out the new animal covers!

Today's Early Release draft includes the new language-specific edits, with minor updates and corrections throughout. Some chapters that are being replaced are missing, and some information may still be out of date. Pardon our dust. We have an aggressive writing schedule and intend to push regular updates.

Reader survey

Please take a moment and complete this brief reader survey. Responses are anonymous. I can use survey data to prioritize the writing schedule and justify deadline extensions for new material.

What's new?

The new drafts are still being written, and I don't want to promise too much until the material has been finalized. I have tentative plans for these new subjects:

Python's ndb library
The Search service
Google Cloud Storage
Google Cloud SQL
Google Cloud Endpoints
A fully updated introductory tutorial based on the new Cloud SDK and Cloud Console
Updates throughout covering the latest best practices and tools

Google Cloud Platform and App Engine have grown substantially since the 2nd edition, and the Platform as a whole is too large to cover properly in one book. My goal is to balance the writing schedule with new features that are ready to be written about in book form, and focus on features for web applications built primarily for App Engine's automatic scaling model.

Don't miss Google Compute Engine: Managing secure and scalable cloud computing by Marc Cohen et al., currently in Early Release from O'Reilly.

What about PHP and Go?

One of the goals for rewriting the book into separate language-specific versions is to open up the possibility for additional versions for the newer languages and APIs. We're still figuring out the right approach for covering App Engine's support for PHP and Go, and publishing contracts have not yet been signed.

If you'd like to see PHP and Go versions of the book, please complete the reader survey.

What about Blobstore and ext.db?

The features of the Blobstore service are now available in the more general Google Cloud Storage service. The Blobstore is still actively supported and used by many apps, but it doesn't make sense to cover both services in the book. Similarly, Python has a new datastore library called ndb, which replaces the ext.db library. I have decided to replace the material on these features from the 2nd edition with new material on the correpsonding new features.

But good news! Since both Blobstore and ext.db are still in active use by many apps, we are making the 2nd edition text of these chapters available for free online. I'm even throwing in the chapter on bulk data operations from the 1st edition, which some people missed when I removed it for the 2nd edition.

Data Modeling with Python and ext.db (2nd ed., 2012)
Large Data and the Blobstore (2nd ed., 2012)
Bulk Data Operations and Remote Access (1st ed., 2010)

These free bonus chapters come with caveats. The text is known to be old, may be out of date, and will not be updated or supported. Enjoy at your own risk!

Google I/O; OSCON

Google I/O starts tomorrow. If you're not there in person, don't miss the live video stream of the keynote presentation, starting at 9:00 am Pacific Time on June 25th. I won't be in San Francisco this year, but I'll be following the presentations eagerly from the Seattle office.

I will be at OSCON 2014 in Portland, Oregon, July 20-24. I'll be doing a book signing at the O'Reilly booth with freshly printed Early Release drafts, and I'll also be hanging around the Google booth. Tickets are still available. Come say hi!

Thanks all! Let me know what you think.

I/O 2013 talk now online

2013-05-26T00:00:00Z

Google I/O 2013 has ended, and all of the session videos are now online. My talk, "Building developers.google.com on App Engine," fit snugly in its 40-minute time slot, with a few minutes left over for questions. As usual, I compensated for having too much to say by speaking too quickly. Check out the video:

Here's the PDF of the slides, and the Github repo. I'm still fixing up and extending the demo app, but so far it should be a functional demo of the concepts described in the talk.

It was great meeting everyone at the conference, and I look forward to doing this again next year on a new topic. Now to go re-learn PHP...

I/O 2013 in May; new PGAE G+ page

2013-04-11T00:00:00Z

I'm currently slated to speak at Google I/O 2013 in May. My talk will be about my work on the Google Developers site, specifically the content management system, built on App Engine with Python. I'm currently in the throes of talk-writing agony, simultaneously nervous about meeting the high bar of the I/O conference, and panicked that I can't fit everything I want into 30 minutes. If you'll be there, consider attending my talk! If not, it'll be recorded and put online for free, which is awesome.

You can now follow Programming Google App Engine on Google+. You're still welcome to follow me on G+, but following the PGAE page directly will keep you up to date on book-related announcements without dragging my link blogging and casual musings into your stream. I will probably echo or link to entries from the book blog onto the G+ page, so if, say, you're about to lose access to your feed reader, you have another way to keep track.

Minor housekeeping note: I've moved the book's code sample repository to Github to be closer to my other Github activity. Github has a nice automatic Zip download feature, so you can always get the latest sample pack without using Git. See Code & Extras.

ndb webcast video and slides; O'Reilly will have PGAE 2e early!

2012-10-10T00:00:00Z

The video for yesterday's ndb webcast is now online. I've also posted the slides (PDF). You can find videos and slides for all of my webcasts in the Code & Extras page.

I have about half of the 2nd edition code samples in the code repository. I have a bunch more I want to add. Once those are done, I'll make a Zip archive available as well, but feel free to pull what's there directly from the repository.

While Amazon will ship PGAE 2e on October 26, I'm told O'Reilly will be selling it starting October 19!

Webcast tomorrow; 2nd edition launches October 26

2012-10-08T00:00:00Z

Just a reminder that I have a live webcast tomorrow (Tuesday) morning at 10am PT, entitled, "Data Modeling for Google App Engine using Python and ndb." I intend to keep the datastore material somewhat introductory, but all code will use ndb and Python 2.7. Hopefully there will be time to highlight a few of the major features that are new to ndb (over ext.db).

Also: Programming Google App Engine, 2nd edition, will be out for real this month! Early Access subscribers will get the final ebook, and print pre-orders will ship. Amazon.com is showing a release date of October 26.

In production; upcoming webcast

2012-08-14T00:00:00Z

PGAE, 2nd ed. is currently in the "production" part of the process. I'm tidying up language and testing code samples, and O'Reilly has a copy editor working through the book. Then we do layout, indexing, and illustration. Naturally, all of these improvements will make it into the digital Early Release edition. I'm expecting a street date of late September or early October. I'm still working on the downloadable code samples as well.

Meanwhile, I'm preparing another O'Reilly webcast, currently scheduled for October 9, entitled Data Modeling for Google App Engine using Python and ndb. The 2nd edition doesn't have any material on ndb, but it's a compelling enough topic that hopefully this can serve as a brief addendum for now. I'm especially excited about this one because we will be broadcasting live using Google+ Hangouts On Air. This means we'll have a quality video stream, as well as an automatic YouTube archive available within a couple of hours after the event finishes. This is a first for O'Reilly webcasts, so bare with us while we work out the details.

If you're an Early Release purchaser and have enjoyed the 2nd edition so far, you're invited to write a review for O'Reilly's website. It'll be nice to have some thoughtful and thorough reviews on the site for the launch date. :)

2nd Edition is Draft Complete

2012-07-21T00:00:00Z

I just submitted the last of the sections for the 2nd edition of PGAE, which means I get to say it is "draft complete." There's still editing and testing to do—drafting got a little hectic in the weeks running up to the deadline—but the outline is final and there's text everywhere. Early Release subscribers will get an update notification in the next week or so. The production process takes a couple of months, then the final edition will ship in late September or early October.

The rough PDFs that I can generate using O'Reilly's author tools puts this draft at 497 pages, not counting the table of contents. At least 50% of that is new or rewritten material. The actual page count of the printed book will vary slightly, but my recollection is the draft PDF comes pretty close.

What's new: The entire book has been updated for Python 2.7, multithreading, and the High Replication datastore. There's new material on recently added datastore features, including cursors, projection queries, and cross-group transactions. The task queues chapter has been extended with common use patterns and new features. The chapters on memcache, URL Fetch, email, and XMPP have been almost entirely rewritten from scratch for new features and better organization. Topics of all-new chapters include app configuration, instances, the Blobstore, request logs, and optimization techniques with asynchronous APIs and AppStats. And yes, the Django chapter is all new as well (though django-nonrel only gets a small discussion, as you can actually do quite a bit without it).

Inevitably, there wasn't enough time to do everything I wanted. Any feature currently marked as "experimental" or otherwise not fully launched ("Trusted Tester") does not have extensive coverage in the book. That includes the Go runtime. The new and hugely useful Python data library ndb, which came out a few months ago in release 1.6.4, I left out because I didn't feel I could do it justice in the time remaining in the schedule. Backends are not covered, partly because of the announcement made at I/O 2012 that the layout of the feature will be changing (though its basic features will not). A few older features like the Images and Channel services were low priorities because they don't contribute to the larger themes of the book, though I'm not opposed to adding self-contained chapters in a future edition.

While I'm testing and editing in the next few weeks, I'll also be working on new downloadable sample code. I'm hoping to have that ready by the street date (late September). As always, the sample code will be free to download even if you didn't buy the book.

Here's the 2nd edition chapter list:

Chapter 1: Introducing Google App Engine
Chapter 2: Creating an Application
Chapter 3: Configuring an Application
Chapter 4: Request Handlers and Instances
Chapter 5: Datastore Entities
Chapter 6: Datastore Queries
Chapter 7: Datastore Transactions
Chapter 8: Datastore Administration
Chapter 9: Data Modeling with Python
Chapter 10: The Java Persistence API
Chapter 11: The Memory Cache
Chapter 12: Large Data and the Blobstore
Chapter 13: Fetching URLs and Web Resources
Chapter 14: Sending and Receiving Email Messages
Chapter 15: Sending and Receiving Instant Messages with XMPP
Chapter 16: Task Queues and Scheduled Tasks
Chapter 17: Optimizing Service Calls
Chapter 18: The Django Web Application Framework
Chapter 19: Managing Request Logs
Chapter 20: Deploying and Managing Applications

Greetings from I/O 2012!

2012-06-29T00:00:00Z

I'm writing this in the late evening on day two of Google I/O 2012, from my hotel in downtown San Francisco. I've had a great time meeting people at I/O and chatting about App Engine. If you're reading this after having met me at the conference, welcome to the book blog!

By now you've probably heard about the boatload of awesome stuff Google has announced at the conference, not the least of which is Google Compute Engine, a new sister service to App Engine for large-scale computing with Linux virtual machines on efficient and robust infrastructure. Be sure to check out the new cloud.google.com site for overview and pricing information on all of Google's cloud products.

Earlier this week, App Engine 1.7.0 launched with several major new features, such as SSL for custom domains, a new EU hosting option, GeoPoint searches in the Search service, and more. Launcher and Eclipse updates should be propagating shortly, and you can download fresh SDKs—including a new Go SDK for Windows!

The video archive of my June 14 webcast is now available for viewing at your leisure. You can also download the slides. Links and resources for both of the webcasts I've done so far are now on the Code & Extras page.

As for book progress: the next update still isn't quite done, but I'm gunning for an update for next week, and draft complete (yikes!) in July. I'll finish the 2nd edition downloadable code samples some time after that, so don't expect it right away. I'm trying not to let this last deadline slip, but there's still a ton of important stuff I haven't gotten to yet. For just one example, I'm increasingly convinced that the 2nd edition needs to cover ndb for Python, either by replacing the ext.db material or by adding a new chapter. Progress waits for no one, not the least of which book authors, and we gotta stop this train somewhere. (Did you know Eclipse 4 just came out?) But if it's stable tech and it's a major part of the AE development experience, I want it in the book, and I'm sure you do too.

There's still one more full day of I/O remaining! If you're not at the conference, stay tuned for the session videos. Just like past years, we're sitting on a gold mine.

Webcast tomorrow; 50% off; June status

2012-06-13T00:00:00Z

(I made a tweak to this blog's Atom feed that caused old entries to pop up in my Google Reader. Apologies for the inconvenience.)

First a reminder that I'm giving another webcast Thursday (tomorrow) 10am PT. The title on the site is Python for Google App Engine. Naturally that's a huge subject, so I've streamlined my slide deck to focus on setting up and understanding a Python development environment for App Engine: installation, tools, IDEs, unit testing, deployment. And it'll still be a tight fit for an hour. Should be fun. As before, the webcast is free, and it'll be archived for later viewing if you can't make it live.

If you haven't yet bought into the Early Release ebook, here's an excuse: O'Reilly is offering 50% off for select Early Release titles, including PGAE! This week only, so get in quick. Early Release gets you access to the intermediate drafts all the way up to the final ebook, in all of the DRM-free ebook formats.

I've set my 2nd edition draft complete date as early July. We're leaving a bit of time to accommodate anything that might be announced at Google I/O in two weeks—and I don't know what if anything will be announced, so don't read anything into that. :) I've got updates for the datastore, memcache, and URL fetch chapters on deck, and plans for new chapters on datastore administration and the async APIs. Next up is substantial updates to task queues. I'll also be rewriting the Django chapter. I have a dozen or so other topics that deserve their own chapters, and I'll try to get through as many of them as I can.

May 15 webcast now available

2012-05-23T00:00:00Z

The video archive of Introducing Google App Engine, my webcast from last Tuesday, is now online for viewing at your leisure. You can also download the slides (PDF). The On24 presentation viewer will ask you to "register," but registration is free. Be sure to click when prompted to open the screen share viewer.

And don't forget Paul Barry's Thoughts On Google App Engine is on Friday, June 1, and my Python for Google App Engine on Thursday, June 14.

Upcoming Webcasts: May 15, June 1, June 14

2012-05-07T00:00:00Z

Hey folks, don't miss three live webcasts on App Engine, coming up fast from O'Reilly Media:

May 15 (Tuesday—that's next week!), 10AM PT: Introducing Google App Engine, Dan Sanderson, author of Programming Google App Engine (that's me). An overview of App Engine's features and tools, followed by a discussion of application design. No AE experience required, but the emphasis will be technical, so some programming experience is recommended. Register.

June 1 (Friday), 10AM PT: Thoughts on Google App Engine: a Python Programmer's Perspective, Paul Barry, author of Head First Python. Another angle on App Engine from the trenches, answering common questions and fielding questions from the room. Paul is an experienced developer, writer, and educator of both Python and App Engine. Information will be language-agnostic, with demos in Python. Register.

June 14 (Thursday), 10AM PT: Python for Google App Engine, Dan Sanderson, author of Programming Google App Engine (me again). Python-specific App Engine topics, including development workflows, application frameworks, and testing tools. I'll be drawing some of this material from my experiences developing a major AE app in Python over the past 18 months. Some Python experience recommended. Register.

They're all free (!), but registration is required. These will be recorded and archived.

Next release: mail and XMPP; minor updates throughout

2012-04-07T00:00:00Z

I'm throwing every scrap of time I can find at making little updates here and there, and scheduling long sessions to plow through chapter-long tasks. This is entirely the wrong way to go about a large project from a time and energy management perspective, but at least it's some kind of progress.

The draft in flight has a new chapter on XMPP, now split from the chapter on mail which has also been updated. XMPP coverage has been expanded to include all the presence features. I'm taking this opportunity to rewrite and expand all of the downloadable sample code in both Python and Java. (I'll post the new sample code once it's further along.) I've also made a bunch of minor updates throughout, just to close out parts of the gigantic to-do list I made by aggregating all of the release notes from the last two years and sorting them by feature category.

My next priority is to split chapter 3, "Handling Web Requests," into two chapters, one on frontend configuration (URL routing, static files, SSL) and one on application servers (runtime environments, instances, multithreading). The new-feature list for the datastore is huge, and I hope to incorporate most of it in the datastore chapters. I'm planning a new chapter on "Datastore Administration," which will include the recent Admin Console datastore facilities, the entirely rewritten bulk loader, the remote API, and maybe trivial data transformations using MapReduce if I can squeeze it in. (The old bulk loader chapter will be deleted, though I have permission from O'Reilly to post discarded chapters to this website, if that'd interest anyone.)

The App Engine team just recently released ndb, a complete replacement for the db library described by the 1st ed's chapter 7. The DataNucleus App Engine plugin version 2.0 is out, which means chapter 8 also needs some serious attention. The asynchronous APIs and AppStats are important subjects worthy of a chapter. The subject of task queues has more than doubled in size, and transactional tasks are more important than ever and need more coverage. The Django chapter needs a complete rewrite to cover djangoappengine and Django 1.3. And I want new chapters and sample code on the Images and Channel APIs.

I'll have more to say about the schedule later, but this is the general order of the next dozen or so things.

RC update in flight: new intro tutorials, Blobstore chapter

2012-01-26T00:00:00Z

I've submitted major updates to Chapter 2 and an all-new chapter on the Blobstore to O'Reilly. Rough Cuts subscribers should see them at some point in the next week. RC releases are not fully automatic, so it takes a few days between when I submit it and when it's live on the site.

As I mentioned earlier, for the 2nd edition I'm recommending the Python 2.7 runtime with multithreading enabled for all new Python apps. The new chapter 2 tutorial reflects this. I'll be going through the entire book and updating the Python samples for 2.7 and testing with multithreading. I do not currently plan on including any material in the book about upgrading from Python 2.5, but I could be talked into it.

I've added Jinja2 templates to the Python tutorial, and rudimentary JSPs, JSTL, and EL to the Java tutorial. It's always bothered me that the first example in the book did horrible things like print HTML directly from the handler code. This also allows me to include larger samples later in the book that rely on some light templating to keep things organized. I've also updated all of the screenshots in Chapter 2 (which will look hideous in drafts until the art department cleans them up), which doesn't help you that much but makes me feel better.

The Blobstore chapter is mostly written (22 pages in the PDF draft), but there's still a bit left to do. The chapter will include a complete sample app, in both Python and Java, for accepting, managing, and serving user uploaded files. Right now, most of the full sample is present for Java, though I'll be reorganizing it. The equivalent sample for Python is written but isn't placed in the text yet. I'm planning two short sections on reading from and creating Blobstore values from within the app; right now they're empty headings.

I also set up an empty heading for a new chapter on the Images service. I omitted the Images service from the 1st edition despite it being available from day one, and nobody has been banging on my door asking for it. But with the new Blobstore integration, I think it's a cool enough feature to deserve a brief chapter. The plan is to extend the Blobstore example app with image hosting and thumbnailing features.

But enough about plans.

Quick Java datastore survey; 2e status

2012-01-16T00:00:00Z

Hey Java App Engine developers, I put up a quick survey on G+ regarding which datastore interfaces you'd like to see covered in the book. Just +1 the comments to vote for one or more options, or just leave a comment. JDO/JPA is a big part of the portability story for Java App Engine, and when the 1st edition came out it was the most featureful option for building a class-based modeling layer on top of the low-level API. Since then, people have come up with cool things like Objectify, and have otherwise done well with just the low-level API. So I'm wondering if anyone would be too disappointed if I rewrote chapter 2 to use either the low-level API or Objectify, and maybe throw in a chapter on Objectify.

Oh, and I bet you're wondering what the heck is going on with the 2nd edition. My busy Q4 last year pretty much ruined all the hopes I had of being draft complete by January, but I finally have some momentum back. I'm releasing a few long-overdue chapters next week, including a rewritten Python tutorial in Chapter 2 that uses Python 2.7 and Jinja2 templates. I'm also trying to get the code samples re-tested and re-organized, but one thing at a time.

I'll continue to post book-related updates here, but if you're interested, you can also follow me on Google+.

A Line in the Sand

2011-10-21T00:00:00Z

Back when I was writing the first edition of the book, I wrote a blog post entitled Moving Targets, about the difficulties of writing in long form about a rapidly changing technical product. I'll try not to repeat myself, except to say that if everyone could petition Google to give the App Engine team a mandatory 2-month vacation, I'd appreciate it.

The plan for the 2nd edition has always been to consider everything up to the "out of preview" release to be fair game for the book. I especially want to capture features that change the emphasis and direction of how App Engine should be used. The "out of preview" release is imminent, but with monthly feature releases, the App Engine team has managed to add some big stuff in the meantime. The recent 1.5.5 release introduced the new Python 2.7 runtime environment, with multithreading, improvements to library support, and a new major version of the webapp application framework. They've also raised many of the major limits, including file size (32MB), file count (10,000), the frontend request deadline (60 seconds), and the URL fetch deadline (60 seconds). Oh, and you can now perform datastore transactions involving multiple entity groups. This was 10 days ago.

As with the 1st edition, the 2nd edition can't cover everything. But it also can't ignore the big new ideas some of these features represent. I'll be adjusting my writing schedule, and the book's release date, to accommodate some (but not all) of the recent releases, and will continue to keep an eye on the out-of-preview milestone before finalizing the 2nd edition outline. There's still some big stuff on the roadmap, but any self-contained subject about a feature currently unreleased or in "experimental" status may have to wait until the 3rd edition.

In the meantime, I'll try to increase the frequency of Rough Cuts releases, even at the risk of releasing incomplete or inaccurate text, though this probably won't start in earnest until next month. I'm also going to try posting to the blog for each RC release with a summary of what has changed.