Technologies:

• Back-end:
  • Google App Engine (SDK 1.2.4)
  • Python (2.5.4)
  • Django (1.0.2)
  • Google App Engine Helper for Django (revision 90)
  • PyAMF (0.5)
    • PyAMF Test Client (Slightly modified from the original Test Client)
  • Pyfacebook (0.1)
• Front-end:
  • Flex (3.3.0)
  • Swiz Framework
  • Facebook ActionScript Library
• Development Environment
  • Windows XP
  • Eclipse
    • Flash Builder 4 Plugin
    • Pydev

Flex has been my primary technology over the past couple years, and I wanted to build a Facebook game with it. I'm addicted to the Swiz Framework so I continued to use that (instead of Cairngorm). The app required a Flex Facebook-Friend-Selector component so I also needed the Facebook ActionScript Library for the FqlQuery command.

I planned to build an AMF service layer for the Flex app and almost went a LAMP/Zend setup on my personal web server. I was introduced to Google App Engine by a colleague and quickly went with it because of the automatic scalability and free quota.

App Engine currently supports Java and Python, and I went with Python because the Django framework sounded really interesting. Using the Google App Engine Helper for Django almost seemed like a must for a newbie like me.

There were a couple AMF libraries for Python, and I first tried DjangoAMF but quickly found it to be unusable for my Flex 3 app. I ended up using PyAMF which worked out really well. I wanted to write unit tests (which Django is great for) and found that I needed a test client for the remoting classes. I founded one on a random blog post and added it to my PyAMF files (with some minor modifications). With the remoting test client and the Django test client I was able to write and debug unit tests for all my AMF services.

My app needed to notify Facebook users and post messages on walls. Instead of doing this on the client-side, I did this in Python with Pyfacebook.

Instead of using the standalone Flex Builder, I used Eclipse with the Flash Builder 4 and Pydev plugins for development environment. I was able to  locally debug both Flex and Python code all while running the app within Facebook (thanks to port-forwarding).

Curveballs

Version Compatibility

Though it was documented, I still stumbled with the version compatibility of Google App Engine, Python, and Django. Be sure to double-check what works with what in the latest documentation.

Locally Running the Python Server to be Available through Facebook

For local development I created a development Facebook application which pointed to my machine's IP address using port forwarding and dlinkddns.com. What I didn't understand until I read the docs more carefully is that when I ran the development Python server using "manage.py", it defaulted to the IP address 127.0.0.1 (on port 8000) which prevented Facebook from being allowed to hit the server even though it could hit my machine. I ended up using "manage.py runserver 0.0.0.0:8000" which allowed Facebook to hit the development server.

Google App Engine Datastore is not a Relational Database

Before I decided to go with App Engine I had sketched out my model to create tables in a MySQL database. I had about a half-dozen tables which in Django directly correlates to a half-dozen model classes. As I was developing the business logic I learned that the App Engine datastore is not a relational database. I couldn't do joins. That forced me to significantly refactor and basically de-normalize my model down to 2 classes.

These links helped me understand what was going on:

• http://tech.boradev.com/?p=38
• http://code.djangoproject.com/wiki/AppEngine

Mocking or Lack Thereof

The service code uses Pyfacebook and requests data from Facebook. I didn't want that code to run during unit tests largely because it wouldn't have the proper session keys. I briefly looked into mocking some of the Pyfacebook code for the unit test but without success at first pass. I cheated using a settings flag so that code wouldn't be run during unit tests to just get the features done for now. I hope to properly learn mocking in Python in the future.

Facebook Session Keys and AMF

From my understanding normally HTTP requests from a Facebook application would contain a bunch of Facebook data such as session keys. With AMF service calls, those HTTP requests do not have that data so the facebook object that the Pyfacebook middleware creates doesn't have some values set such as the session key. And that session key is needed for some of the API calls I was using. I ended up not using the middleware according to this post, manually created the facebook object, and manually set the session key which I parsed out from authentication data sent to the service methods. The authentication data was based on the Facebook fb:swf notes which allows you to verify that the swf was loaded from your Facebook app.

Facebook One-line Story Publishing

I was very confused about how my application should post messages (stories) to Facebook users' walls and the permissions it required. For now I wanted to avoid explicitly asking for elaborate permissions. Posting one-line stories  seemed like it didn't require the "publish_stream" extended permission. I ended up making sure the user was logged in, that the app was added to the user, and using the feed.publishUserAction API. I didn't use the recommended stream.publish API because it appeared to only publish "short stories" which required extended permissions.

Conclusions

I loved using Python and Django. I found Python to be a very friendly yet powerful language and Django to be a very efficient yet powerful framework. It let me quickly build up a tested AMF service layer. I'm very curious about the future of Django in commercial projects.

I think using Google App Engine, Django, and Flex is a great way to quickly build scalable Facebook applications. You definitely have to get used to programming for App Engine though. If you're not afraid to commit to coding specifically for App Engine then it seems like a great solution. I think development speed and scalability are key aspects in social media application development. This combination of technologies seems to address those aspects very well.