AJAX on Google App Engine

Sat, 04 Apr 2009 16:00:00 +0000

Continuing , I started to do something a little bit more than things in the tutorial. The tutorial basically shows the way to do traditional server-side web page processing. In terms of ASP.NET, the way is like coding all logics in a class implements IHttpHandler in the code-behind. As the reality is that we need dynamic pages in our web application, I tried to explore the ways to add some AJAX-behaviors to my web pages.

There isn’t any magic to use AJAX on App Engine (It just serves an incoming request, anyway). The difficult part comes in data serialisation. In an AJAX-enabled environment, you may have to pass a non-trivial amount of data to and from the cloud. With Python and App Engine, how do you parse the data from incoming request as well as prepare data in the response? Should you follow the trend, developers are now using JSON instead of old SOAP-compliant XML (maybe not even plain XML). What I want to do is retrieving some entities from datastore, extracting some of the fields, and encoding the fields into a JSON string.

I’m not giving a tutorial here. Honestly, I’ve never do any Python coding until last week. As a programmer coming from a C# background, the most difficult part is about the language and libraries available. So below is what I’ve done over this weekend.

List and Dictionary

These two are perhaps the most encountered containers. They are mutable. How to declare?

myList = []
myDictionary = {}

Where is my favourite statusMessage = abc == null ? “OK” : “Cancel” syntax?

statusMessage = ‘OK’ if abc == NONE else ‘Cancel’

The `get` handler

Here, Guest is a model in datastore. Then, I created a query named guests and a list named json. A for loop is written to iterate through the entities from datastore and extracted some of the fields to create a dictionary named g. By the end of iteration, “g” is appended to list json. For client side to retrieve the data correctly, I’ve to put the whole thing into a dictionary again and that’s why you see { 'guests': json } in the last line. The work of encoding Python object to a JSON string is done by a library called simplejson. Thus, you should have an import statement like this from django.utils import simplejson. Calling its dumps function is the last thing I have to do.

class GetGuestList(webapp.RequestHandler):
def get(self):
 guests = Guest.all().order('lastName')
 json = []
 for guest in guests:
   g = {
     'firstName': guest.firstName,
     'lastName': guest.lastName,
     'isVip': guest.isVip,
     }
   json.append(g)
 self.response.out.write(simplejson.dumps({'guests':json}))

The `post` handler

I didn’t try using JSON in posting data. But, if you want use it, I guess using simplejson.loads will be fine. Here, I used the ordinary techniques to post data back to server side.

class AddGuest(webapp.RequestHandler):
def post(self):
 isVip = self.request.get('isVip') == 'true'
 guest = Guest(salutation = self.request.get('salutation'),
             lastName = self.request.get('lastName'),
    firstName = self.request.get('firstName'),
    isVip = isVip)
 if users.get_current_user():
 guest.lastModifiedBy = users.get_current_user()
 guest.put()

The dispatcher

application = webapp.WSGIApplication(
                                  [('/', MainPage),
                                   ('/addGuest', AddGuest),
        ('/getGuestList', GetGuestList)],
                                   debug=True)

Here is how I did it.

Happy coding! :)

Initial Throughts on Google App Engine

Thu, 02 Apr 2009 16:00:00 +0000

I got some time this weekend to experience what cloud computing is all about. There are a few well-known “infrastructures” you can utilise at this moment, including Microsoft Azure, Amazon Elastic Compute Cloud (Amazon EC2) and Google App Engine. Honestly, I don’t have time to try Azure and EC2 yet. The reason I am attracted to App Engine is their “advertisements” in youtube. You can see that it looks very simple build a scalable web application from stretch. So, I gave a go this weekend.

No doubt at all. It is amazingly simple to startup. The only prerequisite is you must have python 2.5x installed. You can just download the SDK. For Windows users, the SDK is in form of an installer which helps you to make all the required path shortcuts (setting PATH environmental variable) ( ). For Mac users, there is even a UI that saves you a few console commands ( ). After downloading the SDK, I followed the tutorial to set up a simple guestbook application. The whole process only took me 30 minutes (including time to digest the python scripts and .yaml files) and surely it is painless.

As you may know, I’m coming from a .NET programming background. However, I found understanding python scripts is not all difficult. The hurdle to jump through to learn how to use App Engine is very low. For learning purposes, the quotas like CPU usage, datastore access, bandwidth usage, disk space, etc, that Google given is surely more than enough.

Before I go on to but some really useful applications, I’m now trying to understand the differences between “normal” server-client computing and cloud computing (actually, and between distributed computing and cloud computing as well). What I found so far is mainly about data store and caching. There are a few BIG words that I’ve come across about data store, like bigtable, entities, keys, entity groups, transactions. No matter what I have for my data, App Engine stores all data in a single table and that’s bigtable which allows good scalability. In the code, all a need to do is define a class which, in turn, defines what an entity is. Then calling its “put” method will save the entity into bigtable. Bigtable is not a relational database and it utilises time stamp property to maintain consistency. There are no table locks or row locks for write access. The write accesses are in a competitive environment and, if another transaction is writing to it, the transaction is rolled-back and try again. In bigtable, transaction is based on an entity group (a hierarchy of entities) and the assignments of entities to entity group is arbitrary. Thus, to allow efficient transactions, entity groups is to be designed very carefully to allow high throughput (basically, less disk writes). This is first difference I encountered so far. Relating to bigtable, there are a few interesting articles giving some insights in datas store designs, like (related to pattern and anti-pattern problem), , , etc. There is also a from Brett Slatkin talking about some advance techniques.

I’ll try to blog about caching in App Engine and more interesting link about this topic soon.