The venue was also great—if a bit too big for getting from room to room in a hurry—and the security and catering staff were some of the nicest I’ve ever encountered. Apparently we weren’t allowed to mention the name of the enormous sports stadium west of London that we all attended, but if I say it rhymes with Bembley and looked like it still had the builders in and scaffolding up then you’ll know where we were.

As at any conference the talks were a mixed bag, although all the ones I went to were definitely worth listening to. Mano Marks covered developer optimizations for Google App Engine with aplomb and a cheeky grin; Dion Almaer provided what might have been a “will-this-do” overview of the “state of AJAX”, which actually became a more interesting discussion of the state of browsers in general, and how they might move towards full support of RIAs; Nimrod Talmon’s discussion of Google Visualization, on the other hand, suffered from being immediately after lunch. I could’ve managed that level of tech details after a nap to sleep off my sugar slump, but I think he should really have been in the pre-lunch slot. We were all jamming on simple carbohydrates anyway, so it’s not as though we would have been itching for butties. The content of his talk was still intriguing, though, and it’s good to know you can at least consider handing this sort of thing over to a third-party engine if the client wants it but the poor webserver doesn’t.

The lightning talks at the end of the day were as shambolic as these things tend to be. Liz said that a lot of people had expressed an interest before the event, but if that was the case then they were all being very optimistic about what they’d actually be able to accomplish before the day, as we only had maybe half a dozen in what sounded from Nick like the most popular slot of the day. Anyway, it was fun to break out a bit, but my laptop wouldn’t detect the projector, and then the gist—the actual, pivotal slide—was lost in conversion to whatever it was it was converted to on a Mac. I may do it at a later Geek Night, if I can stomach abusing my position as organiser.

Google very much held off on any go-team antics, hoping that their products would speak for themselves. That was slightly marred by them making it quite clear to everyone, that they did indeed hope that their products would speak for themselves, but at least there were no overt recruitment drives, and rubbishing of the competition was limited to the pretty much warranted chastisement of over-prompting your user and making them numb to modal dialogues, behaviour of which XP is particularly guilty.

Within the reasonably frank and open exploration of their services, however, were occasional notes of discord. Whenever any kind of business case was mentioned things would go quiet, and quite clearly those things weren’t up for discussion, which I think is a shame. Google doesn’t need to pretend that it’s everyone’s best friend to have our respect: it’s public knowledge that it has shareholders, and I think developers the world over can admire it in that context if we know where we are with it.

Transparency engenders trust, and I’d take comfort from someone replying to a query about the bottom line by saying “well, I asked my boss, and he said that we give this stuff for free because it positions us as an influential brand when it comes to advertising revenue, trusted partnerships, GSAs, Google Minis….” Hell, if I’d been fed on those ciabatta rolls and caramel shortbread slices beforehand then I’d probably be asleep by that point, so it wouldn’t matter what they admitted after the fold.

Those occasional moments aside I had a grand day out. I’m itching to start working on App Engine now, and putting into place some of the weirder code patterns Mano mentioned. I’ve also already had a play with Gears following Dion’s talk, and it seems to turn Google Docs into something close to OpenOffice. But before any serious coding, I have to wait for the blood blister on my finger to go downfirst, which came from playing Guitar Hero at the end of the evening. How rock and roll, eh? The young Googler I played against trounced, me: as you’d expect: deep down I think Google’s just as cool as it wants to appear to be on the surface.

Like a moron, I left my mobile phone at home, and then ended up separated from everyone I know; so have a look at what I’m liveblogging and find me, if you care.

Edit 2008-09-18: notes now below.

The End

Lightning talks 16.25-17.35, SF2

Google App Engine
  <head> web conference - headconference.com
  Old days;
    An app would be built, load-tested get discovered, and die. 
  Now:
    You test with ONE person, it gets discovered, and GREAT!

  Construction phase
    More complex
    Tools more limited
      Both of these have their reasons

  1,000 files
    Django source > 1000
    Solution: Guido van Rossum: http://icanhaz.com/zipimport ; rietveld on Google OS

  1MB limit on ALL data structures
    You will run up against this EVERYWHERE
    Can’t combine files on server
    Solution: Amazon S3 - infinitebits.info gives FTP access

  No long–running processes
    Solution: hack it with HTTP refresh!
    Web-based cron! webbasedcron.com

  Short-term quotas
    24-hour quota
    Uncatchable
    Bad advert!

  Backup and restore
    GAE Backup And Restore (uh-huh)
    Open-sourcing it

  Django
    Google are not into developing application frameworks
    So basically use Django, dudes.

  http://opencountrycodes.appspot.com/
  http://isvat.appspot.com/

Android work, Kevin O’ Sullivan, Sita

  Airports still run on 60s technology!
    Looking at mobile technologies
    Predictive analytics from ACARS data - archived and ignored

  Passenger mobility
    Smartphones, context-awareness

  Application
    GPS
    Mashup, overlay with airports

    Click on airport and get Arr/Dep info, querying a backend system

RDF, Tom Morris
  RDF as an open-knowledge enabler
  URIs in the data
    Links to other documents
    URIs that define something e.g. wikipedia:Cities:London

  Mashups
    PITA - be a developer
    Or have the data link itself together
      “Let’s all use the same names”

    dbpedia, bbc.co.uk/programmes
    libris.kb.se - Swedish Nat lib
      every book has a URI

  SPARQL
    A bit like SQL

  sindice.com - search existing linked data (DERI - digital something research inst)

  Libraries + making easier for JS/AJax devs

Green Maps

  Green maps - Anna approached for Glasgow  Green Map
    Open project for local community?
    … Get them to do the work
    Also existing reuse groups - the Electron Group

  Put out leaflets everywhere around Glasgow
    “Enthusiastic developers!” “Enthusiastic designers!”
    … bugger all
    But presented at arts school and got lots of volunteers

  Dear Green Place
    website deargreenplace.org

Visualize your data: Google Visualization API, Nimrod Talmon, ->16.10, Atari

  Types
    Generic
    Specific
    “Hard”

  Examples - iGoogle gadgets
    Wrapped in Javascript, exposed to the iGoogle framework via an API

  Problem:
    Potentially many data sources
    Potentially many visualization sinks
    Many APIs - hard to find “the right one”

  Google Visualization
    Seems to be a generalization of Google Charts

  Google Finance - generic stock charts, embedded into GF

  70 lines of JS code for a simple-ish 10-20 point graph with widgets

  Why?
    Google does the visualization, so fast & scalable
    API built with devs in mind

  Premise of visualizing
    Abstract a visualization
       Data
       Appearance
    Model objects from Google’s API
       google.visualization.TypeOfVisualization() … chart.draw()

  (Nothing should ever make it easier to build pie charts. Especially three-dimensional pie charts, the anti-visualization for people who won’t get numbers anyway. Tufte FTW!)

  (A bit hard work -  data.setCell(x, y, ‘Label’) is a bit like <cfchartdata>. JSON methods?)

  Q; data going to Google?
  A: Javascript call to get API, but here generation is in client. Others in Flash wrapped in JS.

  Q: other formats e.g. JPG?
  A: ?

  Events & actions
    Own event model
    Visualisations listening to events and communicating between each other via closures addListener(fred, ’select’, function() { barney.method(); })

  Data views
    Dynamic re-slicing off the data you’re using for one vis, potentially for reuse in another
    Not a new data set - change the data, change the view
    Like SQL views

  Q: aggregate functions?
  A: wait 10 mins

  Why develop for Google Visualization?
    Reach - de facto standard
    Viable business model? Panorama, Eureka

  (Note to self: ESC :w does not work in a Google doc)

  Extend API with new visualizations
    Declare draw() method on prototype

  … slightly dry but interesting demos… they shouldn’t have these things just after lunch….

  SQL-like syntax querying Google Spreadsheets… Pretty cool, but count the number of browsers that will deal with this scalably: I make it two.
  Ah, this might only be happening server-side. Phew. I wonder if I still have that Bobby Tables spreadsheet lying around anywhere.

  Visualizations laid out on the webpage, about as well as MS Word does it in a document, only you can dive in and work out why everything keeps turning bold, dammit.

  Q: Accessibility?
  A: Don’t have generic solution for this - write your own vis and you can do it

  (Don’t see how that’s possible, as the data will still be in .setCell() calls… how about microformats on a plain-HTML table, with the table appearing for accessibility-impaired? A method to convert HTML or JSON to a data source would be tidier anyway.)

Lunch

A deeper look at Google App Engine, Mano Marks

  Overview of App Engine
  Quick walkthrough
  Best practices

  Standard problems of setting up a webapp
    Startup, scalability, upgrades, maintenance etc.

  GAE easy to start, easy to scale
  5M pageviews / month for typical app
    Payment for additional cap. BY END OF YEAR
  Python only
    More languages soon
    Mano can’t tell us which, but he won’t tell us why he can’t tell us - we don’t need to know
  Offline processing
    No cron, but… soon.

  SLA
    None
    Cloudstatus, partner org, monitoring tool
  Lock-in
    (You can’t download your code, so get svn warmed up)

  cite: Hackathon slides and other useful info - http://code.google.com/p/google-app-engine-codelab/downloads/list

  Tutorial
    app.yaml
    WSGI application
      methods as per HTTP verbs
    Models on top of BigTable
      schemaless - “what happens if you add a column to a table in a relational database? EVERY ROW in that table gets that new column”

  Q: What about data security?
  A: Google do not trawl through your data. It’s your data. We don’t touch it.
  Q: There’s an SLA?

  Q: Do we put ads on your applications?
  A: No. Your visitors will never know this is a GAE app

  Entities
    Most properties indexed and efficient to query (not including BLOBs and CLOBs/text)
    Keys - limitations (only one ID per entity, cannot change ID or key_name later) but Get() by Key is VERY fast
    No revision storage - you have to do this yourself

  Transactions
    ACID
    No queries in transactions - Get() and Put()
    So assemble your data first with .gql() to inform your transaction, then perform

  Counters
    BigTale doesn’t count by design. So must Model.count() scan every entity row
    class Counter(db.Model)
    Sharded counter - in an entity GROUP (see docs)
      Counters count a few entities on reads, and whenever necessary you could the counters

  (I thought Mano was going to break into a rendition of “That’s Amore” to the camera just then. I think you had to be there.)

  Cache reads and counters
    memcached
    cacheing for n seconds, where n is OK for your purposes.

  Q: 1MB limit - can we gzip and reassemble?
  A: We don’t give you access to files and Python - I think - needs that. But you have a 1MB cap on out-of-the door. And we don’t give you the underlying C libraries
  Q: So C won’t be the next language on App Engine?
  A: I didn’t say that (laughs)

  Q: SLA…
  A: UNOFFICIALLY, I’d like people to say “I want to spend this amount of money”. Currently you have a quota but it’s divided up so you don’t use it all up in one spike.

  Q: URL fetch - buy more time? (limit 4s)
  A: at this point no way round that. Can’t comment on future.

  Q: Django 0.96 - 1.0 roadmap?
  A: We haven’t released one. You can upload 1.0 yourself. But things like GeoJSON rely on C libraries, so there are issues there.
     People are always going to ask “Are we going to support multiple versions?” (which wasn’t really the question - 0.96 was pre-release, 1.0 wasn’t. A good reason to just support one version, and that be 1.0. It’s not as though there’s an SLA in the way.)

  Q: memcache - shouldn’t GAE handle that/
  A: we don’t want to pre-empt the developer too much, taking control out of their hands. Maybe a 20% proj will handle that if it goes in as a feature request…!

State of AJAX, Dion Almaer

  Dion runs Ajaxian

  1. Desktop-y world
  2. Cloud services
  3. Browsers
  4. libraries and frameworks
  5. Gears and monkeys
 
  Take a step back
    What does AJAX mean now we’re where we are

  Took a designer to see the potential
    “The latency will get you, the web’s not good enough”
    Needed proving through e.g. auto-suggest

    Maps - eyecandy of draggable maps itself isn’t really AJAX
      just different ways of thinking about the static HTML page

  Car ads
    Show the dashboard (UI)
    Not the engine schematics, although they’re important to get right

  Jared Leto as a UI overhaul
  Vista as a UI and not much else

  cite: Jef Raskin, The Humane Interface. I want Raskin’s head-mounted Borg interface.
    “… if the interaction between one human and one system is not polite and friendly it will poison the user experience…”

  Visual design and interaction design
    Two separate worlds
    But they’re both right

  The whole web used to look like MySpace
    Now, Apple Store - no Flash, but it zooms and swoops
    Expectations change: Bridge On The River Kwai vs. Spiderman 3
    Script.aculo.us, Dojo, jQuery follow expectations. You just have to use them nowadays or the absence is noticeable.

  cite: Jakob Nielsen
    1-second reaction time of your app is about the limit for keeping the user’s flow
    0.1-1, people notice, but they don’t mind too much

  The library dartboard!
    Gradually collapsing down to jQ, Dojo, P+s.a.u, and… GWT

    1. lightweight - Prototype
    2. hate Javascript, love that hot lava Java? - GWT
    3. functional, DOM-like - jQuery
    4. rich soup-to-nuts - Dojo

    I don’t like the sound of soup to nuts. I’ve been in that sort of restaurant.

    P, jQ and Dojo all have thin core + plugin community + visual effect plugins, so “pick one”

  Examples of other libraries
    Mobile Me (SproutCore)
    280 Slides (Objective-j)

  Dojo realtime charting - GFX package, Dojo grid, Processing.js (Canvas)

  The 0.1second limit
    Event queue, browser, processing - browser’s switching system (JS? style?) a bottleneck
    Firefox logo used for the browser, I see

    No such thing as threads in JS.
      cite:Brendan Eich, “Threads suck.”
      In comes Google Gears, neeow
      WorkerPool process outside the browser

  Jef Raskin again. “The typed ‘Y’ becomes a learned gesture” - warning dialogues just get clicked on, unheeded
    So undo instead
    But how do you do that on the web?

    Form history
      Slider bar changes between revisions - don’t ever actually have to give someone the undo

  cite: Jonathan Schwartz. Every RIA has a RIBackend

  Talking to desktop
    Notification APIs

  1. Fluid - Mac only, but integrates tightly using Greasemonkey-like scripts
  2. Gears - more about giving the browser access to existing APIs
  3. Mozilla Prism - cross-platform
  4. Adobe AIR - using Flash / CSS skills to build desktop apps

  Back to the dartboard…
    Wii remote, directing a dart, in an Ajax application.
    You’ve won a rubber bully!

  Wii -> bluetooth -> WinXX -> wiiuse -> wiiusej -> Java plugin WiiTracker -> browser

  Java PLUGINS?
    In Chrome,
      Works out of process (doesn’t kill browser, totally independent)
      Deployment with JNLP - download components only once
      Micro-kernel

  Modern Web Development
    cite: Alan Foreman, poisonedminds.com

  Mozilla’s monkeys
    Getting other languages into the browser with VMs

  Plugins only get you so far
    HTML5
    Gears is trying to follow this (and presumably to some extent lead it)

   70% of sites have a div called “footer” - so why not <footer> ?

  Questions
    Q. Compatibility & SLAs - adopting other people’s projects?
    A. No plans - still very immature environment.

Keynote

  Browser as client
    Ubiquitous, zero-install, standards
    but capabilities mediocre
    Google want to improve browser capabilities
  Cloud access
    Massive capability beyond most devs’ reach
  Connectivity

  Current web apps are pushing the browser’s capability
    Browsers haven’t changed much, but the web has
    Invisible iframe!
  So Chrome

  *** CHROME COMMERCIAL BREAK *** - good but covered by Scott McCloud already

  APIs
    Programmatic accessibility of authentication and content
    *Significant* growth in traffic

  Google App Engine
    Other languages in pipeline

    Solves non-dev problems for apps;
      Deployment
      Pre-launch investment
      Hardware maintenance
      Scalability

    Apps
      Wordle
      Buddypoke (OpenSocial)
      iPhone app - code.google.com/p/metasyntactic
      Pixverse - Pix Wall and Pix Chat

  Android
    Open Handset Alliance (!)
    OS mobile platform + WebKit

    Mike Jennings
      *** Android demo ***
      Tape over branding
      Slashdot is so 2002, unless you’re me
      Touch screen
      The blue dot app - accelerometer
      OpenGL, Java

  Google Web Toolkit
    Writing BIG AJAX apps
      Live demo - a bit .NET
      Hosting browser running Java bytecode, not Javascript representation.
      So can be debugged as Java code

[Edit: run Python using Javascript too.]

“IDEs are draining users away, but it’s not the classic fat-client IDEs that are ultimately going to kill Emacs. It’s the browsers. They have all the power of a fat-client platform and all the flexibility of a dynamic system. I said earlier that Firefox wants to be Emacs. It should be obvious that Emacs also wants to be Firefox…

“… [N]ow the browsers are starting to sprout desktop-quality apps and productivity tools. It won’t be long, I think, before the best Java development environment on the planet is written in JavaScript.”

I’m more of a vi user these days—it behaves much more consistently over emergency ssh sessions—but as a general advocate of Emacs over IDEs I can see his point. Browsers should want to be like Emacs, or at any rate more like the VM of your choice.

Between browser-as-VM, Firefox, ECMAScript and compatibility frameworks there’s the seeds of an RIA revolution. After all, to what extent will industries gladly rest their financial weight on RIAs, so long as they’re all written in Flash-on-the-browser, and so long as browsers remain so unpredictable and Flash remains… well, Flash?

Despite the argument of what constitutes openness being largely resolved in the open-source community, we still found rich pickings of our own. It’s trivial to define openness in, say, data, with its analogies to code; but it would be an error to equate data and knowledge or understanding thereof. The broad consensus was that open knowledge was a combination of both free-as-in-speech and free-as-in-beer, but also free-as-in-educated and free-as-in-enfranchised. In this way, its analogies lie more in open computing, or open web-navigating, than in open source: a combination of freedom, autonomy and opportunity. Solutions will therefore need to be a complex, messy combination of social, political and technical: less like Python, but more like One Laptop Per Child.

Ben Spigel, who made the connection between OS-then and OK-now explicit, missed the mark a little when he likened the OK community to Linux’s. After this conference, I think we need to stretch even further back, to such early efforts as the FSF and GNU. There are still moral complexities to be resolved, difficult decisions about direction to be made, and occasionally vehement arguments to be had: only once all that is settled can we sit back and just worry about the OK equivalent of killer apps, whatever those might turn out to be.

Certainly marketing genius and total orphan Lily Allen, and internationally renowned cuttinge-edge futurologist Gene Simmonds are pulling the sort of pouts you’d expect from them both, and Guy Hands has a look on him like they just cancelled Christmas. But even in these hilariously gurning faces of criticism, and amid the wafting and intermittent atmospheres of genial misunderstanding of how content works these days from the TV and radio monoliths, Radiohead are keeping chipper. Far more so than I’ve ever seen them before, in fact. And when everyone’s on YouTube for free, letting rip with their Thumbs Down webcast, and accepting its reappearance—syndication, if you like—all over the shop very shortly afterwards, was a refreshing change from everywhere else exercising rigid control at the loss of an audience.

But for those of you (like me) who were thinking of taking part in Radiohead’s distribution revolution, yet weren’t keeping an eye on the time:

• The download-only area of “In Rainbows” closed this morning. I just managed to get a copy of the tracks yesterday: I’m sure if you’ve missed out then you’ll all know someone who’s got a copy they can loan you, right? Loan you until the plain old CD comes out at the start of 2008, right?
• Discboxes (40-quid monstrosities that I was secretly waiting till next year to buy) are actually already out and limited stock. I thought from various reportings of the event that they too weren’t going to be on sale till the new year. Get yours while it’s hot.

If there’s demand I bet there’ll be more discboxes, but frankly if Radiohead don’t stamp “SECOND IMPRESSION” over the next lot then I might sue. Actually, if my discbox doesn’t have “A TOTAL W.A.S.T.E. OF CARBON” scrawled over it then I’ll be terribly disappointed.

Seriously: who among us is just itchy and fidgety, waiting for analogue TV signals to be switched off? Who wakes up of a morning thinking, ooh, Whitehaven have to buy Freeview boxes now! with a frisson of glee? Radio switchover would be even more disastrous, of course: whereas TVs normally have a gap between themselves and an aerial into which to insert a Freeview box and convert digital to analogue, most radios are monolithic: receiver, “decoder” and audio equipment all together. That means that the average of five radios per household would be simply landfill material, useless fizzing boxes capable of picking up nothing but static. Future generations will already find a sliver in the geological strata that they can classify as “analogue to digital”; FM switchoff would add a shiny, plasticky laminate to that layer.

Here’s a thought, though: how about a little digital-to-analogue converter for radio? It could be the size and construction of, say, a Fon, and configurable over USB. It would transmit FM in the style of an iTrip to fill perhaps the room it’s kept in, plus neighbouring rooms. It could transmit multiple FM stations at the same time, and even mimic the frequencies of the analogue stations (if they were ever, say, switched off without anyone wanting them to be: God forbid!)

But what if your converter’s chosen frequencies conflict with next door? FM transmission depends on phase coherence, so even if your two boxes were within an electronic ace of each other frequency-wise, they’d still interfere with each other and cause all sorts of beating, flangeing and other dirtily-named auditory confusion. At least when someone passes you on the motorway and their phat BMW iPod transmitter briefly swamps yours then they’re gone quickly, hopefully to come to some sort of messy grief on the next bend. But if you’re stuck near someone who permanently foxes your radio listening—and it would only take maybe three or four such converters for a conflict to be inevitable in the narrow FM band—then what do you do?

Answer: let the converter boxes know how to talk to each other. Let them negotiate their frequency spreads. Let them, moreover, report back to you over what sort of understandings you and your neighbour’s radios can come to. Let them synchronize, if possible, on stations you both want to listen to, strengthening the signal and meaning both of your houses are entirely covered by the FM cloud. Exploit, don’t squash, the wisdom of the group.

I’ve never known the first in (hopefully) a series of events go so well. Clearly from the reaction of the crowd this night fills a hole in the Oxford geek community’s calendar. I can’t comment on my own talk, of course, but there was some interesting stuff there: without doubt the two keynotes from Simon W (OpenID) and Olly Willans (Photoshop CS3), but also Tom’s peastat, James Wheare’s scraping of bus timetables LiveBus.org, and the Drupal and Mapnik introductions.

My talk went as well I could expect: I hope to put some slides and screenshots up here shortly. Unfortunately it touches on work that I’m trying to make live by the end of this week—the new version of my short story site—so I’m snowed under with that right now. Gosh, it’s all go, isn’t it?

(Note: I work with, for, by or under several people mentioned in this post. Take it as fawning sycophancy if you like.)

RSS, the standard millions of us use to syndicate content, and view other people’s syndicated content, was originally invented by Ramanathan Guha at Netscape, for use on its my.netscape.com portal. Soon afterwards, Netscape lost interest in the format, leaving it ownerless and later on picked up by a development community spearheaded by UserLand Software.RSS 0.91 became 1.0 and 2.0, yet despite the deprecation of the grandaddy of them all 0.91 is still around and in use, arguably because of the vast overcomplications in its immediate successor and the divisions that it caused in the community.

The problem with that is as follows. Every time someone views an RSS 0.91 syndication feed with certain types of syndication software, their computer attempts to get the DTD from this location on the my.netscape portal—it’s hardcoded into the way that the software understands what XML format it’s dealing with. So this URL gets plenty of hits:

http://my.netscape.com/publish/formats/rss-0.9.dtd

Which is great, until Netscape decide—legitimately, one might argue—to update the my.netscape portal and get rid of the DTD. Which they did, at the start of the year. At that point, a good portion of the syndication lights go out across the world. And although we now have a moratorium until July 2007, nothing has really been solved in the long run.

Anyway, Netscape shouldn’t have to support the bandwidth of millions of DTD downloads for a standard they declared defunct—when did they sign the don’t-be-evil contract?—and maybe people should “just” move to a newer version of RSS, or Atom. But this whole episode is an Ozymandian warning of what is to come. We’ve reached the point where the URLs of industry (one-time) giants are simply no longer to be trusted as the location of standards.

One day Microsoft, and Sun, and IBM, will cease to exist, and their websites become the 22nd century equivalent of Google-adsensed search engines (Google, of course, will be around forever, more’s the pity). Sooner or later something really horrible will happen for the open communities, say Purl disappearing for good, taking things like the Dublin Core XML specification with it. We need to know how to deal with the loss of their specifications and standards now: the unreliability of the URL as a locator for DTDs and schemata. Or is the only lesson we can draw from history, that we’re destined to wander from standard to standard as the specifications drop off the radar, leading the nomadic life of those standardized today, obsolete tomorrow?