Shaun Abram
Technology and Leadership Blog
Subscribe to RSS FeedOSCON Day3 – Google App Engine
I have seen several talks on Google App Engine before, but have still not used it in anger, so this talk, Introduction to Google App Engine, acted as a refresher. It was given by Ikai Lan, a software engineer working for the Developer Programs groups at Google.
Google App Engine is a way to run your applications on Google infrastructure. You push your code to App Engine and it gets scaled out depending on how many instances you need.
My notes from the talk are below, but you can find the full slides here or here.
Tags: cloud, google, googleAppEngine, oscon
OSCON Day3 – The Joys of Engineering Leadership
The first talk of Day 3 at OSCON was “How to Lose Friends and Alienate People: The Joys of Engineering Leadership” by Brian ‘Fitz’ Fitzpatrick and Ben Collins-Sussman, both from Google.
What is an engineering leader?
- Serves the team
- Eliminates roadblocks
- Provides advice, guidance and helps get job done
- Mutual respect/Mutual trust
- Promotes technical and social health
- Leadership is not a waste of time…
- Being a team leader is a way of scaling yourself
The speakers broke their talk on how to be a good leader down in to two sections, which were (in good coding tradition) patterns and anti-patterns…
Tags: google, leadership, oscon
JUG Meetup: Joshua Bloch (Effective Java)
I had the chance tonight to see Joshua Bloch speak at the Silicon Valley Web JUG meetup down at the Googleplex in Mountain View. I have read and blogged about his great book “Effective Java” – probably the single best book I have read on Java – so it was great to hear him in person. The talk covered a couple of examples from his Java Puzzlers book as well as a discussion on some of the items from the Effective Java book. As expected, he was a great presenter, both insightful and funny.
GTUG Campout Demos
Last night saw the end of the Google Technology Campout weekend, with about 25 or 30 groups giving demos of a lot of cool Wave apps. I particularly liked the robot/gadget that analyzed when it was time for a group of wave participants to leave the wave and meet in real life, supplying a list of possible venues to meet based on the participants’ physical location. A vocabulary analyzer from a group of brothers also looked pretty good. I also liked the h3lp application, kind of like an Onstar four your mobile phone, which pushed out alerts to selected contacts in case of an emergency. In the end, the winner was the video sharing team.
The demo for our BlipWiki project (which I blogged about here) unfortunately had technical difficulties so our presentation didn’t go so well. One of our 2 browsers couldn’t seem to connect so we didn’t get to show our Wiki updating in real time in the way we would have liked. Still, I think we had a great application at the end of the weekend, and I certainly learned a lot, met a lot of great people, and got to know Google Wave much better. A great weekend…
There are photos and videos from the weekend posted here and a write up in the San Jose Mercury News.
Tags: campout, google, gtug, wave
GTUG Campout Follow up
I’m currently at the Google Technology User Group Camp out weekend down at Google’s offices in Mountain View. The objective of the weekend is to form a team and develop an application, using Google technologies. The demos are Sunday afternoon.
I joined the Blip Wiki team. A Blip is simply a single message within a ‘Wave’ conversation. A Wiki, of course, is a software tool that allows users to easily create, link and collaborate on documents. So, our goal with the ‘Blip Wiki’ project was to bring the incredible collaboration capabilities of Google Wave (real time updates, autocorrect context sensitive spelling etc) to the easy document setup and linkability of a Wiki.
Although Wave can certainly be used to collaboratively create documents as it is, Wave is inherently conversation focused. We wanted Blip Wiki to be inherently Document focused.
To do this however, we needed to use our own instance of a Wave server i.e. use the Google Wave Federation Prototype Server rather than the regular Wave server hosted by Google. We also needed to come up with a new client (something like tiddlywiki) and, most importantly, ensure our client can communicate with the server. Our project won the award for the most ambitious pitch at the start of the weekend!
Federation Prototype Server and example client
We got off to a good start by getting the Wave Prototype Server downloaded, building and running (it runs on top of OpenFire, a real time collaboration server that uses XMPP/Jabber). We then got the demo wave client running and talking to our server. We managed this by late Friday evening.
Client/Server protocol
Next, we created our own demo client and tried to get it interacting with our Wave server. That is when we started running into problems. First, the client/server protocol has not yet been formalized, and there don’t seem to be any definite plans to do that yet either. For example, although this Client Server Protocol White paper describes a protocol and data model, it does not give any details on the format that should be used, or suggestions on how to use it. There is a lengthy discussion in the Wave Protocol Google Group about this. For example, someone suggests that the client server protocol is just protocol buffers ‘over the wire’. But a protobuf is really just a simple data format, and while I assume ‘over the wire’ means RPC, it is all a bit vague.
Submitting changes
The client/server protocol used in the example client (a “toy’ text client) is for “illustrative purposes only”, according to this doc. We couldn’t seem to find much documentation for it, perhaps because it is not supposed to serve as a standardized example. As a result, we found it difficult to reverse engineer. So, we ended up resorting to using the Client example code to marshal our data to and from the server. The example client code in effect became a sort of interface to the server for us. A client side stub, if you will. (We had this running in the web tier servlet layer).
Receiving updates
So, after we had used the Client example code to submit changes (blip updates) to the server, our next hurdle was understanding the data that gets returned. Ideally, we would like a ‘delta’ of the data. That is, after the server has done it Operational Transformation magic, we would just like the latest and greatest version of the data to display on the client. However, this proved difficult to get from the server. Instead all I could seem to get was a non-delimited complete history of the blip. I admit that this was done using pretty hacky code. I am sure there must be another, better way!
So, we ended up taking a similar approach to the example client, and just displaying the latest submissions.
Demo ready – almost…
Right now, we have a working client and server with updates made on one user’s WikiBlip automatically showing up in another users.
It would have been really nice to be able to deploy our local Wave Server to app engine, but apparently this isn’t possible since the OpenFire jars required aren’t on the whitelist of allowed jars.
It also would have been nice to experiment with our local Wave server talking to the real Google Wave server (e.g. to have a regular wave client user be able to interact with a blip wiki), but apparently this is not possible due to authentication issues.
So, we chose a very difficult task for the weekend! But, we have a working version ready to demo and it has been a great weekend all in all.
Thank you’s
A big thank you to
- Sriram and Sreejith, my BlipWiki teammates
- Kevin and Van from the GTUG
- Stephanie, Brian, Fred and all the all Googlers who made the weekend possible and great!
I will post again later with the results of the demo…
Tags: campout, google, gtug, wave
Google Technology User Group Campout
I have signed up for the Google Technology User Group (GTUG) Campout. It is a weekend (August 7-9, 2009) of designing and coding an application, as part of a team, using Google technologies. As far as I know, Google ‘technologies’ can include things like GWT, Android, OpenSocial etc, but there will be a particular emphasis on Google Wave (due to members of the Wave team being out and about to help), and hence Google App Engine.
I am not too familiar with Wave yet, so this should be a great opportunity to get to know it better, meet a bunch of fellow techs, and hopefully produce something cool by the end of the weekend. Looking forward to it…
Registration is free, so if you are interested you can sign up at here.
Tags: android, google, googleAppEngine, gtug, gwt, wave
SF JUG: Android UIs
There was another great San Francisco JUG meeting tonight down at the Google offices. It was all very well organized as usual by Sasa. The speaker was Romain Guy from Google’s Android UI team. He gave his talk from Google IO: Turbo-charge your UI: How to Make your Android UI Fast and Efficient.
The presentation slides can be found here.
I thought Romain was an excellent presenter and did a top job of talking on his area of expertise: Android UI development. He covered the issues you need to be aware of when developing Android UIs if you want them to be performant, best practices and work-arounds for the gotchas, as well as useful tools that can be used for development. Personally, I would have benefited from more of a broad overview and introduction to Android, but that is more a reflection of my own lack of knowledge on Android! Maybe the newly created Android User Group will provide an ‘Intro To’ type talk at some point…
First, Romain covered the Andriod UI terminology (like Canvas, Drawable, Surfaces and Views) before covering the architecture.
The bulk of his talk covered how to make sure you UI runs fast, including:
- Avoiding runtime scaling of background images
- Avoiding invalidating (i.e. redrawing) the entire screen and instead only invalidate the small part of the screen that has actually changed.
- Minimizing the number of views you use (ideally have <100, which seems pretty reasonable for a tiny phone screen!) and talked about some techniques to help with this including using ViewStubs and recycling views
- Avoid allocating memory (apparently the Garbage Collector is slow and pretty much stops the world when it is running)
- Use SoftReferences (objects that only have soft references to them will be kicked out of memory if the Garbage Collector needs more memory) and WeakReferences (which can help to avoid memory leaks) when possible
He also talked about some neat dev and debug tools including Allocation Tracker (which monitors objects being created, memory being allocated etc) and Hierarchy Viewer (which shows you all the devices/windows/views you have how long things are taking to render).
He also mentioned the Android emulator that can be used for testing your apps.
Some of the questions from the Q&A session included:
Q: Will Android support languages other than Java?
A: Romain mentioned that there is a version of Scala and python that work on Android, but currently all APIs are in Java.
Q: Does Flash work on Android?
A: Development is on-going and the Android team is working with Adobe.
(I found more on the web about this topic here: http://gizmodo.com/5300800/flash-for-android-webos-landing-in-october)
Q: Can JavaFX be used on Android?
A: Code might be hard to run on the phone and may not be performant.
Q: Apparently, Sony Ericsson are also building an Android phone. How do you plan to avoid fragmentation as other companies start shipping Android phones?
A: CTS – Compatibility Test Suite
You cant ship a phone as ‘Android’ if it doesn’t pass the CTS.
Other links:
http://d.andriod.com
source.android.com
android.git.kernel.org
code.google.com/p/apps-for-andriod
http://android-developers.blogspot.com/
http://forum.xda-developers.com/