boogdesign posts

The venue was a function room in a pub which wasn't ideal - there weren't enough seats for everybody and, since I was a bit late arriving, I had to stand through both presentations which made it a bit awkward to make notes.

Putting microformats on the Semantic Web with GRDDL (Tom Morris) - Tom started off by talking about "Descriptive Markup", an alternate term for semantic markup to avoid "semantic" being every third word that would come out of his mouth. He then moved on to GRDDL and it's potential for creating a decentralised data web out of any HTML pattern you use on your website. An HTML pattern doesn't have to be a Microformat, it can be any HTML as long as it's used consistently on your site and you can provide an XSL transform to turn that pattern into useful semantic data. You can then write your own GRDDL profile to allow the data to be automatically extracted. He also discussed that the output from a GRDDL transform needn't be RDF, it could be anything you want such as RSS or JSON, which would allow you to very easily create an API for your website with nothing more than a few transforms. In the questions at the end he compared GRDDL to CSS and Javascript, except where CSS was for presentation and Javascript is for behaviour GRDDL would be for data. For an example of the potential he suggested we checkout triplr.org. Tom finished off with some "Design Patterns for the Web of Data":

• Give everything a URI - your website, your house, your car, your pets etc.
• Things (ie. URIs) linked together with meaning
• Small vocabularies loosely joined - don't try and describe the whole world, stay focussed on your target domain
• Do the right thing - practice wisdom
• "Pragmatic" usually means you're doing it wrong
• Don't mandate, don't limit - the less you restrict, the more room there is for freedom of expression

One Big Happy Family: Practical Collaboration on Meaningful Markup (Dan Brickley) - Dan's talk was a bit more political than technical and addressed the antagonistic attitudes which are sometimes displayed by Semantic Web folk towards Microformats folk and vice versa. Through a discussion of some of the history behind the current Semantic Web specifications at the W3C, a history which is largely obscured by the specs in their current state, he demonstrated that the two communities have far more commonalities than differences. Both communities are converging on the same goal but are taking very different routes to get there, and a bit more respect on both sides could allow each to learn from the other. That was a high level summary, the way Dan said it took longer but was also funnier with a liberal sprinkling of anecdotes

The talks themselves were very good, but I didn't enjoy the environment much - apart from the standing, the TV screen was a bit hard to read so 3.5 out of 5 overall.

Deploying and Updating AIR Applications (Serge Jespers) - Serge covered the nuts and bolts of deploying AIR applications. He demonstrated the user experience of installing signed vs unsigned applications, and the $299 dollars a year for a code signing certificate is probably worth it if you're going to develop AIR apps regularly. Next he talked about deployment, which involved a discussion of 'Install Badges' - basically flash movies embedded in a web page. The basic one will just run the installer, but there's a more advanced one available, in beta form, on Adobe Labs which adds functionality to check and see if your app is already installed, and tries an update instead of an install if so.

Adobe AIR API Overview (Daniel Dura) - Daniel took us on a potted tour of the AIR API, highlighting some of the 'cool bits'. He started off in the Window API and discussed transparency - so you can create irregularly shaped windows with custom controls - and he demonstrated that it was 'real' transparency by interacting with the desktop through the gap. He then talked about the SQLite API, which lets you achieve Google Gears type things within your app before concluding with some discussion of the integration between AIR and the native OS drag and drop mechanisms.

Extreme AIR development: From concept to TechCrunch in 5 Days (Jeremy Baines) - On to the first lightning talk, Jeremy talked about the rapid development of his AIR app, Alert Thingy, unfortunately the demo went a bit pear shaped.

Developing Secure AIR Applications (Oliver Goldman) - This was one of the more important talks of the day. All the cool apps and transparent windows are fun and shiny, but you want to be fun and shiny while not simultaneously turning your user's machine into a node in a giant spam botnet. The AIR runtime has two security domains - the one where your application code runs, the Application Security Domain, has certain 'dynamic' features, such as eval, innerHTML and <script> elements, disabled to help you avoid shooting yourself in the foot with any imported content (which runs with the loader's privileges). Loaded content, in frames or iframes or loaded by loader.load in a Flash movie, runs in a sandbox by default, the Remote Security Domain. This means it does have eval and friends enabled, but it doesn't have access to all the cool AIR desktop integration stuff. In order to give your loaded content access to those features you have to use the sandbox bridge functions to explicitly make methods available. The final point the Oliver made is that an update function should be part of your security strategy - if security holes are found in your AIR application you've got to have a reliable method for pushing the fixes out to your users, therefore 'check for updates' and associated logic should be included in your first release.

Using JavaScript Frameworks in AIR Applications (Andre Charland) - We were on to the 'short talks' now. Andre discussed how you could easily adapt most popular AJAX/Javascript libraries for us in AIR apps and discussed some of the things they were good for (keyboard shortcuts, activity indicators, window operations when chromeless, mouse hints and tooltips).

BBC News & Sport on Air (BBC) - Three guys from the BBC gave a quick overview of their corporation's history of desktop applets for easy access to website updates and contents, and how the early clients had evolved into the current/new AIR prototype application, which looked quite neat.

Google Analytics on AIR (Nicolas Lierman) - Nicolas has reverse engineered Google Analytics (though now in full co-operation with Google) to produce an AIR desktop analytics application. Quite interesting as an intellectual exercise, I didn't see any clear advantages over the web interface though, and it seems you have to have it on blue gradient background instead of a nice clean white.

Why an Ajax Guy is Excited About AIR (Dion Almaer) - Dion talked about the future of the web and how AIR and Google Gears are complementary technologies. Contrary to popular belief, Google Gears is not "all about offline" - it is a collection of small improvements to the browser API and a testing/proving ground for some HTML 5 APIs. Basically a way of making parts of tomorrow's world wide web available for web developers to use today.

AIR Conditioning (Lee Brimelow) - the day ended on a light hearted note as Lee gave a lot of amusing examples of applications you shouldn't create in AIR just because you can. My favourites were the world's smallest video player and the little app which moved the window out from under the mouse so you couldn't close it. Not much in the way of technical content, but an enjoyable way to end nonetheless.

I didn't enjoy the afternoon so much, and at the time I felt like it was a bit lightweight compared to the morning, and also that the presenters were starting to repeat stuff from earlier in the day. However, looking back in review I think my perception was mostly due to the later afternoon where the flow was lost a bit with all the shorter presentations - it maybe would have been better to spread the shorter talks out among the longer ones rather than clumping them all together like that (ie. one long and one short talk per session between coffee breaks). Still plenty of good stuff, and more free food at the end so 4.5 out of 5.

Free stuff and breakfast - Everyone who attended got a free t-shirt and an O'Reilly Shortcut, Flex 3 Early Evaluation: Assessing Flex and Your Project Needs. Not bad swag (or schwag, as they insisted on calling it), especially when considering this is the first of these sort of things I've been to where they had free t-shirts in XXL. There was also a lot of high value (and some not so high value...) giveaways throughout the day on a raffle type system (no prizes for me, though ). Breakfast was tea, coffee, juice and sugary donut things to be consumed while playing with the XBox or Wii.

Keynote - Andrew Shorten presented AIR as the latest in a long line of 'disruptive innovation' from Adobe (and Macromedia), it was marketing hype but I'm sure we can let them off. He listed the key use cases for AIR applications (as opposed to web apps):

• Applications without persistent connections
• 'Branded' experiences
• When desktop functionality was required
• Local data access scenarios
• Efficient development

There was mention of a few apps which demonstrated the above features, but not enough time to go into details.

Building your first Adobe AIR application with Adobe Flex (Mike Chambers) - This talk used FlexBuilder, the Eclipse based IDE for Adobe's Flex framework. We were shown actual code examples, a common theme throughout the day, rather than pictures of what to do and, despite my having done no Flex before, it all looked easy enough (which I'm sure was the point). There was some discussion of application signing, and Mike also mentioned two books which are being published with a Creative Commons license: Adobe AIR for JavaScript Developers Pocketguide and the ActionScript reference for RIA development.

Building your first AIR application with HTML and JavaScript (Kevin Hoyt) - After the first talk demonstrated building AIR apps with Adobe's commercial tools, this talk swung things around to show how it was just as easy to build stuff with the free SDK, a text editor and a good knowledge of standard front end web technology. He started off with a few samples, MapCache and SimpleTasks, both implemented using only HTML and Javascript. Again we were treated to live examples with real code in an editor, the key first step is to import the AIRAliases.js which gives you access to the OS integration features through references like air.File.desktopDirectory.resolvePath (resolves the file path to the user's desktop) and air.File.FileStream (the main way to read and write files). Kevin also discussed the Application and Non-Application Sandbox: in the Application Sandbox (where you have access to the AIR APIs) the features in Javascript relating to dynamic code execution are disabled for security (because you have file system access with the user's privileges); you can create a IFRAME in the Non-Application Sandbox which runs like normal JS, with eval and dynamic content creation, but with no direct access to the AIR API, then talk to your Application Sandbox through the SandboxBridge.

Leveraging HTML and JavaScript within Adobe AIR (Kevin Hoyt) - After a break we were back with Kevin for a talk on how to get the Flash and ActionScriptparts of an application to talk to the HTML and Javascript parts. This talk was mostly code rather than slides, and I present a much compressed version here from the (hopefully) salient points I scribbled down in my notes. First off, calling ActionScript from Javascript: create an external interface in your Flash file ExternalInterface.addCallback and then use document.getElementById from your Javascript to reference the Flash object and call the method directly. Also from ActionScript you can reach directly into the HTML DOM with a browser.window.document reference. From what I understand this is fairly standard for Flash and HTML without AIR being involved, what AIR adds is a greater consistency and closer integration. In an AIR app you can reach inside the Flash runtime from JS using a window.runtime.flash reference which allows you to take advantage of SWF components. Kevin demonstrated a Zip viewer in Javascript which used David Chang’s Zip utility (fully detailed on his excellent blog).

Lunch - it's my policy never to complain about a free lunch, fortunately in this case I had no desire to Serving staff came to us with trays of finger snacks while we were queuing for the food table, and later came around with little bowls of hot food. I had a lamb and potatoes thing. The only vaguely confusing thing was they seemed to expect me to eat gravy with a fork, but it all tasted good.

I'm going to stop here, since it's taken me over a week already and I'm only half way through the day. The morning by itself definitely deserves a 5 out of 5, if you're still wavering about whether or not to go to any of the events on the second half of the European tour I'd say it's well worth a day out. A few other folk have been a lot quicker off the mark than me - Remy Sharp and James Ford are two I've come across (you can even see me in one of the pictures in the second one).

Microsoft released the first Beta for Internet Explorer 8 the other day, so I downloaded it and installed it on a virtual machine so I could test it out. This post records my first impressions, even if it took me two weeks to actually finish it off and publish it

First stage was the install, which looks much the same as the installer for IE7, I selected 'Choose my settings' to make sure I didn't miss anything.

The first option is also familiar from IE7, nice of it not to change my default search provider to Live anyway.

Next was 'Select activity providers' - this is a new feature in IE8, more on this below.

The 'Safety filter' - much the same as in IE7.

Finally, because I'd selected 'Go online and select more activity providers,' I got to the activity providers page.

Although all the options come from Microsoft, there were a few examples which weren't driven from Microsoft's data. I selected Yahoo! as my mapping provider as well as a few other non-standard ones.

So the first test, how does IE8 render my website? Answer, quite well actually!

The home page looks a lot more like it does in Firefox than it does in IE7 (below). Though a visual test of one web page is hardly thorough, it does seem likely that this will be MS's most standards compliant browser yet.

The blog itself also looks OK, no major issues for me so far!

However, on the JS front, things were not quite so rosy, mostly thanks to some of the many 'blog decorators' I've got going on in the sidebar. But this gives me an opportunity to show off one of the first things I really liked about IE8 - the new 'done with errors' dialogue.

You can expand to see all the errors in a list (in IE7, only one error shows at a time) and it also has that very convenient 'Copy details to clipboard' button.

That's not all on the error handling front, I got to see the other neat new feature, which seemed mostly to get caused by msn.com. The initial error message is much like before:

But what it does after that is a bit more clever. Each tab in IE8 runs in a separate process, a feature known as LCIE, so a crash is not fatal to the browser. As you can see in the image below, when a tab crashes it is simply restarted and the rest of the tabs are unaffected.

There's also a whole collection of (very Firebug like) developer tools built in to the browser, allowing JScript debugging without installing one of MS's Visual Studio variants. The tools menu as also had a bit of an update, to emphasise the privacy features.

Activities are a major new feature of IE8, it's basically a way of taking advantage of other resources on the internet to enhance the information you can see on your current page, similar to the way the Firefox Operator Add-on is supposed to work with Microformats. For example, below I have selected the post code on my 'About Us' page and then right clicked - I get a choice of 'activities' for my selection.

I select 'Map with Yahoo!' and a map appears in a floating frame.

There is apparently a more direct interface than right clicking, but I couldn't get it to appear reliably. Selecting some text sometimes causes a little button with an arrow on it to appear:

So enough praise, there are several things I didn't like so much. First up, WebSlices - basically a sort of single item RSS feed embedded in a web page. This is quite exiting for the Microformats community because the format for embedding the item is based on hAtom. Unfortunately it isn't actually valid hAtom, and also seems to be solving the exact same problem as Microsummaries which has been in Firefox for over a year. So with two existing (though admittedly de-facto) standards to choose from, Microsoft chose to implement neither of them and go their own way. There may be very good reasons for this, of course, but it's the sort of thing that makes you wonder how serious they really are about following web standards.

The next point of complaint is the IE7 mode. Generally a good idea - switch the browser back to an older rendering engine so that any pages which are seriously broken by IE8's new standards compliance have a chance of working, users have a simple 'make this site work' button to press. The implementation, however, is just plain bad. They've gone to all the trouble of making their browser crash proof with the LCIE stuff, but then have a feature as important as 'Emulate IE7' force you to restart the whole browser before it has any effect. So if you have eight tabs open, and only one website which doesn't work, you still have to close all seven other tabs to get that one page to work.

As a web developer you can trigger the IE7 rendering mode from your web page by either sending an HTTP header, or using an http-equiv meta element in your HTML:

<meta http-equiv="X-UA-Compatible" content="IE=7" />

Be warned however, the browser, even in 'IE7 mode', still believes it's IE8 in my (limited) testing. So if you're using conditional comments like these, they won't be picked up:

<!--[if IE 7]>
<link rel="stylesheet" href="/styles/ie7.css" type="text/css"/>
<![endif]-->

Overall then, I'm quite impressed. The activities stuff is quite smoothly implemented, the improvements for web developers are excellent and the move towards standards compliance is commendable - 4 out of 5. I hope they continue to make improvements before the final release.

I'm more of a web developer than a 'Microsoft developer', but I use a lot of the MS stuff at work and I really enjoyed WebDD last February so I thought I'd give the more .Net focussed parent event a try.

Why IronRuby? (Presentation) Dave Verwer - I'd been to a couple of Dave's talks at the WebDD event and enjoyed them tremendously, so I went in to this one with high expectations. The talk started with some of the benefits of Ruby - a dynamic language with elegant syntax designed for simplicity and productivity, before going on to discuss how IronRuby and the DLR are implemented in .Net. The DLR is basically a layer for dynamic languages on top of the standard CLR, it is an abstraction of the what was developed in the course of getting IronPython up and running. At this point Dave admitted that IronRuby wasn't yet ready for use, so the rest of his talk would be about (C based) Ruby 1.8 - which IronRuby is targeting for compatibility. This was a bit of a disappointment for me, because really I was after a more practical demonstration of IronRuby than another presentation on Ruby - but it's possible I was in the minority given the audience. Check out the IronRuby website if you want to learn more.

Entity Framework (Presentation) James Winters - I had no idea what this was before the talk, but the title sounded more interesting than the others available in this slot, and it saved me leaving the room when I knew I wanted to see the talks either side. In the event, I was glad I stayed. To give a simple sound bite - Entity Framework is like an ORM on steroids, which will allow transparent mapping to non-relational stores, such as LDAP, as well as the more usual SQL stuff. The plan is for all MS server products to move to Entity Framework for their data access, though at the time of the talk the only backend available was SQL Server and all the examples were basic ORM stuff. The logical model of Entity Framework is made up of three levels:

• O-SPACE - the object model, eg. LINQ
• C-SPACE - the conceptual model, eg. Entity Client
• S-SPACE - the store - eg. ADO.Net.SqlProvider

All levels are scoped by an entity container, which defines a namespace and an object model, and the goal of the MS Visual Studio team is to be able to generate the lower levels using visual tools.

Entity Framework supports multiple querying methods:

• ESQL - very similar to HQL in Hibernate
• Object Query - a generic object interface with caching and lazy loading, which can either be read only or mergeable
• Use Entities directly
• LINQ

There are some limitiation, there is no locking by default and, while it's going to be possible to map stored procedures the visual tools aren't going to support it for some time so you have to write up the XML manually. Generally, though it has a slight whiff of the architecture astronaut, it looks like an interesting addition to the .Net toolbox (Slides available here).

Why do I need an Inversion of Control Container? (Presentation) Mike Hadlow - I'd heard of Inversion of Control (IoC), but hadn't really understood what it was for. The presenter, Mike, had been in a similar position until he started studying it seriously, and now he was here to share his epiphany. The main problems IoC is trying to address is that the relationship between component size and complexity is not linear - double the size of your components and you quadruple the complexity - but breaking components into smaller pieces tends to lead to increased dependencies. Inversion of control reduces the complexity of large components and manages the dependencies between them. The principals of inversion of control (paraphrased from Robert Martin) are:

• High level modules should not depend on low level modules
• Abstractions should not depend on details
• Details should not depend on abstractions

Typical problems of OO code without IoC are:

• Difficult to unit test
• Tightly couple components
• Violates the single responsibility principal
• Violates the open/closed principal

Inversion of control helps with all these by allowing constructor injection and property injection. If these can be injected into components at runtime, rather than hard-wired into the components, then it becomes possible to modify the behaviour of components without having to modify the components thus satisfying the open/closed principal and reducing the coupling (property injection) and also to easily mock objects for unit testing (constructor injection). Mike then moved on to some detailed demonstrations using the Windsor component from the Castle project, before concluding that IoC is really just the thorough application of design patterns and other OOP best practices. Therefore you should only start considering inversion of control once you're already familiar with these and have already implemented things like unit testing (Slides available here).

Dynamic Languages on .NET (Presentation) Michael Foord - My first session of the afternoon and by this point I was flagging a bit after having to get up early and make the trip out to Reading. Michael is one of the authors of Resolver, a spreadsheet based application environment, aimed at the financial markets and written in IronPython. The app is approximately 30000 lines of code, thus refuting the myth that it's impossible to write large applications in a dynamic language, and it's spreadsheet model is implemented in a Python hash table, making it very easy to extend Resolver with new types and operators. After a discussion of what constitutes a 'dynamic language' and the overall benefits of Python and IronPython in particular, Michael moved on to some practical examples based on his IronPython Web IDE (Slides available here)

Testing Your Applications With MbUnit Gallio (Presentation) Ben Hall - unit testing is a popular topic on programmer blogs these days, and this was reflected in a fairly full room for one of the 'minor' talks (ie. we weren't in one of the big rooms). Ben covered some best practices of automating unit testing on .Net with MbUnit and Gallio, starting at the database layer (use transactions and rollbacks or COM+ transactions), the business object layer (mocking and inversion of control) and the user interface (don't try and automate it!). An interesting if slightly hurried talk which I was unfortunately too tired to pay full attention too (Slides available here)

Overall a good day, I definitely learned more than one new thing per talk and the Microsoft conference room facility is a good venue for these sorts of things, so 4 out of 5, and I'll almost certainly try and get to the next one.