# Revision History - Google App Engine - Google Code

English ▼
Skip to page content Skip to main navigation
e.g. "templates" or "datastore"

# Revision History

The documentation for Google App Engine available on this website is revised regularly. This page describes notable changes made to the documentation.

For information about changes to the App Engine API, the runtime environment, or the SDK, see the release notes.

2011-05-10

- App Engine 1.5.0 SDKs are now available for Python and Java.
- New Default Datastore: App Engine now uses the High Replication datastore by default.
- New Runtime! App Engine now supports several services implemented in the Go programming language.
- New Feature: App Engine Backends allow you to run larger jobs on configurable instances.
- New Feature: Pull Queues allow you to lease tasks from within your app or from code outside your app using the Task Queue REST API.
- New Feature: Asynchronous Datastore API for Python allows you to make parallel, non-blocking calls to the datastore and to retrieve the results of these calls at a later point in the handling of the request.
- Updated several quotas.

2011-03-30

- App Engine 1.4.3 SDKs are now available for Python and Java.
- New feature: Prospective Search API. Prospective Search allows your application to match a large number of queries over a stream of input documents.
- New feature: Java Remote API. The Java SDK includes a library called Remote API that lets you transparently access App Engine services from any Java application.
- New feature: New unit testing capabilities for Python.
- New feature: Java support for concurrent requests.
- New feature: Deferred API for Java uses Java serialization to packagea unit of work into the task queue.
- New feature: Blobstore writing allows you to programmatically write blobs to the blobstore.
- New docs for an existing feature: We now provide documentation of roles in the admin console.
- Bug fixes: Fixed documentation issues related to inconsistent parameter naming, missing or incorrect quotas, broken code samples, broken links, and more.

2011-02-10

- App Engine 1.4.2 SDKs are now available for Python and Java.
- New feature: Capabilities API. The Capabilities API allows you to detect when an App Engine capability is unavailable, so you can avoid latency in your application.
- New feature: XMPP v2. The XMPP service provides new methods to handle presence and send the application's chat status.
- New feature: You can now clear tasks from the task queue programmatically.
- New feature: Task Queue configuration includes a new parameter allowing you to limit the number of tasks being performed in a queue at a given time.
- New feature: `app.yaml` includes a `deferred` builtin handler that allows developers to simplify the creation of task queue tasks.
- New feature: The Java SDK supports vacuum indexes.
- New feature: The low-level Memcache API includes additional functions for the Memcache service.
- New feature: URL Fetch includes a new method allowing you to validate certificates.
- New feature: Django 1.2.5 is now available in the Python SDK.

2011-01-04

- The App Engine 1.4.1 Python SDK is now available. There is no Java SDK in this release.
- New feature: High replication datastore. The High Replication Datastore provides higher availability of reads and writes, at the cost of increased latency for writes, higher cost, and changes in consistency guarantees in the API.
- New feature: Use the Admin Console to disable writes to your datastore.
- New feature: In the Python runtime, copy application data between App Engine applications.
- Limit increase: 10 minute offline URL fetches.

2010-12-03

- App Engine 1.4.0 SDKs are now available for Python and Java. (This is a major release, so version numbers increased from 1.3.8 directly to 1.4.0.)
- New feature: Using Always On, you can pay to keep 3 instances of your application always running, which can significantly reduce application latency.
- New feature: Reduce latency using warmup requests.
- New Feature: Use the Channel API to create a persistent connection between your application and Google servers, allowing your application to send messages to JavaScript clients in real time without the use of polling.
- New feature: Configure custom retry parameters from queue.yaml.
- Limit increase: Deadline for tasks increased from 30s to 2m.
- Limit increase: Apps that have enabled billing are allowed up to 100 queues with the Task Queue API.
- New feature: Run metadata queries on your datastore data.
- Quotas increased for URL fetch, task queue, images, mail, and memcache.
- New feature: Download previously updated code, and lock code so it can't be downloaded.
- Task queues is now out of labs.

2010-10-14

- App Engine 1.3.8 SDKs are now available for Python and Java.
- New feature: Run tasks from the Admin Console.
- New feature: Include standard libraries in your application using builtin handlers.
- New feature (experimental): From the Admin console, delete all entities of a kind, or all entities of all kinds, in the default namespace.
- The imageclass now provides a `quality` argument to `execute_transforms` and `composite`.
- Python precompilation is now enabled by default.

2010-08-17

- App Engine 1.3.6 SDKs are now available for Python and Java.
- New feature: The Namespaces API for Java and Python. With namespaces, you can easily compartmentalize your Google App Engine data. Namespaces make it easy to create multitenant applications.
- New feature: YAML configuration is now available in the Java runtime.
- The Image Service API now includes a new, high-performance image serving system for your applications, based on the same infrastructure we use to serve images for Picasa. This feature allows you to generate thumbnails and cropped thumbnails from the same source image, so you only need to store one version of the image.
- You can configure custom error handlers in your `app.yaml` or `appengine-web.xml` file.
- The datastore no longer enforces a 1000 entity limit on for `count` and `offset`.
- We have raised nearly all of the burst quotas for free apps to the same level as the burst quotas for billed apps.
- Content-Range headers are now supported with the Blobstore API.

2010-06-20

- App Engine 1.3.5 SDKs are now available for Python and Java.
- Apps can now read Blobstore values using file-like interfaces in both Python and Java. These interfaces use multiple service calls behind the scenes to access values larger than 1 megabyte. (Apps still cannot create or modify Blobstore values directly.)
- Task Queue maximum throughput has been upgraded to 50 qps per queue. (Previously it was limited to 50 qps for the entire app.)
- The Python runtime environment now supports "precompilation," a feature which improves load time and per-request CPU utilization for Python applications. For now, it is disabled by default. You can enable it with a configuration change. This will be made the default in a future release.
- Python: The development server now drives task queues automatically. You no longer need to use the developer console to run queued tasks.
- Python: `db.delete()` now accepts an iterable of keys or models.

2010-05-19

- App Engine 1.3.4 SDKs are now available for Python and Java.
- You can now use Google Accounts to build apps that act as OAuth service providers.
- App Engine now supports federated logins with any OpenID identity provider. Google Accounts is an OpenID identity provider, so upgrading your app to use OpenID supports existing Google Accounts users.
- We are pleased to announce App Engine for Business, a new pricing plan and feature set for App Engine designed for business use.
- Blobstore is no longer an experimental API and now supports blobs up to 2GB in size

2010-04-21

- App Engine 1.3.3 SDKs are now available for Python and Java.
- The Blobstore now supports serving part of a Blobstore value to the client, specified as a range of bytes in a response header. The Python helper classes make it easy to set this header, and to allow the user to request a byte range using a request header.
- The datastore now supports pre-allocating system IDs in application-defined ranges. This is useful for preserving system IDs when importing entities exported from another app.
- You can now configure the total amount of storage pending tasks in a task queue can consume. If adding a task would cause the queue to exceed its storage limit, the call to add the task will fail. The default limit is `100M` per queue.

2010-03-29

- Documentation for the two new datastore features in the 1.3.2 release is now on the site. See below for details.

2010-03-25

- App Engine 1.3.2 SDKs are now available for Python and Java.
- The datastore now has two modes of reading entities and performing queries: strong consistency (the original behavior, and the default) and eventual consistency. With strong consistency, all reads and queries wait for pending changes (changes that have been committed but not yet applied to distributed storage) to be applied before reading. With eventual consistency, reads and queries will use the version of the data already available in distributed storage, even if there are pending changes. You can use eventual consistency for faster reads in cases where speed is more important than having up-to-date data.
- The datastore now supports setting a deadline for most operations. If the datastore does not complete an operation before the deadline supplied by the app, the call is aborted and control returns to the application. The default behavior is to wait for the datastore until it returns or until the runtime environment's own deadline elapses.
- You can now use the Denial of Service (DoS) Protection service to prevent clients from specific IP addresses and subnets from accessing your app. See the Java DoS configuration and Python DoS configuration documentation.
- The Appstats utility is now available for Java.
- You can now access data in a Blobstore value from the application. The app can retrieve bytes from a Blobstore value in a given byte range, up to approximately one megabyte's worth of data at a time.
- You can now add multiple tasks to a queue in a single batch API call.
- The maximum task queue refill rate has been raised to 50/second.
- URL Fetch can now access ports on remote hosts other than 80 and 443. The allowed remote port ranges are 80-90, 440-450, and 1024-65535.
- The list of allowed email attachment types now includes several office document types, including Microsoft Word (`.doc`).
- The Python interface for accessing attachments on incoming email messages has changed slightly: `InboundEmailMessage`'s `attachments` property is now always a list of tuples, and is no longer set to a non-list value when there is only one attachment.
- The description of how simultaneous requests are managed has been updated.
- Be sure to check out the updated Product Roadmap!

2010-03-03

- To clean up the appearance of the sidebar navigation, we've removed the word "(Experimental)" from the sidebar for the sections on the Blobstore and Task Queues. Note that these features are still considered "experimental"—and are noted as such in the documentation—and the APIs may still change.

2010-02-09

- App Engine 1.3.1 SDKs are now available for Python and Java.
- Datastore queries now have persistent cursors that let you fetch some results during one web request, store a cursor, then use the cursor to fetch additional results from where the last query left off. This is now the most efficient way to implement pagination, and can also be used for maintaining checkpoints and querying for "new" results.
- The Java URL Fetch low-level interface now supports asynchronous calls, using `java.util.concurrent.Future`.
- The Java SDK now includes helper classes for writing unit tests that use local services. Added Local Unit Testing describing how to use these new classes and updated the original unit testing article to point to this new page.
- The Python SDK now includes Appstats, a suite of tools for profiling the performance of an application. See the Appstats documentation.
- The JCache interface is now implemented in the package `net.sf.jsr107`, instead of `javax.cache`, to avoid confusion about the status of this proposed standard. `javax.cache` will continue to be supported throughout this major version (1.x.x) of the Java runtime environment, but the documentation now recommends `net.sf.jsr107`. (You may find the low-level memcache API more to your liking.)
- Schedule task configuration now supports "synchronized" interval scheduling, which starts a job on an interval synchronized from midnight of the current day regardless of how long it takes the previous job to finish, as in `every 2 hours synchronized`. It also now supports calendar scheduling for specific days of every month, as in `1,8,15,22 of month 09:00`.
- Java AppCfg now supports an `--append` option for the `request_logs` action, which appends the requested log data to the end of the log file instead of overwriting the file.
- The quotas documentation has been updated to clarify that URL Fetch is limited by the incoming and outgoing bandwidth limits. Previously, the documentation indicated a limit of 4 GB for URL Fetch bandwidth, but this is higher than the incoming and outgoing bandwidth limits (currently 1 GB).
- App Engine now uses a "precompilation" process to enhance the performance of Java bytecode. If you prefer that precompilation not be used with your app, you can turn this off in your `appengine-web.xml` file.
- All Python examples now recommend using the `run_wsgi_app()` function from the `google.appengine.ext.webapp.util` module to start a WSGI app. Older versions of the docs used the `CGIHandler` class from the `wsgiref` module in the standard library, but this class doesn't fully accommodate long running processes and may leak data between requests through environment variables. `run_wsgi_app()` properly resets the environment between requests, and is the recommended way to start a WSGI app on App Engine.
- The bulk loader tools can now download all entities of all kinds. It uses the datastore statistics entities to determine the kinds to download. The bulk loader documentation has also been clarified to mention the Java remote API servlet, remove the sqlite3 installation instructions (this was only required for Python 2.4), and to correct the `bulkloader.py` command line.
- Datastore queries can now return as many results as the app can fetch within the 30 second request handler limit. A query is no longer constrained to returning 1,000 results.

2010-02-01

- Corrected documentation that described the ordering of datastore query results when no ordering is specified. Previously, the documentation said that the order was key by default which is not always correct. The documenation now states that when no sort order is specified, the datastore ordering is undefined and may change over time.

2010-01-19

- Added instructions on how to gracefully degrade memcache and datastore operations during a scheduled outage.

2009-12-14

- App Engine 1.3.0 SDKs are now available for Python and Java.
- The new Blobstore service lets your app serve files up to 50 megabytes in size, and accept large files as uploads from users. While the app cannot manipulate Blobstore values directly, it can process forms with file upload fields, and can serve a Blobstore value as a response from any request handler. This is an experimental feature and is subject to change. Let us know what you think!
- The Images service has limited support for processing image files stored in the Blobstore. The source can be larger than 1 megabyte, but the result of the transformation must be smaller than 1 megabyte. This is useful for making thumbnail images of large photographs uploaded by users.
- An app can now configure what happens when a URL restricted by Google Accounts in the app configuration is visited by a user who is not signed in. By default, the user is redirected to a sign-in page. You can now configure the app to simply reject requests from unauthenticated clients.
- Java Unit Testing How-to updated with information on testing Task Queue tasks.
- Incoming and Outgoing Bandwidth quotas have new default maximum rates of 10 gigabytes/minute, up from 740 megabytes/minute.

2009-12-11

- Clarified how query filters interact with list properties.

2009-12-03

- App Engine 1.2.8 SDKs are now available for Python and Java.
- The Memcache APIs (Python and Java) have a new function which lets you increment or decrement multiple integer values in a single API call. For Python, see Memcache Functions: offset_multi(). For Java, see the Javadoc.
- The URL Fetch APIs (Python and Java low-level) have a new attribute on the response object equal to the actual URL that returned the response. This may differ from the requested URL if the fetch followed redirects. For Python, see URL Fetch: Response Objects. For Java low-level, see the Javadoc.
- Task queues now consider any HTTP status code in the range 200-299 returned by a task's request handler to represent the successful completion of the task.
- You can now manage task queues from the Administration Console. You can inspect queues, delete individual tasks, and delete every task on a queue.
- The Java JDO and JPA interfaces now have partial support for data class inheritance.
- Outgoing mail messages now support attachments that are MPEG, MPEG-4, Quicktime and AVI video files and FLAC, MIDI, MPEG-3, Ogg Vorbis, AIFF and WAV audio files.
- The `SERVER_SOFTWARE` environment variable is now set to a useful value when running on App Engine. (Previously it was only set in the Python development server.)

2009-11-06

- Expanded and clarified Model.get_or_insert().
- Mentioned kindless queries in the Query class reference.
- Added a caveat to list properties: value order is not preserved between `Blob/Text` and non-`Blob/Text` values.
- Python code samples now use 4-space indentation widths throughout the documentation.

2009-10-26

- The Java Getting Started Guide and JDO documentation have been updated to use the `Key` class instead of a Long integer ID. This change was made to reduce confusion caused by the inability to use Long IDs for "child" classes in a relationship.

2009-10-15

- We've done a new bug-fix release of the Python runtime environment and SDK, known as release 1.2.7, to fix two problems with the 1.2.6 release. First, the 1.2.6 release added a `key` argument to the `Model` class constructor that broke subclasses who were calling the constructor's private arguments with positional (not named) values. The fix is to restore the original ordering, and require that the new `key` argument be specified as a named argument only. The documentation has been adjusted accordingly. Second, 1.2.6 broke an interaction between remote_api and the development server. This has been fixed. You can download the Python 1.2.7 SDK. The Java runtime and SDK are unchanged.

2009-10-07

- App Engine 1.2.6 SDKs are now available for Python and Java.
- Java AppCfg now supports the `update_queues` and `cron_info` actions.
- You can now pre-allocate system IDs for datastore entities in the Python and Java low-level APIs. Among other things, this is useful for storing references between two newly created entities without having to save one of them twice, such as within a single transaction. See the Python docs for db.allocate_ids() and the Javadoc for DatastoreService.allocateIds().
- The Python `bulkloader.py --restore` feature now preserves numeric system IDs and reference properties correctly in all cases. You can now upload a data dump to an app that is different from the app that originally contained the data.
- HTTPS is now enabled for all URL paths by default, in both the Java and Python runtime environments. In Java, you no longer need to enable SSL with configuration, though you can disable it this way if you want to. URLs that are not restrictd to HTTPS only in the deployment descriptor support both HTTP and HTTPS by default. In Python, `secure: optional` is now the default (was `secure: never`); you can explicitly configure URLs to be `secure: never`. Note that the new default will not take effect until the next time you deploy your app.
- You can now view statistics about how your application's datastore data in the Administration Console. You can also access these statistics programmatically using specially named datastore entities.

2009-09-09

- Task queues: added docs for `appcfg.py update_queues` action.
- Task queues: added docs about headers included with the task web hook request, including the queue name, the task name and the task retry count.
- Task queues: added a note about testing task queues in the development server. (The dev server does not drive task queues, but you can do it manually from the Console.)
- Task queues: added the maximum countdown/ETA to the limits table (30 days).
- Task queues: added a note about how task web hooks are accessed with admin credentials, so you can restrict web hook URLs to be admin-only.
- Task queues: clarified explanation of rate and bucket size parameters.
- Fixed the XMPP Java example code.
- The Java Users interface exposes user IDs as of release 1.2.5, tweaked docs to represent this.
- Added a note about the need to obscure user IDs in public data. (User IDs are global to all apps.)
- Added reference entry for `appcfg.sh update_cron`.
- Added a link to the JDO/JPA implementation open source project to the Resources section of the nav bar.
- Added a note to the memcache limits table about key size: keys over 250 bytes are hashed to 250 bytes.
- Corrected misleading statement about Java static files: files in `WEB-INF/` can never be static files, and are always resource files.
- Documented Python datastore methods for serializing and deserializing Model objects as Google protocol buffers. (These were added to the SDK in the 1.2.5 release, but had not been documented.)

2009-09-03

- New SDKs for both Python and Java, version 1.2.5, are now available. Starting with this release, both SDKs will be released together and with identical version numbers. (Java is skipping 1.2.3 and 1.2.4 to be in sync with Python.)
- App Engine applications can now send and receive instant messages via the XMPP protocol to and from instant messaging services that support it, such as Jabber servers and Google Talk. The service API is available for both Python and Java applications.
- Java now has an API for the experimental Task Queue service.
- Java now supports all of the native datastore types, including the GData types such as GeoPt.
- JDO and JPA now support deleting entities using queries.
- JDO now uses datastore batch operations for `makePersistentAll()` and `deletePersistentAll()`.
- Datastore entity key names may now begin with a digit. It is no longer necessary to prefix user IDs with non-digits to use them as entity key names.
- Datastore transactions now support writing or deleting the same entity multiple times in a single transaction.
- URL Fetch requests can now set the `Referer` header. If the app doesn't set this header, it isn't included in the request headers. Previously, App Engine forced this header to be something App Engine specific. This is no longer the case, it now behaves like any other non-restricted header.
- Java apps can now set the deadline on URL Fetch requests using the java.net.URLConnection interface, with the `setConnectTimeout()` method.
- Java apps can adjust the MIME types used with static files using `<mime-mapping>` elements in the deployment descriptor (`web.xml`).
- Java apps can control the browser cache expiration duration of static files using a setting in the `appengine-web.xml` file.
- The bulkloader has an experimental feature that can dump and restore every entity of a kind without any additional code or configuration (beyond installing remote_api). Currently, this feature is only available on the `bulkloader.py` tool; it will be moved to `appcfg.py` when the feature is stable. Let us know what you think!
- The Python SDK for Windows now includes a Launcher application that provides a graphical interface for creating, testing and deploying projects. This is similar to the Mac version of the Launcher included with the Mac Python SDK. Also, both Launchers are now open source projects. You can find links to the source code in the "Resources" section of the doc sidebar. The Windows Launcher is written in Python and uses wxWidgets, so Linux users can use it by downloading the source.
- With the Python `appcfg.py request_logs` command, you can now adjust the end date of the log data to download with the `--end_date` option. Also, documentation has been added for the the `--include_vhost` option, which was introduced in a previous release.

2009-08-05

- Python SDK 1.2.4 is now available.
- You can now include a displayable name with the email address of the sender of an email message. Previously, you could only use the address without a name.
- The Python Memcache `incr()` and `decr()` functions can now set an initial value for a counter if the key does not exist. Previously, incrementing or decrementing a value that didn't exist did nothing.
- If you access your site while signed in as an administrator, App Engine now includes resource usage information for the request in the response headers, as `X-AppEngine-Estimated-CPM-US-Dollars` and `X-AppEngine-Resource-Usage`.
- `appspot.com` domains now support subdomains. A request whose domain name matches the pattern `http://subdomain.your_app_id.appspot.com`, where subdomain is any string allowed as a part of a domain name (not a `.`), is routed to the application with the given ID.
- Indexes for queries on keys have been improved, requiring custom indexes in fewer cases. Descending sort orders on keys still require a custom index.
- You can now use GQL or the Python query interface to retrieve all entities of a given ancestor of all kinds. Such queries can also include filters (equality or inequality) on `__key__`.
- PolyModel now supports multiple inheritance and diamond inheritance.

2009-07-14

- Updated the Java unit testing how-to sample code to reflect changes to the TestEnvironment class.

2009-07-13

- SDK verison 1.2.2 for Java now available.
- The Java AppCfg command now supports HTTP and HTTPS proxies.
- The Java ORM now supports declaring properties as non-indexed using JDO and JPA.
- The Java ORM now supports ancestor queries within datastore transactions, using the same entity group that is the subject of the transaction.
- The maximum number of files an app can have is now 3,000. This is the total count of application files (code, configuration) and static files.
- The description of the `--max_size` argument to the Python `appcfg.py` has been updated to reflect the increase of the maximum file size to 10 megabytes. This was changed with Python release 1.1.9.
- The article "Using Django 1.0 on App Engine with Zipimport" has been updated with a note about the latest file size and file count maximums, and the fact that Django 1.0 is now included as an option in the Python runtime environment.
- The docs incorrectly stated that secure connections consume more CPU quota than non-secure connections. Secure requests do not consume additional CPU quota. The docs have been fixed.
- Python docs clarified to state that long integers are limited to 64 bits.
- Python docs clarified to state that if a ByteStringProperty, StringProperty or TextProperty is required, its value cannot be the empty string.
- Added a note on JSPs regarding how a `<jsp-file>` value must start with a slash if the JSP file is in the root directory.
- Added a note suggesting that when using a user ID as a datastore key, the value should be prefixed with a letter. Datastore keys cannot start with a digit. (No longer true as of release 1.2.5.)
- Added more information on the Python tools `appcfg.py update_cron` and `appcfg.py cron_info`.

2009-06-11

- SDK version 1.2.3 for Python now available.
- The Python interface for URL Fetch now supports fetching URLs asynchronously. An app can create an RPC object, initiate a URL fetch, then do other things while the service fetches the URL. When it is ready, the app calls a method on the RPC object to get the results of the fetch.
- Task Queues, our first experimental release, are now available for Python. Task queues let you set up work to be done outside of the scope of a user-initiated request. App Engine performs a task by calling a request handler with data specified as part of the task. This is an experimental release, which means the API and implementation details of the feature are not final and may change in a future release.
- The Python runtime environment now includes Django 1.0.2 as an option. Django 0.9.6 is still the default version. See Third-party Python Libraries for instructions.
- You can now perform an ancestor query within a datastore transaction. An ancestor query returns all entities with a common entity group parent. The ancestor must be in the same entity group that is the subject of the transaction, and must not use any other query filters.
- The datastore overview has been extended with a brief explanation of isolation and consistency, and an example of read-only transactions.
- The article on Transaction Isolation has been updated with additional information on queries, and on isolation inside and outside of transactions.
- Docs updated to reflect the fact that all developers can now upload apps that use the Java runtime environment.
- The Javadoc on the site has been brought up to date with the Java 1.2.1 release. (Apologies for the delay.)
- Instructions for sending mail to app administrators using the JavaMail interface have been corrected.
- A package name in the code sample of the JCache docs has been corrected.
- The example `datastore-indexes.xml` file in the Java documentation has been corrected to not use a namespace. (Starting with the 1.2.1 release, validation is enforced, but the schema does not use a namespace.)

2009-05-08

- SDK version 1.2.2 for Python now available.
- Python apps and GQL queries in the Admin Console can now retrieve just the keys for entities in query results, instead of full entities.
- A Python datastore model can now specify that a property should not be indexed, regardless of its value. This saves space and write time by turning off the automatic single-property indexes for those properties.
- The Python API for the URL Fetch service can now set a deadline, a maximum amount of time to wait for the remote host to respond.
- Python apps can call a new API to determine how much CPU time has been spent so far during the current request.
- A bulk data downloader has been added to `appcfg.py`, similar to the bulk data uploader.
- `appcfg.py request_logs` now supports querying logs by the app hostname with the `--vhost` option, so you can download logs separately for a Google Apps domain, and `appspot.com` test domains.
- The cron schedule syntax has been updated to support "every day 09:00" (equivalent to "every mon,tue,wed,thu,fri,sat,sun 09:00") and "every monday 09:00" (instead of "every monday of month 09:00").

2009-04-22

- SDK version 1.2.1 for Python now available.
- The Users service now provides a unique ID for each user that stays the same even if a user changes her email address. Note that the User object itself still does not yet possess this stability property, so if you need a datastore value to refer to a stable user ID, you must store the unique ID separately.
- The Images service can now produce a composite image from multiple images, and can calculate a color histogram for an image.
- The Memcache service now supports namespaces for keys.
- The bulk data uploader is now an official feature of the `appcfg.py` command in the Python SDK. It now includes the ability to skip a header row in CSV files, and the ability to sign in using a Google Apps domain account. Note: The Loader class API has changed; please update your Loader class files.
- URL Fetch requests can now have custom `User-Agent` and `User-Specified` headers.
- Email messages can now have attachments that are `.ics` calendar invitations or `.vcf` V-Card contact information cards.
- An App Engine-specific version of the Python PyCrypto cryptography library is now available to Python applications. The documentation has a new page describing the third-party libraries included in the Python runtime environment, with notes about App Engine-specific differences and usage.

2009-04-07

- An "early look" of Google App Engine for Java is now available. You can download the Java SDK, and sign up to try uploading Java apps to App Engine. The documentation includes all new sections on the Java runtime environment and APIs, and the existing documentation has been restructured and extended.
- This release also includes scheduled tasks, aka "cron jobs," for both Java and Python.
- SDK version 1.2.0 for Python and SDK version 1.2.0 for Java are now available.
- Java developers, don't forget to check out the new Google Plugin for Eclipse, with features for both App Engine and Google Web Toolkit.
- Also check out the new Secure Data Connector, which allows you to develop App Engine applications and gadgets for your company's intranet. See the Google Apps developer tools documentation for an overview.

2009-03-17

- Corrected billing FAQ item to indicate that datastore indexes do count against an application's billable storage quota.

2009-03-05

- Minor revision of billing-related text for clarification. What the docs originally called "adjustable" quotas are now known as "billable" quotas.

2009-02-24

- You can now establish a billing account and a daily budget for your application, and allocate additional quotas for CPU, bandwidth, data storage and email messages.
- Updated the Quotas page to include information about billable quotas, the free quota levels, and the per-minute quotas. Also added a notice about an upcoming reduction in the free quota levels.
- Added a page discussing how to purchase additional quota, which includes a walkthrough of how to enable billing for an application, set a daily budget, and check billing status and history.
- Added a new FAQ page for common billing questions.
- Updated the Terms of Service, revising sections 4 and 10 of the terms to include language around payments, fees, and disallowing the use of multiple applications to avoid incurring fees.

2009-02-18

- The GQL `KEY` literal accepts string-encoded keys as well as paths.

2009-02-04

- SDK version 1.1.9 now available.
- The file size limit has increased from 1 MB to 10 MB. The article on zipimport has been updated with this information. You can now create a simpler zipimport bundle of all of Django 1.0 without having to leave out parts to reduce the archive file size. The app request and response size limit has also increased from 1 MB to 10 MB.
- The datastore now creates single property indexes in both ascending and descending order automatically. Previously, the datastore only made single property indexes in ascending order automatically. Queries that use an index of a single property in descending order no longer require a custom index. If you have such an index, you can remove it from your `index.yaml` and run `appcfg.py vacuum_indexes` to delete the extraneous custom indexes. The documentation on indexes has been updated accordingly.
- The Query class now supports the `!=` and `IN` operators, similar to the GqlQuery class. The reference has been updated, and an introduction to query filter operators has been added.
- You can now specify the number of times a transaction will be retried in the event of contention using db.run_in_transaction_custom_retries().
- You can now use the Python standard libraries urllib, urllib2 and httplib to access the URL fetch service.
- You can now upload data into the datastore from CSV files on your computer using `appcfg.py`. An experimental and undocumented version of this feature was originally included with the SDK as the "bulk data uploader." A newer, faster implementation of this feature is now provided as the `bulkuploader.py` command. The documentation describes this feature in full.
- The `skip_files` property in an `app.yaml` file now accepts either a single regular expression, or a list of regular expressions. If a file path matches any of the regular expressions, the file is skipped.

2009-01-15

- SDK version 1.1.8 now available.
- New feature: `PolyModel` and polymorphic queries.
- New feature: `UserProperty` now supports `auto_current_user` and `auto_current_user_add` attributes.
- New feature: New `ByteString` datastore value type, a short indexed unencoded (non-text) string of bytes. Also, a new `ByteStringProperty` class for modeling byte string values.
- New feature: Images API now exposes the current width and height of an image.
- Major re-organization of the docs, primarily to move Python-specific material to its own section in preparation for upcoming support for a second language. External links to old pages on code.google.com will resolve using redirects. (Our apologies to anyone with links to individual pages of the docs hosted elsewhere.) Please file an issue if you find any unresolved broken links or broken pages in the documentation.

2008-11-24

- New article: How Index Building Works
- New FAQ: "Why were my indexes marked as Error?"
- New FAQ: "Why do my indexes stay Building or Deleting for long periods of time?"

2008-11-20

- SDK version 1.1.6 now available.
- New feature: You can now perform queries, including filters and sort orders, on datastore entity keys, using the special property name `__key__`. See the documentation.

2008-10-28

- `Model` class constructor now accepts a `Key` instance for the `parent` argument.
- Added Windows appcfg.py proxy instructions.
- Documented `google.appengine.runtime.DeadlineExceededError`.
- Documented the fact that entities with a property of a common name but with values of mixed types are sorted by types first, then by values as per type. In particular, all integers < all floats.
- Added whole-file example to top of datastore page of the Getting Started Guide.
- Added a note about requiring a space between the name and operator in Query.filter().
- Updated string prefix search tip to use `u'\ufffd'`.
- Documented GQL value literal syntax for dates, keys, users, and GeoPt values.
- Added db.Timeout to list of datastore API exceptions.
- Added note to "Configure an App" about how using HTTPS with the versioned testing URL, such as `https://1.latest.your_app_id.appspot.com/`, causes browsers to warn about certificates. This is harmless, and users will not see the warning.
- In the article "Using Django 1.0 on App Engine with Zipimport," improved wording about updating existing Django helper projects.
- In the article "Extending Model Properties," fixed several errors in the code samples.
- Mentioned the specific version of Python that App Engine uses: Python 2.5.2.

2008-10-23

- Added the App Engine Product Roadmap.
- Added documentation for the update_indexes command with appcfg.py.

2008-10-22

- Updated the "Retrieving Authenticated Google Data Feeds with Google App Engine" article to use gdata-python-client version 1.2.2 and higher. Token storage code has been greatly simplified.

2008-10-16

- Support for handling secure HTTPS connections for `*.appspot.com` domains, with a new handler configuration option.

2008-10-14

- Removed a note from the What Can Be Done In a Transaction section of the Transactions page about a bug that prevented creating both a new root entity and descendants of the entity in a single transaction. That bug was fixed in 1.0.2.

2008-09-30

- SDK version 1.1.5 now available.
- Doc updates for releases 1.1.3 through 1.1.5:
  - URL Fetch can be instructed not to follow redirects, using a new parameter.
  - URL Fetch is now restricted from fetching the request's own URL, to help prevent infinite loops.
  - New Memcache methods: `add_multi()` and `replace_multi()`.
  - `ListProperty(str)` gets special treatment as `ListProperty(basestring)` because the datastore stores `str` values as ASCII-encoded Unicode, and returns such values as `unicode`. Previously, this would break `ListProperty(str)` models, now they succeed.
  - `StringListProperty` is now a proper class, with additional support for Django forms.
- New article: Using Django 1.0 with App Engine and zipimport
- New version of downloadable docs now available. Includes a fix for an issue with the index.html file and Internet Explorer.

2008-09-26

- SDK version 1.1.4 now available.

2008-08-23

- Added a Sort Orders and List Properties section to Queries and Indexes with details on how list properties and sort orders interact.

2008-08-22

- SDK version 1.1.2 now available.
- Documentation for new features in SDK version 1.1.2:
  - `db.put()` and `db.delete()` are no longer limited to a single entity group per call.

2008-08-13

- Added section about using GData services in App Engine application.

2008-08-12

- All Google App Engine documentation is now released under a Creative Commons license. Example code in the documentation is released under an Apache license.
- Links outside of the documentation now go directly to the destination, instead of through Google's URL redirect mechanism.
- Anchors in content now use element IDs instead of anchor tags.

2008-07-25

- Documentation for new features in SDK version 1.1.1:
  - You can now query and download log data using appcfg.py: appcfg.py request_logs
  - The mail service can now use the current user's email address in the "From" field (the sender) of an email message.
  - New environment variable: CURRENT_VERSION_ID
  - The URL fetch service can now customize the Date HTTP header (was previously disallowed).
  - The URL fetch service now uses a default Content-Type header of x-www-form-urlencoded for POST requests (which can be overridden).
- Added section about the new limit on index entries, and how to avoid it; big entities, exploding indexes, and the "Error" index state.
- Documented webapp.util.run_wsgi_app() (previously undocumented), a better way to run WSGI applications in App Engine. Code samples have been updated to recommend run_wsgi_app() over wsgiref as a best practice.
- Revised code samples to instantiate webapp.WSGIApplication outside of the main() routine, a best practice for performance.
- Documented the webapp.util.login_required annotation for webapp get() handler methods (previously undocumented).
- Added documentation for environment variables.
- Added a new section on reserved URLs. In particular, note that `/form` is a reserved URL.
- Added descriptions of how entities without a property are never results for queries the filter or order by that property. Also added a description of how Text and Blob values are never indexed, and so behave like unset properties in queries.
- Added mentions of how str values are stored and returned by the datastore as unicode values, and how this causes ListProperty(str) to not work (because the model tries to validate the value returned by the datastore as a str). (Use ListProperty(basestring) or StringListProperty() instead.)
- Added a description of how two ReferenceProperty model properties to the same kind must have unique collection_name values set to avoid the default collection_names from colliding.
- Added a mention of the Google App Engine Launcher for Mac OS X in the Getting Started Guide.
- Added a description of how responses are compressed automatically (using gzip) if the request headers indicate that the client can accept compressed responses.

2008-07-24

- SDK version 1.1.1 now available.

2008-06-27

- Corrected the Model.get_by_id reference to include method arguments in the method signature. (The arguments were listed correctly in the method description.)

2008-06-24

- Added more complete documentation for the webapp.Request and webapp.Response classes.
- Added documentation of disallowed HTTP headers for URL Fetch and for responses in general.
- Fixed doc revision history to reflect correct release date for Images and Memcache APIs, and GQL operators.

2008-06-23

- Corrected the Model constructor reference to say that `parent` must be a `Model`, not a `Key`.
- Mentioned that List properties are order-preserving.

2008-05-30

- Corrected the Quotas article to say that the 1000 static file limit only applies to files, not datastore Blobs.

2008-05-28

- Added Image API and Memcache API documentation.
- Updated "Whats is App Engine" document to include Images and Memcache services.
- Added != and IN operators to GQL Documentation.

2008-05-22

- Added a note to the appcfg.py documentation about using the tool behind an HTTP proxy.
- Added clarification of restrictions on datastore entity key names.
- Added clarification of how the 1000-result query limit affects both fetch() and count().
- Added a note about how Python `int` values stored in the datastore are stored and returned as Python `long` values.
- Updated the Getting Started example to pass a sequence of up to 10 query results to the template, instead of passing the query object directly. Passing the query object to the template works just fine, but how this works isn't clear from the example. This also more sensibly limits the results to 10, which is what a real app would do anyway.
- Added a note that the application root directory is in the module include path.
- Added an example to the URL Fetch overview illustrating how to submit encoded form data with an HTTP POST action, including correct headers.
- Corrected a statement in the URL Fetch overview: URL fetching does follow HTTP redirects, up to 5 times.
- Corrected a statement about webapp.Response: This class does not inherit from WebOb's Response class, as webapp.Request does. (This may be fixed in a future version.)
- "Groups" in the navigation bar now goes directly to the Google App Engine discussion group. The original "Discussion Groups" page is still available from the sidebar, with a link to the downtime announcement list.
- This documentation revision history page is now available.

2008-05-19

- Google App Engine Launcher for Mac OS X version 1.0.2 now available.
- Article "Running Django on Google App Engine" updated.
- Article on quotas now includes file count and file size limits.

2008-05-15

- Google App Engine Launcher for Mac OS X version 1.0.1 now available.
- Article "Running Django on Google App Engine" updated, including a mention of how to perform App Engine deployment actions from Django's manage.py script.

2008-05-14

- Added note that the server enforces a maximum file size of 1,045,576 bytes.

2008-05-13

- New article: "Transaction Isolation in App Engine"

2008-05-09

- SDK version 1.0.2 now available.

2008-05-07

- New article: "Using the Google App Engine Helper for Django"

2008-05-06

- New article: "An Open Source App: Rietveld Code Review Tool"

2008-05-01

- Program policies updated to clarify policy on complying with terms of service policies of other Google services, e.g. framing the Google Accounts sign-in screen.

2008-04-30

- "Powered by Google App Engine" buttons now available.

2008-04-24

- New article: "Retrieving Authenticated Google Data Feeds with Google App Engine"
- New FAQ: "Should I use the SDK for serving external requests?"

2008-04-14

- SDK version 1.0.1 now available.
- Many minor additions and clarifications to the documentation:
  - added more information about list property values
  - added mention of how model instance attributes that begin with an underscore are not saved with the entity
  - added mention that entity key names cannot begin with a number
  - added mention that ReferenceProperty back-references lowercase the model name in the default attribute name
  - added mention of how to terminate dev_appserver in Windows (Ctrl-Break)
  - improved the `tzinfo` example
  - mentioned lack of streaming ability in the CGI web server
- `/appengine/docs/python/runtime.html#App_Caching` moved to `/appengine/docs/python/runtime.html#App_Caching`.

2008-04-10

- Program policies updated to clarify a note about putting the Admin Console in a frame.

2008-04-07

- Google App Engine launches. The initial draft of the documentation describes App Engine, the services, the configuration files, the tools, and the Python runtime environment and APIs. The documentation also includes a Getting Started tutorial, a FAQ and a set of articles.
- Google App Engine Campfire One videos added after the Campfire completed.