Fall 2011 App Engine events

Buenos días desde Buenos Aires!! Wow, we are just blazing through the summer! We had an exciting Google I/O in May where we saw the launch of the Go runtime, introduction of the Backends feature, and confirmed Google's commitment to the platform with our plans to leave preview mode, not to mention the five releases since that time. We then hit the road this summer with team members appearing around the globe, including mega events like the Cloud Computing Expo, EuroPython, and OSCON.

At Google I/O, many App Engine team members gave in-depth technical sessions. Alfred Fuller, an App Engine Datastore engineer, revealed how the High Replication datastore gives greater reliability and availability for users. Michael Handler, one of App Engine’s talented Site Reliability Engineers, discussed how App Engine works in production. At OSCON, the largest open source event in the world, yours truly gave a three-hour App Engine overview and workshop to help new users get up to speed, and earlier in the year at PyCon, described how Python users can avoid “vendor lock-in” via the Django-nonrel project by porting their applications from webapp to Django, allowing them to move on to or off of App Engine as they please with only minor configuration changes. We participate in events like these because we like to communicate with users to find out what they like & don’t like about the platform, and we often take their suggestions to heart!

This fall we have a full schedule, appearing at many developer events worldwide, including Google Developer Days and Google DevFests. At the Google events, we'll recap App Engine and those announcements we made at I/O, and you’ll learn how to build exciting applications using App Engine and other Google cloud technologies as well as how to build games in the cloud. Here are the dates, events, and locations that we will be visiting:

Fall 2011
Sep 19-20 - Google Developer Day Argentina - Buenos Aires - Wesley Chun, Chris Schalk
Sep 19-23 - Strata - New York - Chris Schalk
Sep 23-24 - PyCon Argentina - Junín - Wesley Chun
Sep 26-30 - Congresso Brasileiro de Software - São Paulo - Wesley Chun
Sep 29-Oct 1 - Python Brasil[7] - São Paulo - Wesley Chun
Oct 8-9 - Silicon Valley CodeCamp - Los Altos Hills - Wesley Chun
Oct 10 - Google Developer Day Russia - Moscow - Iein Valdez, Fred Sauer
Oct 18 - Google Developer Day Czech Republic - Prague - Iein Valdez, Fred Sauer
Oct 20 - Google DevFest France - Paris - Iein Valdez, Johan “Proppy“ Euphrosine
Nov 1 - Google Developer Day Japan - Tokyo - Takashi Matsuo, Johan “Proppy“ Euphrosine
Nov 8 - Google Developer Day Australia - Sydney - Chris Schalk, Johan “Proppy“ Euphrosine
Nov 12 - Google DevFest Singapore - Singapore - Chris Schalk, Wesley Chun
Nov 13 - Google Developer Day Israel - Tel-Aviv - Michael Manoochehri
Nov 16 - Google DevFest Indonesia - Jakarta - Chris Schalk, Wesley Chun
Nov 19 - Google Developer Day Germany - Berlin - Michael Manoochehri, Wesley Chun

If these aren't close enough to you, keep an eye out on this list as we'll add new events and locations as they are scheduled. A calendar with all of Google's developer events is also available. We look forward to meeting you soon!

Posted by Wesley Chun (@wescpy), Google cloud Developer Relations team

Implementing Workflows on App Engine with Fantasm

This post is another entry in our ongoing series of guest posts contributed by App Engine developers. Today we partner with Jason Collins and Shawn Rusaw of VendAsta Technologies who discuss their simplistic workflow management system for Python App Engine called Fantasm. Fantasm is very simple to start using but incredibly powerful. So powerful in fact, that they couldn't fit it into one blog post. So for more detail, see the Implementing Workflows on App Engine with Fantasm article in our documentation.

Most software systems of reasonable size need to implement workflows: a series of processing steps and decision points over an artifact, typically a document. You are likely using workflows even if you don't realize it; often processing is built up iteratively over time until you're left with a complex system with lots of subtleties. These systems can mysterious and difficult to manage or extend.

A formal workflow engine can offer help in these instances. It allows developers to break the steps and decision points into manageable and testable chunks, so that processing is predictable and measurable. Workflow engines can offer visibility into system operations and metrics around execution times and failure points. They provide retry mechanisms and allow tasks to be distributed among multiple computers.

We have developed Fantasm to be just such a workflow engine. Fantasm is a Python library that allows you to specify your tasks and steps between those tasks in a YAML configuration file. It uses a finite state machine model where the tasks are states and the steps are transitions. As a developer, you implement the code that executes inside of a state and are only responsible to return an event that is used to identify the appropriate transition to the next state. It is similar to the App Engine Pipeline API but is more simplistic and serves as a user-friendly introduction to the concept of workflows in App Engine apps.

Fantasm has become the central processing tool within our organization and we hope it can be of help to yours. For a more in-depth look at Fantasm (including examples!), please see the full Implementing Workflows on App Engine with Fantasm article in the App Engine documentation.

Posted by Wesley Chun, App Engine team

App Engine team appearances Winter 2011

The Google App Engine team has launched some significant features recently, including: High Replication Datastore, Channel API, Always On, Warm Up requests, longer 10-minute (vs. 30-second) limit for tasks, and increased API call sizes. We are excited about these features and think you will be too, so team members will be appearing at a variety of events around the world this Winter to talk about some of these features and the platform as a whole!

One of the marquee events this quarter includes PyCon, the largest gathering of Python developers from around the world, where several App Engine team members will be speaking:

• Brett Slatkin will talk about the Pipeline API distributed workflow manager
• Guido van Rossum, creator of Python, will do his BDFL Q&A
• Wesley Chun will discuss running Django apps on App Engine
• Both Wesley & Ikai Lan will lead a half-day Google App Engine workshop tutorial
• (Planned) OpenSpace session: Fireside Chat with Google App Engineers

Winter 2011 event appearances:

• Jan 18 - ICT Meet Ethiopia 2011 - Addis Ababa - Richard Ngamita
• Jan 22 - Google Hackathon (Year One Labs) - Montréal - Sean Lynch
• Feb 1-3 - Strata - Santa Clara - Patrick Chanezon
• Feb 14-16 - Jfokus - Stockholm - Patrick Chanezon
• Feb 17-18 - Developer Summit - Tokyo - Takashi Matsuo
• Feb 28-Mar 4 - Game Developers Conference - San Francisco - Ikai Lan, Alfred Fuller
• Mar 7-10 - CloudConnect - Santa Clara - Chris Schalk
• Mar 9-17 - PyCon - Atlanta - Guido van Rossum, Wesley Chun, Ikai Lan, Brett Slatkin, Alfred Fuller
• Mar 11-15 - SXSW - Austin - Sean Lynch, Greg D'alesandre
• Mar 28-31 - Int'l WWW Conference - Hyderabad - Patrick Chanezon, Rajdeep Dua

If these aren't close enough to you, keep an eye out on this list as we'll add new events as they materialize. There is also a separate calendar for events featuring other Google products/APIs. For App Engine, look for posts like this throughout the year. We look forward to meeting you in 2011!

Posted by Wesley Chun, Google App Engine team

App Engine conference appearances this Fall

It's conference season, and we're going around the world again! This fall, Google team members will be speaking about App Engine at events in more than 10 countries! In addition to the regular conference circuit, Google is also hosting Developer Days and DevFests in a variety of locations to bring not only App Engine but a bunch of Google technologies directly to you!

Fall 2010:

• Sep 30 - Oct 1 - OpenWorld Forum - Paris - Patrick Chanezon
• Oct 1 - Google DevFest Taiwan - Taipei - Ping Yeh
• Oct 2-4 - Cloud3Days - Fukuoka (JP) - Takashi Matsuo
• Oct 9-10 - Silicon Valley CodeCamp - Los Altos Hills (US) - Wesley Chun, Chris Schalk
• Oct 18-22 - Interop - New York - Sean Lynch
• Oct 19-22 - SpringOne 2GX - Chicago - Chris Schalk
• Oct 26-27 - PayPal X Innovate - San Francisco - Chris Schalk, Ikai Lan
• Oct 27-28 - GOSCON10 - Portland - Wesley Chun
• Oct 29 - Google Developer Day Brazil - São Paulo - Patrick Chanezon
• Oct 29-30 - Google DevFest Nigeria - Lagos - Richard Ngamita
• Nov 1-4 - Cloud Computing Expo (West) - Santa Clara - Chris Schalk
• Nov 2 - Google DevFest Argentina - Buenos Aires - Patrick Chanezon
• Nov 8-9 - Google G|South Africa - Cape Town - Richard Ngamita
• Nov 9 - Google Developer Day Germany - Munich - Fred Sauer, Patrick Chanezon, Simon Meacham
• Nov 9-11 - Management World Americas (Cloud Summit) - Orlando - Wesley Chun
• Nov 12 - Google Developer Day Russia - Moscow - Fred Sauer, Patrick Chanezon, Mike Aizatsky, Simon Meacham
• Nov 16 - Google Developer Day Czech Republic - Prague - Fred Sauer, Patrick Chanezon, Simon Meacham
• Nov 16-17 - Cloud Security Alliance Congress - Orlando - Wesley Chun
• Dec 8-9 - LeWeb - Paris - Patrick Chanezon, Simon Meacham

We look forward to meeting you at one (or more) of these events!

Posted by Wesley Chun, Google App Engine team

Rapid cloud development using App Engine for the Cycle Hire Widget Android application

Update Oct 2010: It's been several months since we introduced you to Little Fluffy Toys and their exciting Google App Engine story. Since then, their app has continued getting rave reviews. We're happy to let you know that there is a great follow-up to this story from the Android and UI/UE/UX perspective, and you can find it here: http://blog.radioactiveyak.com/2010/10/android-app-surgery-cycle-hire-widget.html

---

This post is another entry in our ongoing series of guest posts contributed by App Engine developers. Today we partner with Little Fluffy Toys Ltd to tell the story of how they were able to learn App Engine (plus Python) and launched their service paired with their Android application in less than a week!

Introduction

Last week, Little Fluffy Toys Ltd (LFT) launched an Android app to help its users find bicycles and rental locations in London. While this story doesn't sound particularly phenomenal, how they accomplished this using Google App Engine (and Android) makes their application and its launch one of the most exciting success stories so far in 2010.

The development team at LFT were able to quickly come up-to-speed on learning a new programming language and development environment in order to build and launch the App Engine backend service for their Android mobile app to the world in less than one week. The executive summary:

• Attended 1-hour Thursday night presentation on Google App Engine (Jul 22)
• Started to learn Python and App Engine on Saturday afternoon
• Launched live service Wednesday, announcing their Android app with an App Engine backend (Jul 28)

Before we get to the good stuff, a brief backgrounder on the project which spawned the application: metropolitan bicycle-sharing systems, specifically London's. Based on the success and popularity of the Paris Vélib' system, the Barclays Cycle Hire scheme originated mid-November back in 2008 from its mayor, a strong cycling proponent.

The system launched on July 30, 2010; however a month before the project reached its completion, a call for apps was given by the mayor seeking independent developers so that there would be a variety of mobile and web apps available by show time. Enter Little Fluffy Toys Ltd which ended up creating the Cycle Hire Widget app for Android. They needed a backend system to manage the data, found App Engine, and the rest was history. Shortly after going live with their app and the launch of London's bicycle rental system, I had a chance to discuss how their project came together with the help of App Engine.

NOTE: Cycle Hire Widget is only available in the Android Market if you are located within the UK. If you wish to view the application from outside the UK, please download and install it from within your Android browser via this link — bear in mind that the distances to your nearest rental/hire location will be ridiculous!

App Engine and LFT

As we mentioned above, the sole purpose of their App Engine app is to receive data from and provide data to the Android app running on users' mobile phones. The App Engine stored data is "global" for all mobile clients out there, and this includes names, locations, and dynamic specifics related to each bike station such as the data found in the app's screenshot below. Take note all the valuable data that is provided in real-time by App Engine:

If you're a bit familiar with App Engine, you would no doubt have heard about it as a platform for web applications, but this is a use case highlighting App Engine for a non web-based server-side application where no part of the app is user-facing save for what gets sent back to the mobile app. While this type of app doesn’t get much press, it’s more common than people think.

I met Kenton Price, the director and chief architect of Little Fluffy Toys Ltd, at a developer event recently, and he seemed to think that App Engine would be the right tool for the Cycle Hire Widget. It turned out to be true(!), and when I asked about LFT's needs and how they were met by App Engine after their successful product launch, here is what he had to say:

"As you know, we were massively against the clock with the launch of the cycle hire scheme, and we needed something we could get going with fast that would effortlessly scale to perhaps tens of thousands of mobile users. App Engine seemed the perfect choice from what we had read of it before the meeting, and after your presentation it was obviously the way to go. Your recommendation to use Python was scary given neither of us knew a thing about it, but then again we only knew Java from Android not from web development so we didn't have the domain knowledge of building Java web services. So we went with Python, and it worked out really well. I'm astounded how we actually delivered this product in a very short space of time when we both have full schedules working on projects for our clients and other demanding outside interests. Particularly satisfying was having a solution that was agile and flexible enough to enable us to display live cycle availability data within hours of it becoming unexpectedly available at the launch, so we were live in the field with real-time data that very same launch morning, a feature our competitors are still struggling to replicate."

Development experience

Reuben Harris, LFT's chief technical officer, is the lead App Engine developer for the Cycle Hire Widget. He had a great experience even though he was new to Python as well as App Engine. What excited him the most, and what was his development experience like? He tells his story here:

"The single coolest thing about this project is that it was possible to go from a state of knowing nothing whatsoever about App Engine or Python (other than the mile-high view) to having a working and useful application inside of eight hours. We're long-time geeks but we're not geniuses. For us to pick up a new language, a new SDK, a new environment, a new way of doing things, and produce anything of value at all in such a short time speaks volumes about the value, potential, and quality of App Engine and Python.

After installing the App Engine SDK, yes, the very first thing I did was your online tutorial. I did "Hello World" to find my feet then continued into webapp, since a clean URL handler with easy ways to get at HTTP variables seemed essential. Then I immediately jumped into learning about data storage. And wow, what an enlightenment that turned out to be! Goodbye SQL, don't think I'm going to miss ya.... :-)

Since the app's purpose is to manage just ~400 simple objects representing Cycle Hire Stations, each of which contains only Plain Old Data types — no object references or anything possibly messy — I felt I knew enough to implement it now, and so I dived in. And it was so easy! I started with a handler to rebuild the datastore from scratch. Then I wrote a "get" type of handler to retrieve information about groups of hire stations (returning the data in JSON). Finally I wrote an "update" handler so that updated information about cycle hire stations could be posted, and that was it. Job done.

One thing that initially confounded me was an HTTP 500 error caused by our "reset" handler exceeding the 30-second request limit. For a while I was ready to despair; HTTP 500s to anyone with much ASP experience usually means a hideous low-level bug somewhere! However, once we discovered the problem, this was easy to fix by splitting the work into multiple requests (/reset1, /reset2, etc.) It's an admin function that only we'd ever be using, so no harm done and no need to work out anything more clever.

I know we've barely scratched the surface of what can be done with App Engine. We've yet to use Memcache, background tasks, batched updates, or anything beyond simple cloud-based data storage. But that simple thing alone seemed then, and still seems, not far short of miraculous. To not have to worry about databases, servers, uptime, upgrades and above all scaling... to not have to think about any of that at all is such an immense freedom. I'm completely hooked on it and am unlikely to go back to my traditional server tools of MySQL and PHP.

To see Reuben's work in action, check out this video demonstrating how to use the Cycle Hire Widget app while roaming the streets of London seeking a bike to rent/hire or park:

Conclusion

Since the launch, the Cycle Hire Widget has gotten rave reviews from CNET, The Guardian, and The Londonist. It has even been featured by the Press Association of the UK and Ireland! One user commented on Android Market: "Can't really think of a way to make it better," a sentiment reflected in its very high feedback rating. It certainly does sound like quite a success. What does the future look like? I asked Kenton about how LFT came about as well as how they're looking to improve their succeeding offerings, and here's what he had to say:

"We formed Little Fluffy Toys Ltd as a vehicle for Android development where we do consultancy work as well as our own stuff like the Cycle Hire Widget and Social Wallpaper. Whilst all custom development enquiries are very welcome, we're also interested in hearing from people or organisations that would like us to customise Cycle Hire Widget for their particular domain, whether it's cycles with availability in another city, coffee shops with opening hours in a geographic region, or dieting group meetings at pertinent times nearby. You name it, there are a gazillion applications for it!"

Well here on the App Engine team, we're happy for Kenton and his team on being able to implement the server-side solution they needed in such a short period of time on App Engine, and better yet, to help out a worthy cause. Google itself is a socially responsible company that applauds efforts like Barclays Cycle Hire, so we're proud that technologies we provide such as Android and App Engine can be used to help make London and the Earth more sustainable!

Posted by Kenton Price & Reuben Harris, Little Fluffy Toys Ltd, and Wesley Chun, App Engine team

Upcoming App Engine conference appearances

Fresh from our exciting news from Google I/O last quarter (launch of Google App Engine for Business and new product developments), we now look ahead to the mid-summer months. Since I/O, we've already appeared at a number of events including the Google DevFest Australia and Philippines, PyCon AU, and the Malaysia Open Source Conference, with many more coming this month. There are several well-known large conferences (and many smaller ones too) that our team members will be attending and/or speaking at, so hopefully we'll get to meet you at one of them!

• 2010 Jul 9 - Google DevFest Singapore - Singapore - Patrick Chanezon
• 2010 Jul 14 - Open Web Asia - Kuala Lumpur - Patrick Chanezon
• 2010 Jul 15-16 - Software Architectures for the Cloud - Munich - Nick Johnson
• 2010 Jul 16 - Google DevFest Malaysia - Kuala Lumpur - Patrick Chanezon
• 2010 Jul 17-22 - EuroPython - Birmingham (UK) - Guido van Rossum, Wesley Chun
• 2010 Jul 19-23 - O'Reilly Open Source Convention (OSCON) - Portland - Ikai Lan, Sean Lynch
• 2010 Sep 23 - Google DevFest Spain- Madrid - Chris Schalk
• 2010 Sep 28 - Google Developer Day Japan - Tokyo (+streamed to Kyoto) - Takashi Matsuo, Fred Sauer
• 2010 Sep 30-Oct 1 - OpenWorld Forum - Paris - Patrick Chanezon

In addition to the ones listed above, Google will be hosting more DevFests in Asia and South America later this year. Keep an eye out for specific dates and locations on the Google DevFest home page. There are also 5 larger global Google Developer Day events in the fall. We would love to meet with App Engine developers at a DevFest, Developer Day, or any of the other conferences above!

See you around the world!

Posted by Wesley Chun, Google App Engine Team

PayPal introduces PayPal X Platform Toolkit for Google App Engine

Hello App Engine Developers!
My name is Praveen Alavilli (@ppalavilli) and I work as a developer evangelist for PayPal's X Platform at PayPal.com. I want to take the opportunity to introduce you to our new open source toolkit for Google App Engine that provides an easy way to integrate your Java apps running on App Engine with the new PayPal's Adaptive Payments API. Currently this is a Java toolkit explicitly for App Engine Java, but a Python version will be coming out soon.

Background
The Adaptive Payments API provides a set of core services offered by the PayPal X Open Global Payments Platform to enable developers to embed payments into their applications, services, and platforms. The Adaptive Payments APIs offer several new payments functionality like Split Payments and Preapprovals, that enable developers to implement a variety of monetization models - freemium, subscriptions, pay-per-use, value-added-services, micro-transactions, e-commerce, etc. in their applications built and running on the App Engine. Whether you are building an application for Businesses to process back-end disbursements or payouts to affiliates, or building a social or gaming app for Facebook / Twitter / Open Social, or building a Desktop gadget for premium content, or building a Geolocation app that only helps users find places and people around where they are but even help in transacting them, or building a Web2.0 AJAX app that mashes up content and services, or several more use cases enabled by App Engine, now you can use the PayPal X toolkit to enable payments in them as it fits the needs.

Using the toolkit
Getting started with App Engine toolkit is easy. You can either checkout the source code from svn and import it into your Eclipse project or simply download the prebuilt jar file and include it in your application's class path (/WEB-INF/lib). Similar to other APIs that you might have used, you would need PayPal API Credentials to authenticate your API requests. With the toolkit you simply create an "APICredential" object from one of your application initialization methods (in most cases from your Servlet init() method) and load the API Credentials that you have obtained from the PayPal Sandbox. (Please refer to PayPal's Sandbox guide for more detailed information on how to obtain them).

// Obtain the credentials from your configs 
credentialObj = new APICredential();
credentialObj.setAPIUsername(getServletConfig()
    .getInitParameter("PPAPIUsername"));
credentialObj.setAPIPassword(getServletConfig()
    .getInitParameter("PPAPIPassword"));
credentialObj.setSignature(getServletConfig()
    .getInitParameter("PPAPISignature"));

// setup your AppID from X.com
credentialObj.setAppId(getServletConfig()
    .getInitParameter("PPAppID"));

// setup your Test Business account email 
// in most cases this would be associated with API Credentials
credentialObj.setAccountEmail(getServletConfig()
    .getInitParameter("PPAccountEmail"));

// add required error condition checks
//....

Once the APICredentialObj is initialized successfully, save it in the application's local context so you do not need to reinitialize it on every request.
At its core, the Adaptive Payments API provides 5 generic API methods: Pay, Pay Details, Preapproval, Preapproval Details, Cancel Preapproval, Refunds, and Convert Currency. The toolkit provides the base API Request classes required to make those API calls. To make it even simpler, the toolkit also provides a few functional API wrapper classes that not only abstracts the APIs in terms of the functionality exposed (SimplePay, ChainedPay, ParallelPay, CreateSimplePreapproval, CreatePreapprovalForPeriodicPayments, PreapprovedChainedPay, etc.) but also provides a few exceptions that helps in handling errors more easily than the generic API Responses.

A Simple example
To give you an example, let's say you are building a SaaS model application on App Engine that you charge your customers based on their usage. While on-boarding customers to use your app, you can use the Preapproval API to obtain authorization from your customers to charge them for the app/service based on their usage in the future. In this case you can simply use the 'CreateSimplePreapproval' to create and send a request as below:

try {

  // CreateSimplePreapproval request to setup a simple 
  // preapproval with no Payment Period Set
  CreateSimplePreapproval simplePreapproval = 
      new CreateSimplePreapproval();

  // set the API Credentials object (as given in the code above)
  simplePreapproval.setCredentialObj(credentialObj);

  // starting date in yyyy-MM-dd format
  simplePreapproval.setStartingDate("2010-06-25");

  // ending date in yyyy-MM-dd format 
  // in this case it's for an year from the starting date
  simplePreapproval.setEndingDate("2011-06-25");

  // set max total amount of all Payments
  simplePreapproval.setMaxTotalAmountOfAllPayments(52.00);

  // set max amount for each payment - let's say $1
  simplePreapproval.setMaxAmountPerPayment(1.00);

  // set max number of payments allowed - (52 weeks)
  simplePreapproval.setMaxNumberOfPayments(52);

  // set where to send the user in case of a cancellation
  simplePreapproval.setCancelUrl(req.getRequestURL() +
      "?action=preapproval&cancel=1");

  // set where to return the user after successful approval
  simplePreapproval.setReturnUrl(req.getRequestURL() + "?
    return=1&action=preapproval&preapprovalKey=${preapprovalKey}");

  /* Set other required fields */
  // ... //

  // set memo for user's transaction history
  simplePreapproval.setMemo("Preapproval for GAE Sample");

  // send the request
  PreapprovalResponse preapprovalResponse = 
      simplePreapproval.makeRequest();

  } catch (//...exceptions go here...//) {
  // handle exceptions as necessary

}

In this case, when the 'AuthorizationRequiredException' is thrown, your application would need to redirect the user to PayPal for authorizing the preapproval. The 'getAuthorizationUrl' method takes care of building the PayPal authorization url along with the Preapproval Key returned by the Preapproval API. Once the user authenticates and authorizes the preapproval request on PayPal.com, the user will be redirected back to your 'returnUrl' along with the preapprovalKey, which your application can verify by using the 'PreapprovalDetailsRequest' and store it in it's own app engine data store securely. From that point onwards, whenever the user needs to be charged for their usage of the application, the application can use one of the 'PreapprovedSimplePay' or 'PreapprovedParallelPay' or 'PreapprovedChainedPay' classes to make a payment on behalf of the user. Please refer to the sample apps to understand how to use the other classes provided by the toolkit to make Parallel,Chained or Simple Payments. For eg. the PicMartServlet.java in the PicMart sample app shows how you can make a parallel payment to two receivers at the same time.

Further examples
As mentioned earlier, if you are building a social game where users can buy digital goods (eg. micro-payments) and virtual currencies while playing a game, you can use the same Preapproval API to obtain authorization from them so you could charge their PayPal accounts as and when needed, without requiring them to re-enter their payment information or redirect to PayPal for authorizing the payments.
Other examples of using the toolkit can include:

• An application that lets merchants or enterprises pay their suppliers, or manage affiliate networks
• Applications to enable property owners to collect rental payments from tenants
• With a mult-merchant marketplace, a simple payroll app enables employee salary payments in multiple countries
• ...

As you can see, the toolkit's support of the Adaptive Payments APIs can easily enable all of these usecases.

Where to find more info
Please look at the sample code provided in the samples directory. The AdaptiveRequests.java class in AdaptiveSample and AdaptiveSampleFnAPI shows how to use the helper classes to send and receive requests. The PicMart sample app provides a simple example of how the Parallel Payment can be used in a Photo Printing app that let's users to buy prints of the pictures from Picasa Album of the photographer. This sample app uses the Picasa APIs to fetch the album and picture information from Picasa.

To learn more about the PayPal X Toolkit for App Engine, please visit: http://code.google.com/p/paypalx-gae-toolkit/ and to learn more about Adaptive Payments, please visit: https://www.x.com/community/ppx/adaptive_payments. You can find a lot of resources for developers like documentation, technical spec, sample apps, code, sdks, technical forums, technical support, etc.. on PayPal X Developer Network web site (https://www.x.com).
Posted by Praveen Alavilli (@ppalavilli), PayPal X Developer Network.

TweetDeck and Google App Engine: A Match Made in the Cloud

I'm Reza and work in London, UK for a startup called TweetDeck. Our vision is to develop the best tools to manage and filter real time information streams like Twitter, Facebook, LinkedIn and MySpace. We offer products like our TweetDeck desktop client built on Adobe AIR, and our iPhone application. We are happy to say that we use App Engine as key part in our backend.

We're a small startup, so early on we started to look for tools that would give us the biggest bang for our buck. Combined with the fact we love Python, we thought it might be worth taking a look at what Google App Engine had to offer. The first feature we started playing with was the mail sending facility.

It was easy! Sending mail was a single call-- no messing around. Combined with the fact that it was sent via tried-and-tested Google Mail servers, this meant that we had a simple mailing solution where we didn't have to deal with spam blacklists, mail retries or SPF records. We could really see App Engine being our sole email provider for transactional emails (new users and forgotten passwords), but also for newsletter-type mailing.

When we got started, our existing backend was hosted on Amazon EC2 and SimpleDB, and we knew that we needed a way for the two systems to communicate with each other. App Engine provides all the basic tools to define any sort of resources you want--but more importantly, it has the Python standard library. We implemented a small mail API, with authentication provided by an HMAC-SHA1 of the request information and a shared secret key. The API has been made extremely general: its JSON input format contains fields to send messages to blocks of email addresses that are either defined in the request itself, or which exist as a template in App Engine (templates are defined as strings in a Python module).

The whole setup currently works quite well. We're already extending our mailing system to use App Engine's task queues-- exposing a number of queues to break large mailing jobs into a series of subtasks, thus spreading mailing sending over a large period of time. We have plans to make an even tighter bridge between our EC2 systems and App Engine, which involves keeping our subscriber list entirely in App Engine, and adding and removing from that list as appropriate.

We also use App Engine for various other prototypes and smaller applications that are part of our product. We use it to serve our "TweetDeck Recommends" feed, and we've even developed small tools to apply TweetDeck fan badges on Twitter homepage backgrounds using the Imaging API! The lesson from us, of course, is that using something like App Engine doesn't have to mean everything runs on it. It's an extremely good platform for creating APIs or smaller parts of your application that do specific tasks, and do them well. Think of it as the UNIX metaphor applied to the Cloud.

We love that we've been able to grow the functionality that Tweetdeck provides by progressively using more of the cloud. App Engine provides the perfect platform to compose new services quickly, iterate on them in production, and scale with demand as Tweetdeck's install base grows. Thanks to App Engine and the cloud, there's nothing holding us back from tackling the needs of our user base.

Here is a video interview of Reza and the Tweetdeck team.

Guest Post by Reza Lotun @rlotun, TweetDeck

App Engine at a Conference Near You this Winter!

Happy New Year Everyone!

We're excited to be kicking off a new year, and you can expect to find many new exciting features coming to App Engine in the coming months. In addition to Google I/O 2010 coming up in May -- more on this below -- members of the App Engine team may be visiting a conference near you this quarter. Here is the full list:

2010 Jan 24-30 - Snow Sprint 2010 - Bürserberg, Austria - Nick Johnson

2010 Jan 26-27 - Jfokus - Stockholm - Patrick Chanezon

2010 Jan 28 - PROSA - Copenhagen - Patrick Chanezon

2010 Feb 17-21 - PyCon 2010 - Atlanta - Guido van Rossum, Wesley Chun, Joe Gregorio, Brett Slatkin, Andy Smith

2010 Feb 27 - Dare 2B Digital - Los Altos Hills - Wesley Chun

2010 Mar 10-12 - ConFoo.ca 2010 - Montreal - Patrick Chanezon

2010 Mar 12-16 - SXSW Interactive - Austin - Patrick Chanezon, Brett Slatkin, Sean Lynch

2010 Mar 15-18 - Cloud Connect - Santa Clara - Chris Schalk, Wesley Chun, Ikai Lan

2010 Mar 17-19 - ServerSide Java Symposium - Las Vegas - Max Ross

Although not happening until next quarter, save a place in your calendar and book your travel for May 19-20 to San Francisco for Google I/O 2010. This year will be a blockbuster, featuring your favorite Google technologies and product announcements! There are at least 6 App Engine sessions planned. Register NOW!!

In addition to I/O, Google will be hosting a variety of DevFests in Asia late this winter. Keep an eye out for specific dates and locations on the Google Developer Events Calendar.

We would love to meet with App Engine developers at any of these events! Also be sure to follow @app_engine on Twitter for ongoing announcements as well as our Reddit tag for any relevant App Engine news.

Posted by Wesley Chun, App Engine team

Kaazing creates custom licensing solution using Google App Engine and Google Apps

Hello App Engine Developers!
My name is Peter Lubbers and I work for Kaazing, where we have developed an enterprise-ready WebSocket gateway, named — you guessed it — Kaazing WebSocket Gateway, which enables highly scalable, full-duplex real-time Web communication based on the new HTML5 Web Sockets standard. Using Kaazing's technology, you can seamlessly and reliably extend any TCP-based business messaging protocol to the Web with ultra high performance and minimal latency. The Kaazing WebSocket Gateway also provides emulation for browsers that do not support HTML5 Web Sockets, so you can start coding against the standard today.

We recently built an automated software license key generator using Google App Engine. This internal application proved to be very easy to build and we were able to deploy it within a day. We were extremely impressed with how simple it was to create a service that links our existing Google Apps accounts. Here's a bit of background on our solution and why we chose to implement it with App Engine.

The Problem
We recently needed to automatically create custom license key files for our customers. In order to scale up to our large customer base, we needed a simple internal solution that provided an automated way to quickly generate custom license key files on demand. The key to this hosted licensing system was that it had to tie into our existing Google Apps infrastructure. Fortunately, Google Apps integration (documented here) was very easy to achieve.

Why Google App Engine?
We chose App Engine because it allowed us to create a solution quickly. Since we are already a Google Apps shop, as well as a Java shop, we found the Google Apps integration provided by App Engine to be very helpful, and because App Engine provides an extremely easy development model — from design, to prototype, to a deployed implementation — we found that it exactly suited our needs.

How we built our implementation
Our implementation was extremely simple; we basically capitalized on App Engine's out-of-the-box integration with Google Apps so it was just a matter of writing an automatic license key generator and using App Engine's built-in e-mail service. This license key generator application was then made available as an application on our Google Apps instance.

The best part? From start to finish our license key generator application took no more than a day to prototype, test, and deploy.

Future Apps on App Engine
Overall we were extremely pleased with how easy it was to use App Engine to build a custom solution on top of our existing Google Apps framework. We also appreciate App Engine's support for Java, so we look forward to building other App Engine apps in the future.

To learn more about Kaazing software including their WebSocket Gateway, which includes a developer license (with a license key generated with the App Engine powered license key generator application) visit: http://www.kaazing.com/.

Posted by Peter Lubbers, Kaazing

Audrey Roy Wins the App Engine + Twilio Developer Contest

Congratulations to Audrey Roy -- her "Price It By Phone" application won the Google App Engine + Twilio developer contest that ran from September 21st to October 4th. Audrey will receive $1000 in Google App Engine credit, and a Dell Netbook from Twilio.

Audrey hacked together her contest submission in under 48 hours after going to an art museum and discovering that the $60 box she wanted was only $37 on Amazon.com. She used the Amazon Product Advertising API to look up the best used and new prices for books by ISBN number, using any touch tone phone.

Look up Amazon.com book prices by calling (877) 265-8137. Enter the book's 10-digit ISBN number after the prompt. The voice will tell you Amazon.com's lowest new and used prices for the book. Then, to see the list of books that you've already price-checked, with links to their Amazon detail pages, enter your phone number at http://price-it.appspot.com.

You can find an interview of Audrey on Twilio's blog.

Thank you to everyone who participated in the contest.

Twilio runs weekly developer contests to encourage developers to explore the many use cases, technologies, and industries where voice applications can provide useful solutions. They announce a new category each Monday along with the previous week's winner. This week's category is "Twilio for Salesforce, with Appirio" and the deadline is midnight on November 19th.

Questions? Drop us a line at help@twilio.com

Guest Post by Danielle Morrill, Director of Marketing, Twilio

App Engine talks at a conference near you

It's September and the fall conference calendar is starting to fill up. Members of the App Engine team will present at these conferences: join us if you are in the area, and feel free to tweet @app_engine if you want us to participate in local developer community events around these dates!

• September 29 - Barcamp at La Cantine, Paris - Patrick Chanezon
• October 1 - OpenWorld Forum, Paris - Patrick Chanezon
• October 16 - Stack Overflow DevDays LA - Jason Cooper
• October 16 - HDC09, Omaha - Patrick Chanezon
• October 16 - Day of Cloud, Chicago - Don Schwarz
• October 21 - Stack Overflow DevDays Seattle - Dan Sanderson
• October 29 - Barcamp at Station-C Montreal - Patrick Chanezon
• November 2 - Stack Overflow DevDays Amsterdam - Nick Johnson
• November 4 - Øredev Developer Conference Malmö, Sweden - Nick Johnson
• November 6 - Google Developer Days Prague
• November 10 - Google Developer Days Moscow
• November 17 - Google Devfest Buenos Aires (exact location still TBD) - Patrick Chanezon
• November 19 - Devoxx09, Antwerp - Patrick Chanezon
• December 9 - LeWeb 09, Paris - Patrick Chanezon

We look forward to meeting you during these trips, if you can make it.

Posted by Patrick Chanezon, App Engine Team

Agile paddling with App Engine: lessons learned building the Canoe '09 website

I work for Norex, a web development company in Halifax, Nova Scotia. As part of our sponsorship of the 2009 ICF Canoe Sprint World Championships in Halifax (Canoe '09), we developed an application to deliver real time race results to standard and mobile web browsers. Thanks to the ability to rapidly develop and deploy a scalable application on Google App Engine, and to do so live during the event, what began as a small experiment became a huge success for Norex.

Our goal was to import instant results (directly from the timing system FinishLynx), upcoming race information, athlete bios, teams, and past race results from a system used by the race organizers, and to reformat that data for distribution to web browsers. We chose to develop in Google App Engine (with Django and appengine patch) and iUI (iPhone User Interface) frameworks. In fact, this was our first time deploying an app using any of these technologies! While we had a few weeks to build the prototype, we also had to deal with the added challenges of a varying data format and special cases that could occur during live races. As with many software projects, these specifications were not provided on a regular or consistent basis from the race organizers, so we had to anticipate the unknowns and work to adjust to the conditions at the time.

The Canoe 09 Web Interface

To give you a taste for just how agile we were able to be on App Engine, here are some events during the race which we were able to cope with:

• After the first day, the closed-circuit TV system which the race organizers planned to use for the event was down. Before it was back up and running, we were able to deploy a new view appropriate for display on the TVs.
• By the end of the first day, the application had handled 840,000 requests at a peak of 60 requests/second. This was already several orders of magnitude higher than we had expected. At the start of the second day, we reached 10% of our CPU quota before 7:45am and were processing 100 request/second. While we had originally cached only the main pages, with a few lines of code, we extended our caching strategy to cache every possible page request, a different version for each web platform, and re-deployed during the day's races.
• The rules of the events changed at 2pm on day 3 of the event to allow crew changes. By 4pm, I had reworked the models and views to support the change.
• At 11am on the final day of races, someone in the control booth manually deleted inaccurate records, but this created inconsistencies in the model causing errors. By 11:05am, we had deployed a patch to stop the errors, and by 1pm had deployed a version which gracefully failed when referenced objects were inadvertently deleted.
• Every night we deployed new views of the data as requested by race organizers, participants, and spectators.

We found that new deployments were possible (and quick) because we could stage versions of the application to the App Engine servers, and test these staged versions on live data. Switching from the live version to the staged version and back again takes seconds, thus we could paddle as confidently and rapidly as the racers.

The International Canoe Federation was so impressed by the dependability and versatility of the solution, that they elected to replace their usual channels with our application to serve up the official results for news organizations and to Sport Federation sites all over the world, and to be used internally for calculating medal counts.

All in all, we saw over 1,000,000 page views from 93 countries around the world, and experienced incredible stability and scalability from Google App Engine even when we were spiking 350 requests per second during the finals. It was a big win for Norex, and App Engine has proven itself to be a serious contender for developing scalable web applications. Thanks so much to the Google App Engine team for providing such an outstanding product!

Link to: ZAP Results Application

Guest Post by Adam Thurlow, Web Application Developer, Norex.ca