grep.ro

So here is a more detailed account of the @media Ajax 2007 conference, filtered through my subjective experience. I could have raved on and on about some of the talks, but wishing not to bore you, I tried to keep it short. :)

The talks

The State of Ajax (Dion Almaer and Ben Galbraith) - The introductory talk - it was lively, entertaining and informative.

But I'm a Bloody Designer! (Mike Stenhouse) and Planning JavaScript and Ajax for larger teams (Christian Heilmann) - Two talks about working as a team on web applications. Lots of general points about software teams large and small, and some web-specific issues. These were very interesting for me, because they discussed problems that I've come across, problems that are important, and have no easy answers. How do you get a group of people to work together, be productive, do quality work, and, not least, enjoy it? Some take-aways:

• Do automated testing. It provides both a specification and a verification of the code.
• Pair programming. Not in the XP sense (two developers working on one keyboard - I've tried that, and I don't see much value in it), but rather pairing a designer with the programmer who's going to make the code for the interface.
• Do agile development. It's better suited to the way people think, and facilitates information sharing.
• As a developer, write code assuming someone else is going to take over when you finish. Don't say "we'll hack it now, and fix it later"; chances are it's not going to get fixed. Also, don't experiment when writing production code, on a deadline.
• Do code reviews. It helps with code quality, sharing information among team members, and spotting people who could use help/training but are afraid to ask.
• Use a good build process: consolidate and compress javascript and css files. Too often these are considered "special"; they should be treated like any other source code files.
• Have a lead developer. His job is to keep the managers off the developers' backs and generally remove impediments, so the developers have room to work.
• Maintain a handover document, versioned together with the source code. This is useful for new people coming aboard the team, and just in case another team needs to quickly pick up the code.

Real World Accessibility for Ajax-enhanced Web Apps (Derek Featherstone) - An interesting insight into the kinds of problems one has when building an interactive, ajax-ish web site that is also accessible (for keyboard-only and/or screen-reader users). It can be surprisingly difficult to get around the limitations of HTML.

How To Destroy The Web (Stuart Langridge) - Stuart gave a very entertaining talk on what not to do on the web. Things like polling the server with ajax requests, serving uncompressed content via http, etc. It mostly centered around the (tongue-in-cheek) theme "we must do all we can to fill up available bandwidth".

Ajax at Work: A Case Study (Peter-Paul Koch) - PPK talked about a project he's working on: an interactive site to navigate family trees. There are interesting problems and design decisions for fetching data to be displayed in the page: what format to use on the wire, how complex a request may be (wether to allow complex queries), etc.

JavaScript 2 and The Open Web (Brendan Eich) - A bit of a history lesson on the origins of JavaScript, and example code for the features proposed for JavaScript 2. The features are interesting, but I'm not holding my breath, I don't see how those features will provide much improvement for me, and of course there's the really big issue of backwards compatibility and the cooperation of all browser vendors (*cough* microsoft *cough*). Also, there were screaming monkeys flying about.

Building Interactive Prototypes with jQuery (John Resig) - The jQuery talk. I'm already a big fan of the library, so the talk didn't teach me many new things. But then John typed a command in the Firebug console, a jQuery selector that returned an array of DOM elements. Firebug prints that as a list in the console, and mousing over an element highlights it in the page itself. So simple, so elegant. This is a lot of separate things coming together: a good dynamic language (JavaScript), a solid platform (the web), a smart and polished tool (Firebug). Definitely my kind of coding. :)

Metaprogramming JavaScript (Dan Webb) - This was a hackish talk. Dan explained, one by one, the really cool features of JavaScript. My only complaint is that I didn't hear this talk two years ago when I started playing with the language - I had to learn most of those things myself :) Anyway it was great fun, and I learned some useful tricks. Take a look at the slides if you're into this sort of thing.

Dojo 1.0: Great Experiences For Everyone (Alex Russell) - Alex gave a totally different perspective on web development, explaining the philosophy of Dojo: the web as a platform has really failed to evolve, we still use the same HTML controls we had years ago, and we increasingly have to hack around their limitations (anyone who tried to build a file upload control that does not reload the page knows this only too well; accessibility is another good example). Dojo attempts to encapsulate these hacks; Alex said he would be only too happy if browsers implemented the missing stuff: "we'd love to become legacy".

JavaScript: The Good Parts (Douglas Crockford) - This was a more studied, academic, mature take on the same topic of Dan Webb's talk. Some really interestig points on what JavaScript does wrong (favourite quote: "In JavaScript there is a beautiful, elegant, highly expressive language that is buried under a steaming pile of good intentions and blunders") and how to set it right. For example, prototypal inheritance versus classical inheritance - object construction should really be "take this object and make me another one just like it". Douglas built a really nice tool for people who care about writing good JavaScript: JSLint ("JSLint defines a professional subset of JavaScript"). It looks at your code and tells you what you do wrong; I fully intend to use it. He also had an interesting take on the lack of evolution of the language: "the very best part: stability - no new design errors since 1999!". This is not merely poking fun; think about generics in Java and C#.

The Panel - There was the obligatory panel at the end. Some good discussion happened, especially about how to move forward on the language front, why are there so many different JavaScript frameworks and how to choose one, and some thoughts about security on the web.

Conclusions

First, a couple of bad points. Internet access didn't work - you have a conference about web technologies and there's no internet? Something is wrong :) Also, the sound system was not that great and, combined with the fact that I'm not used to listening to a fast speaker of british english, meant that I missed some parts of somem talks.

All in all, I thoroughly enjoyed the conference - good job Vivabit! - and I can only wish I had the chance to go to more conferences like this. The topics were interesting and thought-provoking, the speakers were good and they managed to engage the audience (there were lots of questions at most talks). A lot of the "raw information", especially in day two, was not really new to me, but there were some really interesting bits that I learned, that are bound to be useful.