• Go from Google App Engine instances to serve the appropriate level of detail for users' viewport queries from memory at very low latency, and
• Dart to render the live result maps on top of Google Maps JavaScript API using Firebase real time database updates.

• 406,000 people used our maps, including 217,000 on election day.
• We had 139 stories in the media.
• Our map was also embedded in major news websites, such as Sky News.

1. Dynamically scalable application servers to handle variable traffic patterns
2. Replicated storage that’s scalable and provides reliable performance under load
3. Enterprise-grade reliability to ensure 24 x 7 access for our customers

• Five new instance type families (diskless versions of our standard instance types, plus diskful and diskless versions of high-memory and high-cpu configurations), with 16 new instance types.

• We will continue to run Python 2.5 applications throughout the deprecation period. For most customers, upgrading to Python 2.7 is trivial as most elements of Python 2.5 are forwards-compatible with Python 2.7. We’ve prepared a handy migration guide that covers the steps to migrate in detail.
• If your application is still using the already deprecated Master/Slave Datastore, then you should first plan the migration to our more reliable High Replication Datastore, as the Master/Slave Datastore is not accessible from Python 2.7.
• Future versions of the App Engine Python Development SDK will display warnings to developers deploying updates to a deprecated runtime.
• Starting from January 2014, we will no longer allow new applications to be created using the Python 2.5 runtime.

• Use of the Python NDB API
• Jinja2 templates
• Discussion of data consistency and datastore indexes

• Cloud based editing and deployment of your App Engine projects
• Autocomplete for Python code, including built-in App Engine libraries
• OAuth deployment, so DevTable never has access to your Google Credentials
• Native App Engine deployment for production releases
• Git DVCS integration, including GitHub support
• Mimic deploy, for faster intermediate testing feedback

Python autocomplete and documentation in DevTable

Mimic bootstrap code deployment

• Bronze: All customers get access to online documentation, community forums, and billing support. (Free)
• Silver: In addition to Bronze, you can email our support team for questions related to product functionality, best practices, and service errors. ($150/month)
• Gold: In addition to Silver, you'll receive 24x7 phone support and consultation on application development, best practices or architecture for your specific use case. (Starts at $400/month)
• Platinum: The most comprehensive and personalized support. In addition to Gold, you’ll get direct access to a Technical Account Manager team. (Contact Sales for more information)

Java 7 Runtime Support for App Engine

public static void invokeExample() {
   String s;
   MethodType mt; 
   MethodHandle mh;
   
   MethodHandles.Lookup lookup = MethodHandles.lookup();
   MethodType mt = MethodType.methodType(String.class, char.class,
          char.class);
   MethodHandle mh = lookup.findVirtual(String.class, "replace", mt);
   s = (String) mh.invokeExact("App Engine Java 6 runtime",'6','7');
   System.out.println(s);
}

public static void viewTable(Connection con, String query) throws SQLException {
   try (
      Statement stmt = con.createStatement();
      ResultSet rs = stmt.executeQuery(query)
   ) {
      while (rs.next()) {
         // process results
         //
      }
   } catch (SQLException e) {
      // con resource is auto-closed, no need to do anything here!
      //
   }
}

Map> myMap = new HashMap<>();

Map> myMap = new HashMap>();

• Use of String class in Switch statements.
  
• Expression of binary literals using simple prefixes 0b or 0B.
  
• Single catch blocks that can handle multiple exceptions.
  
• Simplified varargs method invocation.
  

Cloud Endpoints Preview

public class SuperHeroes {
   public List listSuperHeroes() {
      List list = new ArrayList();
      list.add(new SuperHero ("Champion of the Obvious", "Brad Abrams"));
      list.add(new SuperHero ("Mr. Justice", "Chris Ramsdale"));

      return list;
   }
}

}

Now you have a simple REST interface.

$ curl http://localhost:8888/_ah/api/superheroes/v1/superheroes
{
 "items": [
  {
   "knownAs" : "Champion of the Obvious",
   "realName" : "Brad Abrams"
  },
  {
   "knownAs" : "Mr. Justice",
   "realName" : "Chris Ramsdale"
  }

Real result = superheroes.list().execute();

GTLQuerySuperHeroesV1 *query = [GTLQuerySuperHeroesV1 queryForSuperHeroesList];
[service executeQuery:query completionHandler:^(GTLServiceTicket *ticket, 

GTLSuperHeroes *object, NSError *error) {
  NSArray *items = [object items];
}];

// ...
var ROOT = 'https://' + window.location.host + '/_ah/api';
gapi.client.load('superheroes', 'v1',
                 loadSuperheroesCallback, ROOT);
// Get the list of superheroes
gapi.client.superheroes.superheroes.list().execute(function(resp) {
  displaySuperheroesList(resp);
});

• Bronze: All customers get access to online documentation, community forums, and billing support. (Free) 
• Silver: In addition to Bronze, you can email our support team for questions related to product functionality, best practices, and service errors. ($150/month) 
• Gold: In addition to Silver, you'll receive 24x7 phone support and consultation on application development, best practices or architecture for your specific use case. (Starts at $400/month) 
• Platinum: The most comprehensive and personalized support. In addition to Gold, you’ll get direct access to a Technical Account Manager team. (Contact Sales for more information)

• K. Mani Chandy, Simon Ramo Professor and Professor of Computer Science, California Institute of Technology
  Cloud-based Event Detection for Sense and Response: Develop a low-cost alternative to traditional seismic networks. The image below is taken from the Community Seismic Network map showing active clients and events in real time.

A dense network of seismic stations enables the Community Seismic Network to perform a finer-grained analysis of seismic events than possible with existing seismic networks.

• Lawrence Chung, Associate Professor, The University of Texas at Dallas
  Google App Engine: Software Benchmark and Google App Engine Simulation Forecaster: Develop a tool to estimate software performance and cost on Google App Engine.
• Julian Gough, Professor, University of Bristol, UK
  Personalised DNA Analysis: Develop a service that provides personal DNA analysis.
• Ramesh Raskar, PhD, MIT Media Lab; Dr. Erick Baptista Passos, IFPI (Federal Institute of Technology, Brazil)
  VisionBlocks: develop a tool that delivers computer vision to people everywhere. The image below shows a current prototype implementation of VisionBlocks.

Many algorithms are already included, and you'll be able create your own blocks as well.

• Norman Sadeh, Professor, Director of Mobile Commerce Lab, School of
  Computer Science, Carnegie Mellon University
  Mapping the Dynamics of a City & Nudging Twitter Users: uncovering local collective knowledge about the a city using social media.
• William Stein, Professor of Mathematics, University of Washington
  Sage: Creating a Viable Free Open Source Alternative to Magma, Maple, Matlab, and Mathematica.
• Enrique Vivoni, Associate Professor, Hydrologic Science, Engineering & Sustainability, Arizona State University
  Cloud Computing-Based Visualization and Access of Global Climate Data Sets: provide scientific data on global climate trends.

The Lula, Nomanini's portable voucher sales terminal

• High Replication Datastore, NDB and Memcache
• Extensive use of push Task Queues
• Blobstore for storing file records
• Logs API, Mail API and XMPP for reporting and real-time notification of issues to our development team
• URL Fetch API to link to third-party API’s such as sending SMS’s and integration to mobile networks for airtime voucher purchase
• Google Cloud Storage and Google BigQuery for mining our data for interesting trends

• ProdEagle (another application built on top of Google App Engine) for real time metrics visualization

• Task Queue statistics (General Availability): You can see statistics such as the current number of tasks in a queue, the number of tasks executed in the last hour, and more.
• Traffic splitting (General Availability): You can split requests amongst different versions of your app.
• LogsReader and Logs API (General Availability): You can now fetch requests based on a list of request IDs.
• Expanded Datastore query support (Experimental): We’ve added ‘DISTINCT’ support to Datastore queries.

• High Memory Instance - High performance instances tailored for applications that demand large amounts of memory.
• High CPU Instance - Reduced cost option when applications don’t require as much memory.
• Diskless Configurations - Lower cost options for applications that do not require ephemeral disk and can exclusively utilize persistent disk.

• More Storage: We’re increasing the available storage on Cloud SQL to 100 GB - ten times more than before.

• Faster Reads: We’re increasing the maximum size of instances to 16 GB RAM. This amounts to a 4 times increase in the amount of data you can cache.

• Faster Writes: We’re adding optional asynchronous replication, which gives the write performance of a non-replicated database, but the availability of a replicated one.

• EU datacenter availability: If you sign up to be a Premier customer, you can choose to store your data and run your Cloud SQL database instance in either our US or EU data centers.

• Integration with Google Apps Script: We’re making it quick and easy for businesses using Google Apps to use Cloud SQL. Publish and share your data with Google Sheets, add data to your Google Sites pages or create simple Google Forms without worrying about hosting or configuring servers.

• High Replication Datastore with NDB
• Memcache
• Task Queues - Deferred execution, MapReduce, batch jobs
• App Engine Search API -- Indexing both course content and student résumés
• Blobstore API -- Lecture videos, résumés, data exportation
• Image API - Thumbnail generation
• MapReduce API - Daily usage analytics, data migrations, data maintenance

• Converting usage of the old datastore API to the new NDB API
• Using NDB.tasklet coroutines as much as possible to enable parallelism during blocking RPC operations
• Not indexing fields by default and adding an index only when we need it for a query
• Carefully avoiding index hotspots by indexing fields with predictable values only when necessary (i.e. auto-now DateTime and enumerated “choices” String properties).
• Materializing data views very aggressively so we can limit each request to the fewest datastore queries possible

• 4:00 am - Load begins increasing on traffic routers in one of the App Engine datacenters.
• 6:10 am - The load on traffic routers in the affected datacenter passes our paging threshold.
• 6:30 am - We begin a global restart of the traffic routers to address the load in the affected datacenter.
• 7:30 am - The global restart plus additional load unexpectedly reduces the count of healthy traffic routers below the minimum required for reliable operation. This causes overload in the remaining traffic routers, spreading to all App Engine datacenters. Applications begin consistently experiencing elevated error rates and latencies.
• 8:28 am - google-appengine-downtime-notify@googlegroups.com is updated with notification that we are aware of the incident and working to repair it.
• 11:10 am - We determine that App Engine’s traffic routers are trapped in a cascading failure, and that we have no option other than to perform a full restart with gradual traffic ramp-up to return to service.
• 11:45 am - Traffic ramp-up completes, and App Engine returns to normal operation.

• Django 1.4 is now fully supported for Python 2.7

• Java classloading priority can now be granted to specific JAR files.  This is an experimental feature. More information can be found here.

• The ability to use the String class in Switch statements

• Expression of binary literals using simple prefixes 0b or 0B

• Single catch blocks that can handle multiple exceptions

• Improved type inference for generic instance creation

• Auto closing of resources when enclosed within a try-with-resources statement

• Simplified varargs method invocation

• High uptime
• Short loading time
• Flexibility to deal with social network API changes
• Ability to manage thousands of players, concurrently, from all over the world
• Adjustment to capabilities and performance issues on different users’ computers
• Ability to measure user actions to constantly improve the user experience
• Hosting and delivering quality, beautiful game art
• Complex game domains and algorithms: such as enemy adaptable performance, path finding, and 2D and 3D rendering

App Engine addresses these complicated issues.  It provides few tracerouting hops from almost anywhere in the world, great uptime, automatic scalability, no need for infrastructure monitoring and a reasonable price for content delivery.

Implementing App Engine

The diagram above shows a simplified view of our game architecture. We’ve discovered that App Engine is good to use not only as a game backend server, but also as a metrics server and content delivery network.  In addition, we periodically synchronize game state and retrieve data to and from the server.  

The App Engine Datastore is great because it has high availability and easily handles hundreds of millions of rows of data, which is important for social games.  For example, we  can easily scan the Datastore to present high score information and gamer stats to the user.  Additionally, because gamers tend to spend lot of time during a game session, we’ve found it’s helpful to cache game data. Using Memcache, we have significantly reduced Datastore API calls and lowered users’ waiting time.

Another tip for App Engine developers - although App Engine API failures are uncommon, you must be sure to write proper retrying code to minimize the possibility of exposing users to an application crash.  RaceTown performs almost a hundred million operations daily, and proper client side retrying algorithms have enabled us to reduce failure rates to very low levels.

Final thoughts

I believe that today there is no technology that matches App Engine.  You can run your code and store your data in the very same servers that Google uses.  Migrating your applications to this technology means you have to start thinking in a cloud-centric way and reinvent your architecture to stop working inside a relational database and classic clustered web server.

If you can achieve this, your products will be delivered using the same infrastructure that Google uses, without a huge corporate budget!

- Contributed by Hernan Liendo, @hernanliendo of Zupat, @zupcat

• App Engine to serve our app

• App Engine Datastore to persist user data

• Memcache to make operations fast

• BigQuery to analyze our logs and power dashboards

• App Engine Search API to let users sift through their data

• Prediction API to machine learn over user data

• Google Translate API to translate our app to over 40 languages.

• Which requests cost us the most money?
• What is the average response time for every URL on our site over the last 3 days?

A Streak dashboard powered by BigQuery showing current usage statistics

• It's fully managed, which means you don't have to set up Jenkins or the build machines you need.

• You always have enough build capacity -- we dynamically add more build machines as you need them.

• CloudBees Jenkins is free to get started.

• Paid applications can now upload more than 1GB of code and static files for their applications. Storage above the free quota of 1GB will be billed at $0.13/GB per month.

• PyCrypto 2.6 is now fully supported as an option for third party libraries in Python 2.7.

• Java Threads is now a fully supported feature of the Java runtime.

• Usage Report Download - We’ve added the ability to download the past 90 days of your application’s usage reports as a CSV file.

• Namespaces in the Memcache Viewer - The Admin Console now supports retrieving memcache values that are stored in a non-default namespace.

• Appstats updates - We’ve included a few new things in appstats with 1.7.1. You can now view RPC cost information in appstats. We’ve also added an interactive console which lets you trigger and then examine an RPC call for real-time debugging.

• PyCrypto 2.6 support - We’ve included the latest version of PyCrypto as an option for third party libraries in Python 2.7.

• In our overview session, Peter Magnusson and Greg D’Alesandre introduced many of our new features and announced that we have attained 7.5 billion hits per day and are running more than 1 million active applications.
• We announced Google Compute Engine and Alon Levi and Adam Eijdenberg showed how to use App Engine to orchestrate compute instances.
• Cloud SQL began taking open signups and we witnessed an epic battle of the backends in our SQL vs NoSQL session, with Alfred Fuller representing the Datastore and Ken Ashcraft representing Cloud SQL.
• We announced Google Cloud Endpoints and hosted a codelab to give developers early access to our trusted tester program.
• Brian Quinlan covered the finer points of the Python 2.7 runtime.
• And last but not least, Marzia Niccolai, Greg Darke and Troy Trimble gave some great tips for optimizing App Engine applications.