Tags: appengine
Django
2008/07/28 @ 01:15I was thinking about using Django for one of my projects on GAE because it seems like a popular project and somewhat easy to use, but I'm not quite understanding yet why it's better to have helper functions rather than controller/handler classes like Pylons or GAE's normal WSGI handling has. With handler classes my controller might look like:
| from google.appengine.ext.webapp import RequestHandler | |
| class MainHandler(webapp.RequestHandler): | |
| def get(self): | |
| # Read data from BigTable here | |
| self.response.out.write(outputhtml) | |
| def post(self): | |
| # Write data to BigTable here | |
| #redirect back to the url | |
| self.redirect(self.request.url) |
Whereas the django helper function might look like
| from django.http import HttpResponse, HttpResponseRedirect | |
| def mainview(request): | |
| if request.method == 'POST': | |
| # Write to BigTable Here | |
| return HttpResponse(outputhtml) | |
| elif request.method == 'GET': | |
| # Read from BigTable Here | |
| return HTTPResponseRedirect(request.url) |
While the Django method might have the potential to have be a bit less verbose it feels like it would be harder to do things correctly, like factor code etc. I also don't really like the conditional checks to see what kind of HTTP method was used. So either I would need to split GETs and POSTs to separate urls or just live with the conditional checks.
Personally I feel better with the Pylons-ish controller/handler approach. Anyone have an opinion?
I went to Google Developer Day 2008 in Yokohama Japan yesterday. The keynote speech was pretty much the exact same info as was given at the keynote at Google I/O where Google announced their direction, moving forward the web as a platform.
Keynote
As with the Google I/O keynote it was mentioned how Google feels that Computing power and accessability have kind of flip-flopped over the years. In the mainframe era you had computing power but no accessability, in the PC era you had accessability but lost relative computing power, and now in the web era we are getting back computing power in the form of cloud computing but we are loosing accessablity to those resources. They plan on fixing this with the, so called, three Cs. Client, Connectablity and Cloud.
The first refers to the browser, so Google wants to make the browser richer in order to give us accessability to the computing power that they can provide. They are doing this with Google Gears and some other handy browser plugins.
Connectability refers to allowing everyone equal access to resources and making sure every one can connect. This means making sure that internet lines are fast, airwaves are open etc. They see mobiles as big in the future so they hope to help the connectability problem with Android, their free, open operating system for mobiles.
Cloud refers to their vast data centers. They hope to give access to these resources through products like Appengine where developers can access the vast resources and scalability that Google's data centers provide.
Appengine Hackathon
In the afternoon I attended the Appengine Hackathon which was presided over by Brett Slatkin, who is none other than the guy in the Appengine demo video. It was interesting because from the e-mails I recieved about the event, I figured it would be in Japanese but it ended up being entirely in English. Many of the Japanese folks had trouble following along so I tried to help where I could.
In the beginning, Brett talked about Appengine and used an example wiki as a demo app. Then we went into coding our projects. At the end some folks showed off their applications. Despite the language barriers many folks came up with some really original, and cool ideas. The first was created by a Google engineer, who said he would set the bar low but ended up with one of the better applications. His app read calandar events from RSS and allowed users to add comments to it. He also implemented memcache support. There was an application with the idea to attach pictures based on the hostility/mood level of a chat message or Twitter tweet. There was a social bookmarking app, and an app to allow live translating of a django application.
For what it's worth I presented my application which I hope to make into a workable form application builder. I haven't uploaded it yet so you'll have to make do with my first Appengine application, a prefix calculator with a simple rest api.
Dinner
Afterwards I went out to dinner with a number of folks who participated in the Hackathon. It turned out to be a lot of fun and I made a lot of new friends many of whom are now in my twitter contacts 
All in all a hugely satisfying experience.
Google Developer Day Japan 2008 is being held on June 10th at Google's offices in Shibuya and I've registered to attend this year. There were a number of sessions that people could take part in but I decided to register for a Google appengine hackathon. I'm pretty curious about appengine since I've been working at becoming more familiar with really newly evolving technologies and not necessarily ones that have been around a while. Newly evolving technologies is something I've always felt I've had to catch up on since starting programming in high school. Going to high school with folks like Bob Ippolito (Mochikit, simplejson) and Konrad Rokicki who started coding stuff when they were in early middle school didn't help my self esteem.
Anyway, in the spirit of learning about Appengine I took a dive into the documentation and learned a few of appengines silly limitations but I came up with a simple application that utilizes the simple python library I created for prefix back in college. I put it up in my mercurial repository under prefix-appengine if you care to take a look.
The main work is done in two handlers which are essentially the controller part of the MVC pattern. One simply renders the page as a template, which is really simple since there isn't any template code, and the other implements a simple rest API that I use for an AJAX call to evaluate an expression given by the user. Using JSON seemed like a waste since there was only one returned value.
| class PrefixHandler(webapp.RequestHandler): | |
| def get(self): | |
| self.response.out.write(template.render("main.tpl", {})) | |
| | |
| # def post(self): | |
| # self.redirect('/') | |
| class EvalHandler(webapp.RequestHandler): | |
| def get(self): | |
| expression = self.request.get("exp") | |
| values = {} | |
| try: | |
| output = prefix.parser.parse(expression).evaluate() | |
| values = { | |
| "value": output | |
| } | |
| except ValueError, arg: | |
| output = "ERROR: " + str(arg) | |
| values = { | |
| "error": output | |
| } | |
| self.response.out.write(simplejson.dumps(values)) |
The rest of the code is in the javascript which I just wrote strait into the template file because I was lazy. The javascript uses jquery to do an AJAX call when the button is pressed and update the HTML DOM.
| var lastvalue = ""; | |
| $(document).ready(function() { | |
| $("#eval").click(function() { | |
| expression = $("#exp").val(); | |
| $("#output").html("Loading.."); | |
| uri = "eval?exp="; | |
| uri += encodeURIComponent(expression.replace("Ans", lastvalue)); | |
| uri = uri.replace(/%20/g|>, '+'); | |
| $.getJSON(uri, | |
| // Callback | |
| function (data) { | |
| output = "<font color='#FF0000'>ERROR: Invalid response from server</font>"; | |
| if (data.value != null) { | |
| output = expression + " = <font color='#00FF00'>" + data.value + "</font>"; | |
| lastvalue = data.value; | |
| } else { | |
| if (data.error && data.error.length>0) { | |
| output = "<font color='#FF0000'>"+ data.error +"</font>"; | |
| } | |
| } | |
| $("#output").html(output); | |
| } | |
| ); | |
| }); | |
| }); |
XML Feeds
