The Creation Engine No. 2

BL:AM

2023-10-07T19:00:00+01:00

After The Spirit of Gravity in February I ended up talking to Jason Hotchkiss and Jo Summers. I knew Jason from a Build Brighton guitar pedal workshop years ago and as a sound artist from Sound Plotting, but Jo knew Jason as the game developer who made 1D Pong. After talking about 1D Pong and another 1D dungeon crawler we started thinking about the most ridiculous 1D game we could imagine in 2023 and settled on 1D, 1 button battle royale.

Normally that’s where the story would end, but for some reason the idea kept rattling around in my head and eventually I ended up putting my thoughts down in a Google Doc and started thinking about how to make it happen.

To be a battle royale the game had to be multiplayer with players on a shared map trying to shoot each other, but a 1D display meant the gameplay couldn’t come from aiming. Judging the distance to shoot by charging and launching a missile solved this problem and provided a fun core gameplay loop which could be implemented with a single button. Hold the button to charge the missile then release the button to fire a distance dependent on the time the button was held.

With the button used for shooting, moving players around had to rely on another key feature of battle royale games: the shrinking map. The game would start with a large map filling the display and would position players randomly as they joined. Periodically the map would shrink and randomize the player positions within the smaller play area. This would create a natural tempo increase in the game as players would move closer together, so players could fire shorter distances and so fire more often. Eventually all the players would be next to each other, so just tapping a button would always result in hitting a player, ensuring the game came to a swift end.

Jason had already suggested the Raspberry Pi Pico as a potential hardware platform, so I built a prototype as a Linux terminal application which outputs frames as lines of ASCII to quickly test the design in a way that might be easy to port. The first prototypes were surprisingly fun. Some tweaking of the map resize period gave good players enough time to range-find long distances while not making weaker players wait too long if they were a long way from the action. As the map got smaller the action got more frantic before ending in a flurry of button mashing as planned.

The slow pace at the start gave players enough time to learn how to play, but could feel frustrating when all the targets were at the other end of the map. A solution came by adding loot boxes, another feature common to battle royale games. Scattering loot boxes across the map meant players would always have something nearby to shoot, helped maps feel more varied and provided a way to add depth via power-ups and another way to move around via teleporters.

Loot boxes also added another interesting gameplay choice: should I try to snipe an opponent immediately or get tooled up first? The initial design always fired missiles at the nearest target, which Jo highlighted as a problem as it meant you couldn’t always pick your target. An easy solution was to alternate the direction of fire. Just tapping the button meant players could quickly launch a missile in the wrong direction before getting back to carefully charging a shot to fire in the right direction again.

After playtesting the software version at The Brighton Indie Gamedev social, I was convinced that the game was fun and started thinking about hardware. I expected it to be a lot of work to get running on the Pico, especially as I’d allowed myself to joyride some relatively new C++ features like lambdas and auto parameter types, but g++ happily took my fancy code and cross compiled it without any complaints. I could also use PuTTY to connect to the Pico as a USB serial device to see the ASCII output, which was incredibly useful while testing the hardware without the LED display and then for debugging problems while getting the display working.

I ended up with a hardware main function (which wired the inputs up to the Pico pins and redirected the output to the USB serial interface), a terminal main function (which used some hacks to get unbuffered keyboard presses) and renderTerminal and renderRgb methods implemented by the game objects. The rest of the code was shared between the two builds, allowing me to quickly develop, test and debug the game using VS Code and gdb, then cross compile and drag a binary to the Pico mounted as a USB drive.

In May I got the chance to play 1D Pong at Jason’s studio which made me realize how important audio is when you only have a 1D display: the sounds of balls bouncing off bats and points being scored did a lot to explain what was going on, so I started thinking about adding sound to 1D battle royale. The Pico doesn’t have a digital to analogue converter, but some experimentation showed that it can generate some gloriously grungy sounds by using pulse width modulation to play samples using one of the digital outputs. After aggressively compressing some of ProjectsU012’s arcade sounds and converting them to 8 bit samples stored in header file arrays, the game came to life. Instead of being a quirky, abstract 1D game it was a battle royale complete with missiles whooshing and exploding and players powering up and teleporting around.

I haven’t made a game in a long time and I’ve never made a hardware game, so this project has been a lot of fun. It’s also something that I couldn’t have done without Jason, Jo and everyone at the Brighton Indie Gamedev socials: thank you to everyone for your help and feedback.

“Battle Lines: Arcade Machine” (BL:AM) was included in the Pop Up Arcade at the Dreamy Place Festival in Crawley in October 2023 where I had lots of fun playing it and talking about the design and development. You can find more gameplay footage here.

How (Not) to Build a Metaverse

2022-10-05T22:27:00+01:00

Earlier in the year I helped Josh Sanburn and his team put together a podcast series on building Second Life for the Wall Street Journal called “How To Build a Metaverse” which I’m now really enjoying. It’s great to hear all of the amazing stories about the origin of Second Life told by some of the most amazing people I’ve ever worked with, but the stories I’m enjoying the most are the stories I hadn’t heard before.

An incredible example from the most recent episode is the story of how Second Life’s moderation began. Peter Alau tells the tale of how he cribbed together a 20 paragraph Terms of Service using examples from other virtual worlds before Philip stepped in and mandated that the terms of service should be “Be Nice”.

My life was changed forever when I read Julian Dibbell’s article “A Rape In Cyberspace” while working on the literature review for my PhD in Persistent Virtual Environments at the University of Nottingham. The article made me realize that virtual worlds were not just a collection of interesting technical challenges, but that they could become real, meaningful communities and that the people who met in them could be hurt, just as they can in real life. Reading Dibbell’s article made me want to work on commercial virtual worlds that enabled those real human communities rather than experimental worlds that only existed as technical proofs of concept. I left academia, started working in the games industry, and quickly found the Terra Nova group blog that Julian Dibbell was contributing to along with Cory Ondrejka, the CTO of Linden Lab.

Given the path that led me to Second Life, I was saddened to hear that the origin story of moderation in Second Life didn’t mention it. Peter should have known that people wouldn’t read his epic Terms of Service, but at least he tried to apply best practice. “A Rape In Cyberspace” was already 10 years old when Second Life launched and Linden Lab were talking to many of the pioneers who worked on early virtual worlds. Philip should have known better, but pursued a wishful, naive approach to moderation and Second Life ended up learning a lot of lessons that had already been learned the hard way.

This wasn’t the only occasion that Second Life’s design was optimistic, naive and didn’t give enough thought to how it might be abused by bad actors. When I first visited San Francisco I hosted a party on Russian Hill to get to know my colleagues only to end up huddled in the living room with other engineers battling a plague of grey goo spreading across the grid that was enabled by an over-permissive API. The API allowed scripted objects to self-replicate and so exponentially overwhelm regions until firewalls of shut down simulators limited the spread and space lasers were able to delete scripts to purge the world of the menace. Shortly after I returned to the UK I woke up one morning to my first encounter with the infamous Goatse image which a resident had pasted across the world so that it would show up on the live map that had been naively been added to the front page of secondlife.com without enough thought about how it might be abused.

Eventually Second Life’s moderation policies and processes got to a good place (Robin Harper was one of the people I spoke to about best practices for moderation when I was working on building safety into Oculus Venues) but the story of how moderation began in Second Life is one of missed opportunities. We shouldn’t just laugh off Second Life’s failings as the stories of swashbuckling hackers while at the same time pointing fingers at the similar failings of the current efforts to build a Metaverse. Multi-user virtual worlds were already 20 years old when Second Life was built and many lessons had already been learned.

“How To Build a Metaverse” is incredibly entertaining and illuminating, but this part of the story is a good example of how not to build a metaverse. You can’t just read the fiction about virtual worlds and ignore the non-fiction. You can’t just talk to people who built early virtual worlds or hire them: you have to actually listen to them and apply the lessons they learned.

Virtual Worlds, Real People

2022-03-17T12:00:00+00:00

Last week I gave a lab talk to my former research colleagues at the Mixed Reality Lab at the University of Nottingham about the work I’ve been doing since leaving the lab over 20 years ago. Rather than talk about technology I focussed on the lessons that todays efforts to build the Metaverse can learn from virtual worlds of the past and the lessons that the real world might be able to learn from virtual worlds of the future.

I’d like to thank my former PhD supervisor Professor Chris Greenhalgh, Professor Steve Benford and everyone else at the MRL for a great discussion and for making me feel very welcome.

Virtual Objects You Can Touch

2021-08-26T14:26:00+01:00

Now that Horizon Workrooms has launched I’m very happy to be able to write about the functionality that I found most exciting while building the experience: the mapping of virtual objects to their real world counterparts.

Typically augmented and mixed reality experiences overlay real world objects with virtual annotations. An AR app on your phone might recognize a face seen by the camera and show the face with added bunny ears on the phone screen, for example. Workrooms is different in that it shows you an entirely virtual environment, but asks you to indicate the position of real world objects like your desk in a process which feels like a more detailed guardian setup process. Workrooms then positions your avatar in the virtual world so that your real desktop aligns with your virtual desktop. When you reach out and touch the virtual desk your hands touch the real desk. As long as the important virtual objects within arms reach are mapped to real objects, the virtual environment can be much bigger than the available real space while maintaining the illusion that every virtual object can be touched as well as seen.

In addition to adding to the immersion and realism of the experience, the haptic feedback has important practical benefits. Typing on a virtual keyboard is much easier if you’re also typing on a real keyboard rather than on a flat featureless surface or just moving your fingers in space; it is much less tiring to draw on a virtual whiteboard if you are also leaning on a real wall and it’s much less dangerous to show someone a virtual desk if leaning on it or putting a coffee on it doesn’t result in you falling over or spilling coffee on your feet. While requiring a suite of real objects to be available puts some additional constraints on using the application, the required objects are common enough in the case of Workrooms that the trade off is often worthwhile and less onerous than requiring the use of specialised additional VR hardware to provide much lower fidelity haptic feedback.

Mapping real objects to virtual objects can also go beyond providing haptic feedback by being used to provide a very natural indication of intent. Moving from a seated desk to a nearby wall in the real world can be used to indicate to an application the intent to use a whiteboard and might result in teleporting in the virtual world to a whiteboard location much further away, allowing people to navigate virtual spaces which are much larger than the available space in the real world.

Using real objects that can be touched shifts the problem of providing haptic feedback from one requiring complex mechanical force feedback devices to one that, in future, would use computer vision to recognise objects in the real environment using the same cameras that provide inside-out tracking capabilities in modern VR headsets. By using virtual objects that map exactly to their real counterparts the haptic feedback provided would be perfect. A real MacBook keyboard feels exactly like a MacBook keyboard when you touch it because it is a MacBook keyboard, whereas any force feedback device trying to synthesize the same haptic feedback could only ever provide an approximation.

While the relative ubiquity of home offices means that this mapping approach lends itself to an experience like Workrooms, it’s also exciting to think about how similar approaches could be used to add perfect haptic feedback to less mundane VR experiences in more fantastic virtual environments. The Workrooms team was lucky enough to see some of those possibilities during a team offsite to the Star Wars VR experience at the Void in London. The experience created the illusion of a large virtual environment using a much smaller real space by using tricks like having participants moving through a real doorway into a virtual elevator and then later exiting through the same doorway to a new virtual room once the elevator had virtually moved to a new floor in the virtual environment.

With the increasing availability of headsets which use SLAM based inside-out tracking and the development of techniques like redirected walking, it’s possible to imagine a future where rather than defining a safe cuboid within the real world, guardian systems could instead map an entire home or office, identifying doors, chairs, tables and other objects which could be enumerated via an API to VR applications. The application could then use the available real world features to generate huge custom fantasy environments in a rogue-like game in which every wall and table can be leant on, every door can be opened and closed, every chair sat in and potentially every staircase climbed. I’m very excited to see, hear and touch the experiences these techniques might enable in the near future.

The Art Of Social VR

2021-02-03T23:25:00+00:00

The recording of my recent Stereopsia 2020 talk about the art of designing social VR experiences is now online. The talk summarises a lot of material covered in more depth in my posts on The Conversation Around Content, A Tall Dark Stranger and Small Places Loosely Joined, so if please read those posts if you would like to learn more.

The current situation made it impossible to host the normal Stereopsia conference, but also created the opportunity for a conference on immersive technologies to be held in a multi-user immersive experience for the first time and also made it possible for me to take part. I’d like to thank Ricard Gras for inviting me to talk and for everyone at Stereopsia for making me feel very welcome.

A Past And Present Future Of Work

2020-09-30T16:51:00+01:00

Over the last few years I’ve spent a lot of time helping people new to virtual worlds learn how they work. Over the last few weeks I’ve been sharing a series of short posts on some of the high level concepts I covered which will hopefully be useful to other people new to virtual worlds. The previous post talked about how you can structure the world so that everyone can move around easily to find everything that they want. This post talks about how virtual worlds can become the workplace of the future.

Not long after joining the Oculus Rooms team a couple of years ago, I first heard Michael Abrash talk about his dream of a virtual office where he could collaborate with colleagues from around the world in VR. My immediate thought was that of course this would happen: I had already done it very successfully for years. This note is an attempt to distribute that past future more evenly.

When I started working at Linden Lab in 2005 I was living in the UK and working from home. After a day of hacking on Second Life‘s server infrastructure I would spend several hours every evening in Second Life working with my colleagues who were in San Francisco in real life.

One of the first engineers to arrive at the San Francisco office was Zero Linden who was a big fan of pair programming. As soon as he was online we would meet in our virtual office where our avatars would sit next to each other and we would discuss software architecture and test cases in Second Life while we used a shared editor to hack on C++ or Python in another window . Over time we started using our virtual office space to host office hours for other engineers with questions about the Second Life server and our initially spartan virtual office grew to include experiments in using Second Life to visualize our work and parts of the Second Life software architecture.

After an hour or so of pair programming with Zero to hand off the code I’d been working on during the UK daytime, other Lindens would start arriving at the San Francisco office and we would start using Second Life for larger scale team meetings. Even without tracked headsets, the 3D positional audio and instantly recognizable avatars made these meetings more successful than video conferencing. Because everyone was in Second Life together I felt far more present than I typically do using video conferencing to join a meeting in Menlo Park as the lone participant in London. Everyone was an equal participant in every meeting.

I expect this to be a common model for collaboration between remote workers in VR: the virtual space provides a forum for communication, conversation and annotation while existing applications, editors and tools are brought in to VR to provide familiar and powerful ways to create content together. I’m particularly excited about the possibilities for people to collaborate on very complex problems at the limit of human comprehension like large scale software development which are often hard to discuss in real life, but possible to visualize, understand and explore together in VR.

While the creators of virtual worlds are likely more open to meeting in them than average, I can imagine many people with remote colleagues also being open to using virtual worlds to allow everyone to contribute more effectively in team meetings. Virtual worlds will be especially valuable in meetings which require a lot of media presentation or recording as that can be more easily automated than in real life.

As Linden Lab became more international with offices in Brighton and Singapore we started holding regular company all hands in Second Life. While these were often plagued by technical troubles due to the high attendance pushing the software to its limits, they were also great opportunities for remote employees to meet people they might not have seen for months and for serendipitous conversations to occur in the hallways outside the conference rooms, just as they do in real life.

This is also a use case I expect to become important in VR and something that is already better supported by Oculus Venues than it was in Second Life. After attending OC3 and OC4 in person I was disappointed that I couldn’t justify the time away from my family to attend Oculus Connect 5, but delighted that I could attend in Oculus Venues where I had a better view of Hugo speaking on stage than I’d had in real life. I am sure that VR can enable myriad opportunities for networking and serendipitous conversations which don’t happen when people just catch up on conference talks on YouTube.

After working for years both on and in Second Life it is clear to me that using VR for work collaboration is both very valuable and very possible. It’s also clear that there is a lot of overlap between the social and work opportunities for VR. The Linden Lab all hands in Second Life looked a lot like the Accelerating Change conference in Second Life. The office hours held for Linden Lab engineers were so successful I started holding office hours for people building in Second Life. The time I spent working with Osprey Therian on Combat Cards in Second Life was just as rewarding and productive as the time I spent with Zero Linden working on scripting APIs. A lot of the most valuable use cases for VR will combine work and fun and we should beware false dichotomies. Any Metaverse worthy of the name will be both the future of work and the future of fun.

Small Places Loosely Joined

2020-09-23T16:51:00+01:00

Over the last few years I’ve spent a lot of time helping people new to virtual worlds learn how they work. Over the next few weeks I’m sharing a series of short posts on some of the high level concepts I covered which will hopefully be useful to other people new to virtual worlds. The previous post talked about how you can make sure everyone can create an avatar representation that they feel properly expresses them within a virtual world, this post talks about how you can structure the world so that everyone can move around easily to find everything that they want.

Second Life always aspired to be the Metaverse, but in the beginning it was more like a neighbourhood. The first regions were named after streets in SoMa and, like the district in San Francisco, people took walking tours from one corner of the world to another, flew biplanes across the sky and sailed on the simulated winds around the bay. However you decided to travel in the early days you could see the whole world in a few hours, so Philip Rosedale became very excited when he realised one day that the constant tsunami of content generated by Second Life’s residents had grown so large that the world was changing too fast to see everything.

As the Second Life continued to expand and change at an ever faster rate it became increasingly important to have ways to find the good stuff. Bookmarks, searches and external blogs indexed the expanding world helping people find things. Rather than walk, fly or sail around the world people would teleport from place to place or event to event. Even if you wanted to walk it became increasingly hard to do so: more and more parcels of land became private, restricting entry to both people and any scripted fish unlucky enough to try to swim across the boundary.

While you could still plot every parcel on a map which grew to the size of Denmark and looked like a huge series of fjords, as more and more people wanted a beach front property, the world effectively became a graph of experiences which people teleported between. The seamless, endless world that descriptions of the Metaverse conjure up and that Linden Lab aimed to build ended up being a graph of bite-sized experiences linked together like a web.

Technologically, Second Life also began to split at the seams. The addition of Second Life URLs (SLurls) allowed blogs to link to locations in Second Life and people increasingly wrote scripts which published out to the web and Twitter or pulled data in from the web to visualize in 3D. A lot of people would keep a browser tab open showing the presence information published to the web and would teleport to their friends as soon as they saw them come online. Developers wrote applications on web servers which used Second Life scripts just to build user interfaces so they could escape the limitations of the in-world scripting platform. People captured 3D geometry sent to their graphics cards to provide 3D printing services or circumvent in-world DRM to produce knock-off virtual goods. Companies like IBM lobbied Linden Lab for legitimate ways to host their own private regions while open source developers forged ahead to produce alternative clients and servers that anyone could run. Despite much concern, these efforts mostly provided developers with more convenient development sandboxes: the content, community, conversation and commerce stayed on the Linden Lab hosted grid.

Towards the end of my time at Linden Lab there was a push to standardize these efforts and make it possible for experiences run by different organisations, potentially on different technology stacks, to inter-operate. For people to teleport not just between regions, but between organisations taking their appearance and inventory of clothes, animations, and interactive objects which defined their identity with them. This was a big deal, so it was incredibly encouraging to see some of the earliest experiments in social VR at Oculus try something similar by linking Oculus Rooms to other experiences via coordinated app launch (CAL). While the first CAL implementations linked Oculus Rooms to a fixed set of published experiences it’s easy to imagine people using similar technology to build environments which link to their favorite locations around the Metaverse just as early web sites curated links to favourite content around the web.

When we think about the Metaverse it is easy to jump to images of endless wonders teaming with multitudes stretching to a distant horizon. Linden Lab dreamed similar dreams and went to extraordinary lengths to make Second Life appear seamless, but much of that effort could have been more profitably spent enabling a universe of small places, loosely joined. Several social worlds that followed Second Life including Metaplace, Whirled and Linden Lab’s own Sansar all learned this lesson by building collections of linked experiences rather than a single space containing everything. Linking experiences also makes it easier to support requirements like IBM’s need to host their own servers, build experiences which require custom clients to support new or specialized hardware or weave existing applications which may have been built on different engines into a broader Metaverse. As we think about building new Metaverses, it’s important not to just think about how we can bring everything into our worlds and make them stretch out to infinity, but also about how to connect experiences and technologies together and allow people to move and connect between them.

(Second Life screenshot: Ella Pinellapin)

A Tall Dark Stranger

2020-09-16T21:51:00+01:00

Over the past few years I’ve spent a lot of time helping people new to virtual worlds understand how they work. Over the next few weeks I’m going to share a series of short posts on some of the high level concepts I covered which will hopefully be useful to other people new to virtual worlds. The previous post talked about ways in which you can fill an entire world with things to keep everyone interested forever. This post talks about how you can make sure everyone can create an avatar that allows them to fully express themselves within a virtual world.

Professor Richard Bartle, the co-creator of MUD1 and networked multi-user virtual worlds in 1977 is fond of saying that he prefers text-based virtual worlds because the graphics are better. Just as a good book can conjure vivid images in the mind, text can conjure images of worlds which would be hard or impossible to render with triangles. Another huge advantage of text-based worlds is that it is far more common for people to author text than to create 3D art assets. If I want to be a tall dark stranger in a text based world it is as simple as setting my description to those words. If I want to be a tall dark stranger in a VR environment it is much harder.

Where a virtual world has a clearly defined setting such as high fantasy, space opera or tropical pirates it can be feasible to supply a wide enough variety of faces, bodies, clothing, accessories and hair styles. This is the approach taken successfully by EVE or Rare with the infinite pirate generator and results in a wide variety of avatars which are all thematically consistent with the world. If you are building a Metaverse which connects every possible virtual world how do you start? How do you please the person who wants to have the perfect tall dark stranger avatar rendered in 3D as well as everyone else?

This was the challenge facing Linden Lab when building the avatars for Second Life at the turn of the millennium. While the default avatars could be manipulated into a huge variety of shapes and sizes using the available parameters, the results were often crude and the available wardrobe never strayed far from geeky teen hangout chic. Luckily for Linden Lab the inability of the avatar system to satisfy every whim was a huge opportunity for the entrepreneurs of Second Life.

Builders quickly realized that they could fashion shoes, hair, clothes and accessories from primitive 3D objects which could be attached to avatars to dramatically increase the gamut of styles that could be realised. Linden Lab enabled another wave of innovation by allowing animations to be uploaded which as well as allowing every conceivable dance move to fill the nightclubs of Second Life also enabled tiny avatars which either folded up the default avatar geometry inside cutely sculpted animal models or moved the default avatar under the floor so it was completely hidden and just served as a platform for a tiny replacement avatar standing on its head. Many years later Linden Lab finally allowed people to entirely replace the default geometry and textures so now it is common for not a single triangle or texel in a Second Life avatar to have been defined by Linden Lab.

People were welcome to build their own clothes and avatars from textures and geometry, but the vast majority instead chose to buy and combine pieces from the vast array of builders who were paying their real life rent by selling virtual goods and so were more than happy to cater to their every desire. If you wanted to be a tall dark stranger there were a huge number of them to choose from. If you wanted to combine a punk jacket with a tutu to create a unique and look you could do that without ever opening photoshop.

People chose to be robots, punks, steampunks, wizards, astronauts and chose looks from across every conceivable genre of art, fiction and real life fashion scene. Conversations about where people found clothes or accessories became common, people went shopping for clothes together, attended and hosted fashion shows or reported on them in social media, just like in real life. Avatars and fashion became important content around which conversation would form.

Second Life in general accepted this riot of self expression with open arms. IBMers attended a company all hands talk by their CEO in Second Life as aliens in suits among a variety of other things. While a few areas enforced dress codes or handed out attire which would match the theme of their experience, most of the time this was optional. Avatars were seen as a very personal form of expression which people building experiences would respect and not constrain. Some people would revel in this freedom by changing between avatars and identities frequently and on a whim, but in general the more well known someone became in Second Life, the more useful having an immediately recognizable avatar became, the less frequently they would tend to change their avatar and the more onerous being asked to change their appearance in order to fit in with an experience became.

We should bear these lessons in mind as we think about avatars for the virtual worlds of the future. While default avatar styles should be comfortable for a wide audience of people and acceptable for developers building a wide range of experiences, we likely also need to allow people to easily create everything from clothes and virtual personal electronics to blend shapes and eye movement simulation models and the services to allow people to buy, sell and police virtual goods and take them wherever they go across the Metaverse. Ultimately the developers of a successful Metaverse shouldn’t need to define avatar styles: the virtual fashion industry they enable will.

(Second Life screenshot: Ella Pinellapin)

The Conversation Around Content

2020-09-09T21:51:00+01:00

Over the last few years I’ve spent a lot of time helping people new to virtual worlds learn how they work. Over the next few weeks I’m going to share a series of short posts on some of the high level concepts I covered which will hopefully be useful to other people new to virtual worlds. This first post talks about ways in which you can fill an entire world with things to keep everyone interested forever.

Whenever I visited Linden Lab’s San Francisco office while I was building Second Life there was always a copy of Snow Crash in the restroom. We were definitely building the Metaverse and so there was much excitement when one of our colleagues met Neal Stephenson and asked what he thought of Second Life. Neal commented that he didn’t expect a company to set out to build the entire Metaverse, he thought it would be more interstitial. Over a decade later I think Neal’s comment is very relevant as several organisations contemplate building the Metaverse.

Oculus currently provides content, but the conversation happens elsewhere. Some people enjoy content in Oculus Venues and then go to Oculus Rooms to hang out afterwards, but most of the conversation happens on sites like Reddit and Facebook. Oculus provides content but the spaces where the conversation happens exist on the web.

Successful Massively Multiplayer Online Games (MMOs) provide content as well as space for conversation. Games companies typically spend years creating content which is voraciously consumed within a few months. It is typically impossible to build content as fast as it is consumed, so it is crucial that the content promotes communication between players so that relationships form and the world becomes a forum for conversation. The model is similar to a virtual theme park: it is impossible for people to continuously ride on new roller coasters all day and so the park around the rides becomes important. Disneyland is the conversation in the queue as much as the ride itself. Games companies hope that by the time people have completed all the quests, they have made friends and that the virtual world is the natural place to continue to hang out with those friends.

Unlike static theme parks, some MMOs provide a more open sandbox which allows people to have a bigger impact on the world and so define more of the content themselves. A good example is EVE which allows players to build enormous empires via trade, industry, conquest and espionage. The continuing power struggles fuel a rich continuing conversation around the player created content and a history which is just as real as any other human history.

Other virtual worlds like Second Life rely almost completely on user generated content. Linden Lab builds a software platform, rents out virtual space and provides customer services, but builds very little content itself. In the early days of Second Life content creation was itself the content around which conversation formed. People would build in virtual sandboxes and others would swing by to see what they were building and ask how it was done. As more people began creating content it quickly became impossible to see everything, which enabled more content and conversation as people shared their favourite spots, curated exhibitions and shared links on the web.

Each of these approaches has advantages and disadvantages. The traditional MMO approach provides accessible, high quality content and builds community around it, but has to focus on broad, mainstream tastes to ensure that the limited content appeals as broadly as possible. It results in a theme park full of content that appeals to lots of people for a limited amount of time. Even with the resources to appeal to every taste, would a Disneyland punk rock club really be punk? The sandbox approach creates a much greater feeling of ownership, investment and constant evolution, but while Burning Man is an impressive achievement it’s not clear that many people would want to live there all year.

If you’re thinking about building the Metaverse can you learn lessons from the past to build an appealing space for as broad an audience as possible? Can you build somewhere with a core of high quality, broadly appealing commissioned content surrounded by a constantly changing vibrant fringe of more niche experiences like the Edinburgh Festival which people can safely explore? Can you provide space for content, conversation and commerce which allows people to be heroes, protagonists and entrepreneurs as well as visitors to a theme park? Can you leave the right spaces around our content for people to contribute comments, conversation, curation, communities, collaboration and commerce? Can your Metaverse support services in the spaces between the content just as services grew in the interstices in the web?

(Second Life screenshot:Ella Pinellapin)

HTTPS

2020-09-08T17:41:00+01:00

Before my recent post about leaving Facebook, it had been a while since I’d updated The Creation Engine and it turned out I had some housekeeping to do. After pushing the Pelican output to https://github.com/jimpurbrick/jimpurbrick.github.com I got a mail from GitHub saying that I needed to update the jimpurbrick.com DNS records to point to a new set of IP addresses and while doing that I noticed that GitHub now supports HTTPS for GH-Pages hosted sites.

After the DNS changes had propagated I loaded up https://jimpurbrick.com and saw that a lot of the styling was broken. The issues tab in Chrome’s Inspector revealed which resources were still being loaded over HTTP and it only took a few minutes editing the Pelican configuration and some of the templates to make the site use relative links and load externally hosted images and CSS over HTTPS.

A few minutes after that the changes were pushed to GitHub and https://jimpurbrick.com loaded without any broken styling or HTTPS issues in Chrome inspector and with a reassuring padlock in the address bar. While it’s unlikely that serving a personal static blog over HTTP would have caused any problems with eavesdroppers or man-in-the-middle attacks, I’m happy about being a good citizen and promoting safe and secure habits on the web.

0 to 1

2020-08-20T14:09:00+01:00

8 years ago London was hosting the Olympics and I met Philip Su for the first time at Browns in Covent Garden to talk about the engineering office Facebook was planning to open in London. By the end of this year Facebook London will have thousands of people working in technical roles. It was an amazing ride.

Along the way I was lucky enough to work with some incredible engineers to help build numerous things that I would have considered impossible 8 years ago: a static analyser which defies the halting problem to finds bugs in massive code bases in minutes; immersive multi-user VR experiences that support hundreds of mutually aware people running on a mobile phone strapped to your face and a working siege engine built overnight on the roof of a castle.

8 years on it feels like mission accomplished. Despite the incredible recent events, I can’t remember the last time I heard anyone question the future of Facebook London engineering: I can move on and it will continue to succeed without me, so that’s what I’m doing.

Recent events have also made me think more about where I want to spend my time. In the near future I’m going to spend more time with my family and friends in Brighton, more time supporting XR, more time making music and software and then, eventually, some time thinking about what comes next. If you’d like to make some music or software with me, let me know.

This blog is 10

2018-07-02T20:12:00+01:00

Just over ten years ago I set up The Creation Engine No. 2 after previously blogging on the original Linden Lab hosted Creation Engine and before that on Terra Nova. So, while I’ve been blogging for almost 14 years, 10 years of The Creation Engine No. 2 seems like a good excuse to look back at the last decade of blogging.

Behind the scenes the technology behind The Creation Engine No. 2 has changed a lot. Originally hosted as a Django site on Byteflow, I converted the blog to a static site generated by Pelican and hosted by github almost exactly 5 years ago. I wrote a post at the time detailing the move, which I finally published on its 5th birthday after rediscovering it today. Despite the big changes behind the scenes, github’s support for custom domains and Pelican’s support for RSS import meant that the only externally visible changes to The Creation Engine No. 2 were cosmetic. All the RSS feeds and links to the site were unaffected, which is great because Cool URIs don’t change.

While the technology has changed a lot, the content continues to mostly be a hack diary describing the various contributions I’ve made to projects like the EVE CREST API, nailgun, buck, infer and ReactVR. I write these posts as documentation in case I have to solve similar problems in future, but it’s also great when they’re useful to others, so I’m very happy to see that my recent set of posts about using ReactVR with Redux have been my most popular posts to date.

I don’t attend as many conferences now as I did while I was working at Linden Lab, but the various conference write up posts serve a similar purpose: reminding me about the talks and speakers I’ve seen and hopefully also pointing others to useful information. Social media is now more effective for letting people know about future events, so I rarely use The Creation Engine to announce upcoming events, but still think its a useful place to collect longform thoughts about past events and links to recordings.

One post which doesn’t fit in to the above catatories is my review of Now We Are 40 and thoughts on growing up with the web. Part of the reason I posted it here is because I could. I don’t need someone to speak for me or my generation, I can do it myself. I’m very grateful that I’ve been able to share my thoughts with the world for the last decade and very happy that a lot of people have found them useful.

Happy birthday to The Creation Engine No. 2. Here’s to the next 10.

Replicated Redux: The Movie

2018-05-22T11:30:00+01:00

The recording of my recent React Europe talk about Replicated Redux is now online and I’ve written several other posts describing designing, testing and generalising the library if you would like to know more about the details. If you’d like to play the web version of pairs or see the rest of the code, it’s available on github here.

People often describe multi-user networked VR experiences as laggy, but code to hide latency by optimisticly predicting the effects of local actions is hard to write, difficult to test and often application specific. It feels great to have helped make this problem a little easier to solve for React developers by building Replicated Redux.

Replaying Replicated Redux

2017-11-10T22:56:00+00:00

While property based tests proved to be a powerful tool for finding and fixing problems with ReactVR pairs, the limitations of the simplistic clientPredictionConstistenty mechanism remained.

It’s easy to think of applications where one order of a sequence of actions is valid, but another order is invalid. Imagine an application which models a door which can be locked: an unlock action followed by an open action should be valid, but an open action followed by unlock should be invalid given a starting state where the door is locked. It’s a lot more difficult to imagine how every ordering of this simple sequence of actions can be made either valid or invalid.

The limitation of clientPredictionConsistency is caused by the master client having to see an invalid action before it notices that clients need resyncing. An obvious way to avoid this limitation would be to have all other clients let the master know if they have seen an invalid action, but this solution becomes more complicated when you want to avoid the master sending duplicate sync actions if multiple clients report invalid actions simultaneously.

At this point, I took a step back: even if clients could report conflicts without duplicate resyncs, the improved clientPredictionConsistency would centralise conflict resolution in the master. Clients receiving a state sync action would have no context on the conflict and so would be unable to do anything more than reset their local state. Reusing the state sync mechanism which allows late joining is simple, but doesn’t allow anything more than effectively rejoining.

One of the nice things about Redux actions is that they are more meaningful than either UI events or state updates: it would be nice if clients could use the context they have in the actions to resolve conflicts and reconcile optimistic updates with authoritative actions gracefully. This made me think of the optimistic update mechanism used by Half Life which keeps a list of actions which have been predicted locally and reapplies the predictions to new states received by the server. Redux was built to easily support this kind of time travel through application history, so I wondered whether something similar could be built for replicated redux.

Some hacking on these ideas produced replayConsistency: a generalisation of the Half Life optimistic update ideas applied to arbitrary Redux actions. When a non-master client generates a valid local action it is sent to the master, immediately reduced locally, but also appended to a list of predicted actions. When the client recieves a new action from the master it rewinds the state back to the start of the prediction, applies the new master validated action and then reapplies the predicted actions if they are still valid. Eventually every predicted action becomes part of the total ordering defined by the series of actions validated by the master and is sent back to the client, or the state which caused the prediction to be invalid on the master is reached on the client. In either case the prediction is discarded. In the case where a prediction becomes invalid, the client has the state before the prediction, the master validated action and the list of predicted actions available when updatePredictions is called. This context allows the client to do something significantly more sophisticated to fix the local state than simply reseting the entire local state. In fact replayConsistency does not need to send state syncs at all, making it significantly more efficient than clientPredictionConsistency which I renamed resyncConsistency to make the differences between the two optimistic consistency policies clear.

Switching out resyncConsistency for replayConsistency and eyeballing several games of ReactVR Pairs suggested that the new consistency mechanism was working as intended, but finding all of the kinks in resyncConsistency had required testing thousands of sequences of actions using property based tests. My existing tests didn’t apply here: they made sure that an application would work given the limitations of resyncConsistency. The property I really wanted to ensure held for all consistency mechanisms is that regardless of the predictions made at each client, eventually all clients would be consistent.

This test generates a sequence of pairs actions which might be sent by the master or one of two non-master clients and then checks that all clients are eventually consistent even in the pathological case where each non-master predicts all of its actions before getting any actions from the master. A nice feature of this test is that it is independent of the consistency mechanism and so the same test can be run to ensure that both resyncConsistency and replayConsistency result in all clients being eventually consistent for thousands of sequences of actions.

With my tests passing I had high confidence that replayConsistency was working and didn’t impose any limitations on event ordering making it a much more general and efficient solution than resyncConsistency as well as much easier to use as it doesn’t require complicated reasoning about application event ordering. The potential to perform sophisticated application specific state reconciliation when predictions are invalidated is also interesting and I’m excited to see what we can do with it in future.

If you’d like to play the ReactVR version of pairs or see the rest of the code, it’s available on github here.

All code in this post is made available under the ReactVR examples license.

Building Safety in to Social VR

2017-10-26T23:07:00+01:00

Last year I hosted a panel on creating a safe environment for people in VR with Tony Sheng and Darshan Shankar at OC3. I commented at the time that the discussion reminded me of the story of LambdaMOO becoming a self-governing community told by Julian Dibbell in My Tiny Life, so I was very happy to have the opportunity to compare the established and novel approaches to Building Safety in to Social VR at OC4 with Mike Howard.

While technology changes, people stay the same, so it’s important that we don’t lose the lessons learned by people like Julian, Richard Bartle, Raph Koster, Damion Schubert and the many others who have been wrestling with and thinking about these problems for decades.

Testing Replicated Redux

2017-07-31T20:29:00+01:00

Opening a couple of browser windows and clicking around was more than sufficient for testing the initial version of ReactVR pairs. Implementing a simple middleware to log actions took advantage of the Redux approach of reifying events to allow a glance at the console to reveal precisely which sequence of actions caused a problem.

Adding support for optimistic consistency made testing more challenging. In order to test conflict resolution, conflicting actions needed to be generated on multiple clients almost simultaneously. After a couple of sessions testing broken versions of pairs with friends it was clear that a more efficient process was required. Fortunately, Redux actions are independent of the UI events which generate them. This separation of concerns made it trivial to randomly generate and dispatch actions without driving the UI. Opening clients dispatching several randomly generated actions per second made it easy to generate conflicts to test optimistic consistency policies while watching games play out made it easy to eyeball the results to check that they were correct. This random action generation mechanism can be enabled by adding ?random as the query string when opening the Pairs example in a browser.

One of the problems found by this approach was that clients didn’t always end up eventually consistent. One client would end up with all squares shown and all pairs scored, while another would have some squares hidden. After some digging it turned out that in these cases the master would be reducing a hide action followed by a score action, while the other client would reduce the actions in the reverse order, causing the hide acton to be invalid. Without a way for a non-master client to let the master know about the conflict the master would not send a sync action and the clients would not end up eventually consistent.

This problem identified a limitation with the optimistic clientPredictionConsistency policy: if any sequence of actions causes a conflict then every ordering of those actions must also cause a conflict in order for the clients to end up eventually consistent. The fix for the hide-score case seemed clear: if the score action was only valid if the pair was shown then both orderings of those actions would generate a conflict and so the master would generate a sync action regardless of the order in which it reduced the actions. Some more eyeballing seemed to suggest that the problem had been solved, but a better way to test the property that sync action generation is independent of action order was to write a property based test.

Some Googling revealed that my Facebook colleague Lee Byron had written a JavaScript property based testing framework called test-check which was compatible with the Jest framework used by ReactVR tests, so I started hacking. I soon had a test which could generate an arbitrary sequence of actions, dispatch them and check that if the sequence of actions generated a sync action then dispatching the same sequence of actions in reverse would also generate a sync action.

I could now test that the property held for thousands of action sequences in a few seconds and so I found the next bug almost immediately. While my change to make any ordering of test then hide generate a sync had fixed one problem it had introduced another. The validity of score events was now dependent on the preceding show events, so it was possible for show-show-score to be valid but for every other order of those events to cause the score event to be invalid and so not reduced.

At this point I took a step back. The only situation that should cause a conflict that needs to be resolved is when more than one player tries to score the same pair. In this situation clients don’t have enough information to resolve the conflict and a master client needs to pick an ordering and communicate the result to the other clients. In the case of hide and score actions every client can do the right thing. Hide actions can be made to not hide scored squares and score actions can be made to show pairs. With the reducers changed to work in this way hide actions can always be reduced and score actions are only invalid when they conflict with each other. With these changes in place the validation logic becomes dramatically simpler to reason about and the property based tests were unable to find any more cases which would not be eventually consistent even after thousands of runs.

Testing distributed systems is hard, but combining replicated Redux with property based tests has proved to be a powerful way to gain a high degree of confidence that applications will work correctly despite limitations in the current simplistic clientPredictionConsistency mechanism. The same property based tests will enable new optimistic consistency mechanisms without those limitations to be developed far more quickly in future.

If you’d like to play the ReactVR version of pairs or see the rest of the code, it’s available on github here.

All code in this post is made available under the ReactVR examples license.

ReactVR Redux Revisited

2017-07-04T20:29:00+01:00

There were a couple of aspects of my previous experiments building networked ReactVR experiences with Redux that were unsatisfactory: there wasn’t a clean separation between the application logic and network code and, while the example exploited idempotency to reduce latency for some actions, actions which could generate conflicts used a conservative consistency mechanism which added at least a network round trip to those actions. So, I did some more hacking.

In an attempt to create a clean separation between application and network logic I kept the network code in a redux middleware and moved the application logic to an isValid callback which returns true if an action can be safely reduced:

With this in place the simple, conservative, dumbTerminalConsistency policy can be implemented in a few lines of code:

Clients generate actions in response to UI interactions and send those actions to the master. The master returns valid actions which are then reduced. Conflicts are resolved by serializing actions through the master client: isValid will return true for the first event, which will be distributed to all clients, but false for subsequent conflicting actions which are discarded. All clients see a single, consistent view at the cost of a round-trip to the master for all actions.

The same isValid method can be reused to implement an optimistic clientPredictionConsistency policy which treats the clients as decoupled simulations:

When using this middleware, clients immediately reduce actions which are valid given their local state and distribute local actions to all other clients. If a conflict is detected, the master client uses the same setState mechanism used to allow late joining to reset the decoupled simulations to the master state. The effects of actions are seen immediately at the cost of occasionally seeing the effects of actions roll back when the state is reset. By designing reducers to be idempotent and making the isValid callback as permissive as possible the number of state reset actions can be minimized. In the case of pairs, state resets only occur when two clients try to get the points for the same pair, or if a client tries to hide half of a pair which has been scored.

Testing pairs with the two different consistency policies over a high latency ngrok connection gives wildly different experiences. With dumbTerminalConsistency introducing 500ms round-trip latencies between clicking and seeing results the experience feels laggy, slow and clumsy. With clientPredictionConsistency the effects of local actions are seen with 0 latency and the experience is fast, snappy and frantic. Glitches caused by state resets are occasionally jarring, but often go unnoticed as the focus of attention is on the board during the game before switching to the scores at the end once they are eventually consistent. While it may make sense to use conservative consistency for some applications, pairs definitely benefits from an optimistic approach.

Being able to independently develop application logic and consistency mechanisms is extremely valuable. While developing the pairs example I was able to get the dumbTerminalConsistency middleware working, then the pairs game logic and then switch between the dumbTerminalConsistency and clientPredictionConsistency policies to determine whether I had a problem with the game logic or middleware while getting optimistic local updates working. I could imagine a similar approach being valuable for other applications. Conservative consistency could be used during development, then optimistic consistency policies could be experimented with to find the right trade off between latency and consistency without worrying about breaking the application logic by mixing in tightly coupled local update logic.

Its easy to imagine more sophisticated optimistic consistency mechanisms: middleware which generates anti-events to avoid full state resets when the state becomes too large, approaches which use Redux time travel approaches to rewrite history when conflicts are detected or policies which extrapolate predictions or interpolate corrections to avoid discontinuities for example. Many of these approaches could be implemented in generic ways, but developers would still have the option to build middleware which exploits application specific knowledge where appropriate.

The Redux approach of defining the next state as a function of an action applied to the current state lends itself to building sophisticated decoupled simulations. I hope to see these approaches become standard in networked ReactVR applications in the near future. Modern VR hardware provides incredibly low motion to photon latency and it would be a shame to see the sense of presence it can create broken by the network round-trips inherent in client-server architectures. Optimistic updates, client prediction and zero latency should be the default.

If you’d like to play the ReactVR version of pairs or see the rest of the code, it’s available on github here.

All code in this post is made available under the ReactVR examples license.

Generation JPod

2017-06-03T00:00:00+01:00

I’ve just got back from Kaş where I spent a lovely few days celebrating Pinar and Simon’s wedding and while there spent a few hours reading Now We Are 40: a thoughtful and entertaining look at everything from house music to house prices from the perspective of Generation X.

While a lot of the book was familiar, I was surprised how different my experience has been. I don’t feel part of the last generation who grew up without digital technology, but part of the first generation to grow up with it.

I learned to program at school, started writing code professionally at 18 and haven’t stopped. I didn’t work many McJobs, but have worked in many JPods (and seen friends move to Vancouver to work in the games industry there). I may have bought my first smartphone when I got my first job, but my life has felt digital from the start.

One focus of “Now We Are 40” is the changes in music over the last few decades from the pre-digital rave scene to the current over-saturation of recorded music available from streaming services which has rendered selling recorded music unsustainable for almost everyone. Food and drink followed on as the next big thing, something I’ve experienced personally as my brother-in-law morphed from hip hop pimp to sommelier. You may not need to buy recorded music any more, but you still need to eat and drink.

In fact raves, clubs, cafes and restaurants are mostly a place to hang out. When people were incredulous at the idea of spending real money on virtual goods Cory and I used to point out that most of what you were buying in Starbucks was not coffee or service, but an experience just as ephemeral as a virtual hat.

Virtual worlds like Second Life and now Social VR showed that you could digitise the hanging out too. It’s already proving to be an invaluable lifeline to people who find it hard to hang out in real life. While festivals, clubs and gigs are where musicians are increasingly making money in real life, they also work in virtual worlds. I first saw the Qemists, now one of my favourite bands, on the Ninja Tune stage at a festival in Second Life organised by Aleks. Later, Leon poked me on Facebook to ask me to advise his new tech startup because, after music and food, technology is apparently the new rock and roll.

For most of my career I have been building experiences which compliment the real world and working at Facebook is the first time that I have felt like I might be working somewhere that has been disrupting existing industries. The view that Facebook is an existential threat to the open web (a prospect that Bryan likens to the bug sucking the wildebeest dry) is relatively widespread and I remember a circle forming around me when I told Aral and some of the other web developers at a Skiff Christmas party that I was going to work there.

In fact I’ve spent much of the last few years working on open source tools that will benefit the wider web while also being able to support my family more sustainably than I could working in a games industry where redundancies and closures were more common than Philip Rosedale being asked how much he would sell Second Life for at Davos.

While the software industry seems to be constantly changing with new tools, languages, platforms and frameworks arriving all the time, a deeper disruption is potentially coming to the business of writing code for a living. Increasingly large parts of software systems are learned by machines rather than programed by humans. As Jeff Dean at Google observed: “If Google were created from scratch today, much of it would be learned, not coded.” When I started studying Computer Science in Nottingham my dad advised me not to become just a computer caretaker. It’s very possible that I may end up becoming a computer trainer instead.

If my experience has felt so radically different despite being only a few years younger than Tiffanie Darke - if I feel more Generation JPod than Generation X - are we already at the point where technological change is rendering the use of 15-20 year long generations obsolete?

The difference may also just be because “The future is already here — it’s just not very evenly distributed.”. If you were connecting early modems to BBSes at the start of the 90s it was easy to become a digital native. If you were busy dancing to Charly in a warehouse you may have had to catch up later.

One thing that is clear is that we need to work out how our increasingly disrupted and automated society will function. If software is eating the world and software is increasingly learned, then we’re going to have to find a way for people to flourish in that future. Brexit and Trump show what happens when people are worried about their place in the world. I’d like to see my children grow up in a future which is closer to the The Culture than Mad Max. There’s a general election in the UK next week. My next plan is to vote for a more progressive future.

2² Decades

2017-04-20T00:00:00+01:00

Several years ago when we were in 100 robots together, Max was celebrating his 40th birthday. When I said that mine would be in 2017, it felt like an impossibly far future date, but, after what feels like the blink of an eye, here we are.

Along with many other lovely gifts I received this morning was a book with the subtitle Whatever happened to Generation X? by Tiffanie Darke complete with a bright yellow acid house cover and a quote by Douglas Coupland on the cover.

I’ll read the book when I go to Simon and Pinar’s wedding next month, but I’ll share my immediate reaction now. Despite the term being popularised by Coupland’s book, whatever did happen to generation X we won’t read it in a book. We’ll read and write about it on the web we built.

While I remember my parents freaking out when I wanted to wear a bright yellow acid house badge to school, at the time I was more in to loud guitar music like Nirvana and Blur. From the perspective of loud guitars it felt like I’d missed the party: Metalica’s Master of Puppets was already receading in to the rear view mirror and Led Zeppelin firmly in my parents era. While we didn’t have The Beatles though, I did have computers.

There are plenty of people who would argue that I missed the boat there too: Boolean algebra was developed in 1848; the Halting Problem proved to be undecidable over Turing machines in 1936 and Quicksort was developed in 1959. While the Infer team refused to give up at the halting problem and are now producing amazing real world results using static analysis, a lot of computer science was finished before I was born.

My kind of computers weren’t huge machines crunching numbers and doing maths though, they were small pieces loosely joined. Connecting to things and each other they didn’t operate on maths, but changed the world or built new ones. They automated my physics experiments so that I could spend more time kissing Ali in the common room, helped reverse engineer Grand Theft Auto maps and automated synthesiser parameters when I didn’t have real controls for them.

They let me record hours of music and made writing books, making films and recording music accessible to everyone. While that made lives harder for those trying to make a living from their art it helped many more lives flourish. Napster may have made Metallica pretty upset, but the french horn player from my school could plunder the past for funk loops to accompany his synthesisers.

The DIY explosion gave us hip-hop and a million flavours of dance music and the networks to share it. Eventually it also gave us digital versions of the Beatles and, now I have been able to download and listen to it all, I’m convinced they have nothing to top the Aphex Twin.

The same democratization of tools meant that as a software engineer I could scratch an itch and choose to build my own service on top of world class open source software or work for one of the companies that became huge making the web easier to use. I’ve seen enough of how the startup sausage is made to know that a lot of the glitter is not gold, but owning the means of production means I at least have the choice to strike out on my own.

Climate change may mean that our real world horizons are closer and the piles of stuff we collect smaller, but the virtual vistas we can explore are ever growing.

When I watch my children grow up with YouTube it’s amazing to think about what they will accomplish in the future. If they want to do something, they watch it, learn it and do it. Nothing is unknown and nothing is impossible. They’re incredible, which is lucky, as together we’re going to have to save the world.

These thoughts are my own. They don’t represent my employer. They don’t attempt to speak for my generation. I write them and share them because I can and because I want to. Someone might read them and comment on them or link to them to build a web. Thats how my generation works and that’s what we built. We may not have had the Beatles, but I’m OK with that.

VR Redux

2017-01-04T20:20:00+00:00

Mike and I have been talking about how to easily build simple networked social applications with ReactVR for a while, so I spent some time hacking over the Christmas break to see if I could build a ReactVR version of the pairs game in Oculus Rooms. Pairs is simple and fun, but also interesting as it’s real time and has the potential to generate conflicting updates that need to be resolved.

Redux seemed like a promising starting point as it reifies events and allows flexible event processing in a similar way to MASSIVE-3. I used websockets as they are already supported by ReactVR along with wsrelay to network the clients.

With those pieces in place the simplest way to network the clients is to implement a middleware function to send every action generated in one client to all the others. In the case of actions which show a tile this is sufficient as the action is idempotent. If two players click on a square at the same time, the order that the actions are reduced in doesn’t matter: in either case the result is that the element is revealed. We can exploit the idempotency by optimistically processing the action locally before sending it to other clients to minimise network latency.

Scoring is trickier. While each client can tell when a pair has been revealed, only the first player to reveal the pair should score a point. As the actions to reveal tiles are potentially processed in different orders on each client that could lead to inconsistent scores even if only the first is processed. A simple way to avoid this inconsistency is to nominate one client to be the master and only have that client generate score actions. This can be implemented as another middleware to avoid generating actions inside a reducer.

The master client can also be made responsible for sending the current state of the simulation to new clients to support late joining.

With those parts done the app is usable and makes an interesting example of one possible way to network ReactVR applications. This was the first time I’d used React, ReactVR or Redux and I was very impressed by how easy to use and flexible they are. With the addition of some small pieces of middleware Redux can be used to implement a distributed simulation with flexible consistency mechanisms to trade off latency and consistency. The pairs example shows that even within a simple application applying different consistency mechanisms to different actions and parts of the application state is useful.

The next things to experiment with are using WebRTC to allow peer to peer communication between clients to further reduce latency, add a server to allow trusted and hidden state and allowing clients to subscribe to a subset of actions to allow heterogeneous clients and interest management.

If you’d like to play the ReactVR version of pairs or see the rest of the code, it’s available on github here.

All code in this post is made available under the ReactVR examples license.

Creating A Safe Environment For People In VR

2016-10-31T23:28:00+00:00

I was very happy that Oculus found time at OC3 to host a panel on creating a safe environment for people in VR. As social VR becomes more popular over the next few years it will quickly have to learn how to keep people safe together in shared environments. Some of the challenges are new: tracked hands make it easier to violate other avatars and gesture abusively without resorting to custom animations or scripts; invading personal space is a much bigger issue and increased presence makes all experiences more visceral for better or worse. Some novel solutions have already been developed for these challenges, notably the personal space bubbles developed for Bigscreen and widely used in other social VR experiences. However, a lot of these problems have been experienced in virtual worlds since MUD1 launched nearly 40 years ago. I was particularly struck by how the experiences with filtering, reporting and governance in Altspace VR reminded me of the story of LambdaMOO becoming a self-governing community told by Julian Dibbell in My Tiny Life. People like Julian, Richard Bartle and Raph Koster have been wrestling with and thinking about these problems for decades. The pioneers of this generation of VR should make sure they learn from those experiences.

crestexplorer

2016-08-21T21:48:00+01:00

At the 3rd Party Dev State of the Union at EVE Fanfest 2016 earlier this year, CCP FoxFour drew my attention to a limitation of the current approach used by crestmatic to generate CREST documentation: it only discovers resources always reachable from the API root from the perspective of the authorised character at generation time. As CREST now includes APIs for transient resources like fleets the entire API isn’t reachable for documentation from a nightly run using the credentials of a character not in a fleet.

There are a couple of ways to fix this. At the API level OPTIONS responses could refer to linked representations that can exist. An alternative is to extend crestexplorerjs with OPTIONS metadata to make it expose live documentation about reachable resources.

At a recent hackathon I took the second approach. crestexplorer now makes OPTIONS requests to each resource it requests and uses crestschema and data urls to generate downloadable JSON schema descriptions for each of the representations available for a resource. It also hyperlinks to the alternative representations so now all representations of all reachable resources are available in crestschema and the human readable descriptions of each field are added to the rendered resource as hovertext.

Now documentation for any valid CREST resource live by specifying the URI for the resource as the crestexplorer hash fragment. Even when the resources are transient documentation is available for resources while they exist.

Strange Tales From Other Worlds

2016-05-10T00:00:00+01:00

At the end of last year, Michael Brunton-Spall and Jon Topper asked me if I would like to give the opening keynote at Scale Summit as I had “lots of experience scaling weird things”, by which they meant Second Life and EVE Online. I immediately thought of The Corn Field, a place in Second Life that is a reference to an episode of The Twilight Zone where naughty avatars were sent to think about what they had done. Several more bizarre anecdotes quickly came to mind and soon I had a talk: Strange Tales From Other Worlds. A few people who couldn’t make it to Scale Summit mentioned that they wanted to hear the talk, but the recording I made at Scale Summit was somewhat disapointing. Luckily I was invited to give the talk again a few weeks ago to the Oculus team at Facebook London and made a Keynote recording which I’ve now uploaded to YouTube here. The strange tales are mostly true, but a few errors snuck in to the second telling: firstly MUD stands for Multi-User Dungeon and secondly I forgot to credit Brian Bossé for his amazing work on TiDi the second time around.

Towards A Generic Media Type System

2016-04-17T00:00:00+01:00

The early days of RESTful hypermedia API design tends to involve lots of homogeneous collections. In the case of CREST vnd.ccp.eve.Api-v1 pointed to the logged in vnd.ccp.eve.ccp.Capsuleer-v1 which pointed to a vnd.eve.ccp.CharacterCollection-v1 of contacts which pointed to many vnd.ccp.eve.Capsuleer-v1 representations, one for each capsuleer contact.

Adding search makes things more complicated. A typical search resource will accept a query and return a collection of hyperlinks to heterogeneous resources. EVE allows capsuleers to have contacts that might be other capsuleers, agents, corporations or alliances. In the future capsuleers may also be able to have coallitions in their contacts list. In this hypothetical future a contacts management application developed now would end up receiving search results that it wouldn’t understand. After requesting a resource and receiving an unknown representation the client can ignore the resource, but it would be better to filter out unknown resources as part of the query.

Server side filtering is typically added to search via extra query parameters. In our CREST example we might add q=Jayne&type=capsuleer parameters if we just wanted to find the capsuleer Jayne Fillon. An unfortunate consequence of this design is that we end up with application level types used to filer searches as well as Media Types used for HTTP content negotiation.

It would be nice to just use content negotiation, but we want to filter the resources that are referenced by the returned resource, not the returned representation itself. The search request might return a vnd.ccp.eve.Collection-v1 representation, but we want to make sure that the hyperlinks in that collection only point to vnd.ccp.eve.Capsuleer-v1 resources.

As a client we’d like to specify is that we want search to return a vnd.ccp.eve.CollectionOfCapsuleerReferences. If the client wants to include corporations in the search results it should be able to specify a CollectionOfCapsuleerOrCorporationReferences. We’d like a richer media type system.

While this could be implemented in the backend just by switching on the Accept type, the combinatorial explosion of potential search results quickly makes this impractical. A simpler way to experiment with this approach would be to implement a proxy which can query the API for Collection-v1 representations and convert them in to arbitrary CollectionOfFooAndBarReference representations.

The proxy could also be used to inline reprsentations, allowing clients to request a CollectionOfFooAndBars rather than a collection of hyperlinks. If clients only wanted a subset of the full Foo and Bar representations thay might ask for CollectionOfJustNameFromFooAndJustNameFromBars. These additions would address some of the biggest headaches caused by API designers who have to decide which fields to denormalise in to collection resources to avoid clients having to make a huge number of requests in order to provide meaningful choices to users.

This approach potentially provides a lot of the benefits of GraphQL to RESTful clients just through normal HTTP content negotiation protocols and maintains the benefits of maintaining a small number of versions to API developers. If a composite type refers to a type which is deprecated in the underlying API, it can return as deprecated response as normal.

As with programming languages, it seems that if we’re going to support strong media types it’s useful to also support generic media types.

#recordstoreday

2016-04-15T00:00:00+01:00

3 weeks ago I spent a few hours with photoshop working on the Story Bird logo that Linda made a while ago to make it suitable for print. 2 weeks ago I spent a few hours researching the best way to convert the 24 bit 48 Khz Story Bird mixes to 16 bit 44.1 Khz audio files that could be burned to CD. A week ago I went to Maplins in Tottenham Court Road, bought a cake of printable CD-Rs, dusted off my old MacBook Pro and spent the weekend burning copies of the Story Bird album. Tomorrow the CDs will go on sale at The Marwood Coffee Shop in Brighton for #recordstoreday.

The whole process felt fun, quaint, cute, anachronistic, nostalgic, and absurd. The last time I burned CDs was 3 years ago, when I made a few copies of the 100 Robots Sustain album for friends. My current MacBook Pro doesn’t have an optical drive, let alone a CD writer. The CD player in our living room doesn’t work. I ripped our CD collection to MP3 a decade ago when we still lived in Nottingham and needed to make space for our new family. Until I tested the Story Bird CDs, the last 2 operational CD players in our house haven’t played a CD in months. It’s great to see real, physical copies of the album I’ve spent the last 6 months working on, the CDs sound great and the unique hand printed covers look amazing, but as with the piles of vinyl records sold tomorrow on #recordstoreday they will mostly serve as limited edition souvenirs.

#recordstoreday promotes collecting records just as the #comicbookday that inspired it promotes collecting comics. Fetishising obsolete formats is harmless fun, but discovering new music and supporting musicians is important. On the 23rd of April, once you’ve filed away the limited edition vinyl you queued overnight to buy on #recordstoreday, spend some time in the comfort of your own home downloading some amazing music on #bandcampday.

#bandcampday

2016-03-26T18:59:00+00:00

I love record shops. Whenever I had pocket money it would go on Metallica and Nirvana CDs bought from Our Price or black t-shirts to match. When I lived in Nottingham I bought Boards Of Canada CDs from the same Selectadisc that my Dad bought a rare Fairport Convention single from decades before and the latest Ninja Tune or Rudy Van Gelder edition Blue Note records for £5 from Fopp. While working at Linden Lab in San Francisco my brother and I gorged on releases by the Quannum collective hungrily snatched up from Amoeba Music. While walking home from BrewDog with Alistair recently, we were both enthusing about the amazing Resident in Brighton. I commented that it was a shame that even Resident didn’t have room for the incredible Tera Melos who I had just seen at The Green Door Store after finding their music along with Cleft, 100 Onces and many others on Bandcamp.

I also love making music. While I was still at school I recorded Timeless Mind songs on a Fostex X-28 cassette 4-track. When I got to Nottingham I watched 4hero coax amazing sounds out of an Atari while I projected virtual worlds on the wall behind them, tried to convince Cubase to sync MIDI parts to audio on an underpowered PC, shut my brother in my spare room until he recorded saxophone parts for Vanishing Trick and eventually saw some of my music in Selectadisc thanks to DJ SS and Formation Records. Computers democratized music production and unleashed a Cambrian explosion of DIY musical creativity that can’t fit in to any record shop, but can fit on the Internet. When Resident runs out of room, Bandcamp keeps going. Bandcamp also allows musicians to charge a fair price for their music and takes a fair percentage for their services: an important consideration in a world where making money as a musician is becoming increasingly hard.

A couple of days ago I was reminded of the conversation with Alistair when I started seeing mentions of this year’s #recordstoreday. #recordstoreday is great for record stores; Bandcamp is great for the rest of music; why isn’t there a #bandcampday? On the 23rd of April, the week after you spend the afternoon buying exclusive slabs of shiny black vinyl at your local record shop, why not spend an afternoon uncovering some of the musical treasures on Bandcamp? I hope to have the first Story Bird album and new Point Mass music finished by then; I have some old Vanishing Trick tracks I can release and if I can find a good tape recorder I might even be able to upload some of the Timeless Mind recordings from 22 years ago. If you’re a musician, do you have any hidden gems you could release on the 23rd of April? If so, join this event and let’s see how much music we can release on the first ever #bandcampday.

crestmatic

2016-01-03T23:13:00+00:00

A year ago I gave a talk at EVE Vegas about building RESTful CREST applications. My #1 recommendation was to specify representations in requests, but that’s hard to do when there is little documentation on which representations are available and what they contain.

Fortunately CREST is self describing: send an OPTIONS request to a CREST URI and a list of methods and representations that can be used with that URI is returned. The metadata isn’t in a standard format, so I built the crestschema library which can convert the CREST format in to more useful JSON schemas. The library works in browsers, in applications like crestexplorer, and from node in applications like crestschemaspider which can crawl the CREST API to find all reachable representations. Converted schemas can then be used with wide variety of software, libraries and languages to validate data from the live CREST API, generate parsers or automatically generate documentation.

With the schemas converted it’s easy to build crestmatic which uses crestschema and matic to generate the documentation. Adding a travis step to publish the generated documentation to gh-pages and wiring up nightli.es to trigger a build every night ensures that the documentation is automatically kept up to date. If you’d like to see some changes please feel free to submit a pull request or just donate some ISK to Capt Out if you find the documentation or code useful.

Free Tests For Everyone!

2015-06-11T17:00:00+01:00

Modern software development is sometimes colourfully described as being similar to firing tracer bullets at a target. Rather than spending time doing a lot of research, design and specification up front, the smallest, simplest version of the software is built and the feedback gathered from its use is used to improve the next version. Being able to continuously integrate, test and deploy software means that we can make this feedback loop incredibly tight but because the same engineers are developing the software and the tests we constantly have to think carefully about the testing investments we make and their opportunity costs.

Software engineers allow themselves to use knowledge of how the software works to pick good white box tests. They rely on code reviewers to catch important test cases that they’ve missed. They rely on unit tests to exercise pathological cases which are hard to exercise in end-to-end or integration tests. They use bugs discovered in previous releases to inform tests cases developed for the next. The goal is to ensure that the next version of the software provides feedback on how close it is to the target rather than just exploding on impact.

The decisions around which tests to write are hard because tests have costs. They take time to write and maintain and need to be changed and updated along with the software they test. What would happen if some or all of the tests could be free?

This question has tantalised computer scientists since Turing’s work on the halting problem in the 1930s and while academic progress has been made, tools based on that work have tended to either only work on small codebases; perform trivial analysis; generate a high percentage of false positives; produce difficult to understand reports or impose other overheads on the development process that make the resulting testing pretty far from free. As a result while we theoretically know how to do sophisticated analysis, in practice we tend to rely mostly on linters doing trivial checks alongside automated tests which check a handful of paths through the software written by engineers.

So it was wonderful when my mixture of hope, anticipation and scepticism gave way to delight when the Infer static analyser delivered on the promise of useful, non-trivial static analysis at Facebook. While Infer currently only reports on a small subset of the errors that it can detect, for those classes of errors Infer’s output is generally as useful as seeing a failing test case: Infer’s 80% fix rate on the non-trivial bugs it finds and reports on is extraordinary in an environment like Facebook’s.

Infer and tools like it won’t completely replace test cases written by engineers. To paraphrase Cristiano, without application specific information, no formula will be able to determine whether a piece of software is working as intended. As a companion to test suites though, static analysis will be transformative. It’s likely that sophisticated static analysers will soon be used by everyone from the smallest software engineering teams to the biggest tech companies. When high quality tests are free, why wouldn’t you run them?

Working with Infer in production at Facebook over the last year has been like living in the future. It has changed the way I think about testing and about the testing investments that should be made. I’m incredibly excited to see its public release as an open source tool that can be used by everyone and very grateful to have been able to help distribute this future more widely.

Investing In Testing

2015-06-10T20:22:00+01:00

Last year I was talking to an engineer at Droidcon London who was working on an Android app with 100% test coverage. I immediately asked whether he thought 100% test coverage was worthwhile: many software engineering teams strive to achieve 100% test coverage, but few succeed because it’s an enormous investment and one that I’m not sure often pays off.

As with technical debt, I think it’s useful to think of tests as technical investments. Time is invested writing and maintaining tests and the expected return is in time saved writing and debugging code or shipping hotfixes. However, in many cases that payoff doesn’t happen. It’s easy to write tests which never fail or slow down the software development process they were intended to speed up. Large software systems tend to accumulate lots of connective tissue in the form of methods which simply pass a call along to another object. If the software builds and starts these tests will always pass and so deliver little value, but they fail when the code is changed, requiring an engineer to investigate the failure and change or remove the test. Even good test investments incur an opportunity cost as time spent writing tests is time not spent improving the software being tested.

An alpha software engineer then is one that can pick the investments that pay off while avoiding spending time writing tests that don’t. There are lots of useful investment strategies that can be employed. In some cases test driven development can save more development time than it costs to write the tests, meaning that the the investment can pay off in hours. In other cases the past can be a useful guide to the future: if a bug is discovered then writing a test to ensure that it can’t occur again is often a good bet. Similarly, if changes to one part of a system cause failures in another then writing tests for those dependencies can avoid similar breakages in the future. In both cases it’s easier to add the tests later if the code is designed to be testable, which in turn means that it’s often a good idea to write at least one test for each part of the system, to ensure that more tests can be added when needed. Adding tests to code that you need to change can be a good strategy as it prioritises parts of the system that are changing while allowing parts that just work to keep running without tests. However, if those parts of the system continually change the tests being added can add maintenence cost without having time to deliver a return on their investment. In a system where the user interface behaviour changes less frequently than its implementation, investing in end-to-end tests can be worthwhile. The end-to-end tests have the opportunity to find many different bugs in different revisions of the software, which is changing faster than the user interface, but this needs to be weighed against the high maintenence costs of end-to-end tests and the difficulty of diagnosing problems when they fail.

In all of these cases the goal is to write the tests with the highest expected return, or at least write those tests first. The problem with just striving for 100% code coverage as an investment strategy is that it values all tests equally. Any test which adds to code coverage is considered valuable: even those which will never fail and just add maintenance overhead. As the tests which can’t fail are the easiest to write they can often end up being written first. As more of these tests are added, the costs mount without benefits being realised and eventually tests stop being written with 80% code coverage, but with many of the most valuable tests missing and a demoralized and dissilusioned team.

When it comes to investing in testing it pays to invest in alpha.

buckd

2014-08-18T21:13:00+01:00

One of the things I’ve been working on since joining Facebook is Buck, an open source Android & Java build tool which is significantly faster than many other Java build tools for a number of reasons.

As well as being fast, Buck gains a lot of power and flexibility by using Python to generate build rules. Once projects become very large, however, this can become a problem as Buck has to execute thousands of python scripts to build its dependency graph before it can start its parallel build process. When I started working on Buck this parse phase could last tens of seconds. Buck was already much faster than Ant, but test driven development could be painful.

Our initial work focussed on making the parsing step faster and after some experimentation with Jython we discovered that bigger improvements could be made by running a long lived Python process which could be handed build files to execute as required.

As is often the case, the bulk of the improvements could be made by caching. Build files change far less often than source files, so caching the build file output avoids the need to spend a lot of time parsing in the common case when only a small number of source files change. After spending some time looking at serialising the build file output to disk it became clear that a more effective approach would be to cache the output in memory by running Buck as a long lived server process using Nailgun.

Nailgun is a client, protocol, and server for running Java programs without incurring the JVM startup overhead. Nailgun makes converting Java applications to client-server architectures as simple as passing the name of the class containing your Main method to the nailgun Server and client application. Early experiments running Buck with Nailgun showed a lot of promise, allowing us to reduce parse time to close to zero, but running buck as a server invalidated several assumptions that required a non-trivial amount of work to fix.

The environment had to be threaded through from the client and calls to System.getenv() replaced, System.exit() could no longer be used for garbage collection, so resource lifetimes had to be managed with try-with-resources blocks and Nailgun needed to be extended to detect client disconnections which could be thrown as InterruptedExceptions to ensure that killing the Nailgun client cancelled builds as expected. It’s also worth noting that for large, long running applications like Buck the JVM started overhead saved by Nailgun is not significant, but the time saved by the long running process being able to maintain a JIT cache of Java class files is.

With Buck running as a long running server process the next step was to make it correctly invalidate cached build rules when build files changed. In order to avoid building outputs each time a file is touched, buck hashes the contents of input files to see if they have actually changed. While this saves a lot of time when switching between similar source control branches it requires reading each input file each time a build is run: something which was adding several seconds to the per-build overhead that we were trying to reduce.

To avoid this overhead we switched to a composite approach which watches the file system for changes and then checks the hashes of the contents of changed files. In the case where a few files are edited only a few hashes are generated and compared, in the case where source control systems touch many files without changing their contents comparing hashes avoids unnecessary rebuilding.

Initially we used the standard Java WatchService to generate file change events, but found that in practice the latency between changing a file and the FileWatcher generating events was far too high. Luckily wez, sid0 and friends had built Watchman which provides very low latency file change events and an easy to use JSON based interface which only took a day to wire in to Buck. Watchman is an amazing piece of technology, but requires some tweaking of OS settings to work well, so if you notice Buck taking a long time to parse project files you may need to check the system specific preparation.

When combined with exopackage and a number of other optimisations, the benefits of the Buck daemon are significant. Trivial builds now take a small fraction of the time they used to and in some cases it’s possible to incrementally build and install of an app in less time than it takes some build systems to do a no-op build.

I’ve had a great time working with the amazingly talented Buck team and I’m very happy to see buckd improving build times within Facebook and beyond.

Now it’s time to go back to writing a test, watching it fail and making it pass: with a lot less waiting around.

Organisational Structures

2014-03-20T23:00:00+00:00

There have been a number of blog posts recently about exciting new organisational structures. As Cory points out “Every early stage company thinks it has reinvented management”: a very dangerous belief when betting on a new organisational structure can be much riskier than betting on the wrong product.

It starts innocently enough: version 1.0 has finally launched, early adopters have arrived, the graphs are definitely starting to point upward and it’s time to hire.

Growing the company is the next challenge, but no one has spent the last couple of years foregoing income and sleep to build another Acme Corp., in fact no one believes that an Acme Corp. would have been capable of launching version 1.0 which was clearly only possible due to having a room full of smart people and no management.

So, the first course of action is to hire more smart people and empower them to choose the right thing to do. This works for a while but eventually the CEO can no longer keep track of what everyone’s doing and some things are falling through the cracks.

This is clearly a scaling problem, so a scalable system is devised. Maybe everyone picks N tasks a week and votes on the most important, maybe this is 2 years ago and some bonuses are sprinkled on gamification style, or this is in 6 months time and some sharing economy social mechanics are wedged in.

Like all alphas there are some wrinkles and so the system is tweaked and iterated on, but now the organisational structure has become a second product. While some people are enthusiastically hacking on the organisation, they’re not working on version 1.3 which is late. Other people are frantically trying to get version 1.3 out of the door while another no longer buys the new organisational structure and has cashed in their last 2 years vacation along with the money they gamed from the bonus system to pay for a month long holiday in the sun.

Eventually it becomes clear that fighting on two fronts is not sustainable and the CEO decides to pivot to a more conventional organisational structure to concentrate on getting version 1.4 out on time. Some of the people who heroically got 1.3 out of the door would make great managers, but by this time they have either already burned out and left or are shopping their CVs to Acme Corp.

Luckily the product is still generating buzz, so a brace of experienced managers can be drafted in, but this generates even more organisational churn as some more of the smart people look up 4.5 years in to their 3 month project to discover that a lot of their friends have left.

The organisational structure that looked like a trivial problem compared to building version 1.0 results in version 2.0 never shipping.

Getting product decisions wrong costs time and money. Getting organisational decisions wrong burns even more valuable human capital and goodwill. Engineers at startups expect to make product pivots, but they don’t expect to be alpha testing an ever-changing series of organisational MVPs at the same time.

In many cases the ground breaking tech product and/or service is mostly a clever combination of commodity hardware and open source software connected to the internet and maintained by a small and heroic ops team.

Similarly, the innovative company is often a clever combination of existing organisational structures maintained by a small and heroic management team.

I’m currently very happy as one of the nodes in the middle left picture below. We’re hiring.

(via bonkersworld.net )

Beyond Time Dilation?

2014-01-29T06:38:00+00:00

EVE online is a remarkable game. On Monday over 2000 people spent over 20 hours destroying virtual spaceships worth 200,000 USD in real money in what was the likely the largest battle in a video game ever. That EVE is capaple of supporting such large engagements is an amazing technical achievement, that thousands of players are willing to invest huge amounts of time and money in to a game that recently celebrated its 10th anniversary is an amazing game design achievement.

The reason that the scale of EVE battles continue to break records and make headlines is the introduction of Time Dilation (TiDi) in 2012. When the server simulating a solar system in EVE becomes unable to keep up with the rate of updates from connected clients it slows the simulation down so it can keep up. Before TiDi the server would become overloaded and start failing to process commands from players. After time dilation, game time slows down, but commands continue to processed fairly for all players. Up to a point.

In order to ensure that battles eventually get resolved, TiDi is only allowed to slow the simulation down to 10% of it’s normal speed, so at 10% TiDi one second of simulation time passes for every 10 seconds of real time. The 20+ hour Battle of B-R5RB on Monday was eventually brought to a halt due to a server upgrade, if TiDi was allowed to continue past 10% this would become increasingly common and battles would often be decided by one side’s willingness to put up with more simulation slowdown than the other.

In part due to the extra real time that TiDi gives players to join in, the scale of large EVE battles have now grown to the point where they regularly push TiDi to 10%, server CPU to 100% and cause the old problems of failing updates to reappear, as was seen in The Battle Of HED-GP a week ago in which many of the attacking forces were unable to issue commands successfully and so were destroyed. The limits of TiDi to allow battles in EVE online to scale up have been reached.

In his analysis of The Battle of HED-GP, CCP Veritas, talks about “one of the bounding scaling factors in large fleet fights, the unavoidable O(n2) situation where n people do things that n people need to see”. Avoiding this bounding scaling factor may be one way to allow EVE battles to scale beyond the limits of TiDi.

As the amazing screenshots from B-R5RB show, large scale battles in EVE quickly become difficult to navigate. With 1000s of pilots in space, simply finding the ship you want to target becomes hard. As a result EVE provides an overview that lists the ships in nearby space. This overview can be sorted in a number of ways allowing a particular ship to be selected and multiple lists can be set up filtering out different subsets of things in space. Often during a battle pilots will use an overview set up to only show enemy ships to avoid targeting friendly ships, for example.

Pushing these filtering settings to the server may be one way to scale EVE battles beyond the limits of TiDi. In the case where all pilots have their overview set up to only show enemy ships we would have a situation where n people do things that n/2 people need to see. With more aggressive filtering that only showed interacting ships plus the nearest ship of each type plus ships piloted by known pilots plus ships broadcast to your fleet it might be possible to get to a situation where the number of things people need to see does not depend on the number of people in a battle. The O(n2) problem could be avoided without significantly changing EVEs game play mechanics. If the number of ships of each type were also sent to the client, the overview could still be populated with one entry per ship, albeit with missing information, allowing for situations where fleets want to spread their fire rather than focussing it.

One potential weakness with this approach is that it would allow pilots to force the server back in to doing O(n2) work by simply disabling thier overview filters, something that might become impossible to resist in a situation where it’s clear that your fleet is going to lose hundreds of thousands of real dollars worth of virtual spaceships. In the Battle of B-R5RB, one side had ships filled with autonomous drones which they apparently chose not to deploy to avoid server load, but might well have decided to deploy if they had started losing the battle.

A potential solution here would be to prioritise updates from players with more aggressive filtering settings. If the server runs out of time at the limits of TiDi it simply stops processing updates and starts on the next frame, penalising pilots with too liberal filtering settings who could be made aware that their updates are being dropped by the UI. This would encourage pilots engaged in the battle to aggressively filter while potentially still allowing non-combatants to capture the occasional screenshot or even video of the entire battle.

Another weakness of this approach is that pilots will no-longer see every ship in the battle rendered at the correct position in space. A similar approach to populating the overview could be taken here by rendering the correct number of ships of each type at ranges beyond the minimum range for each type, or more symbolic approaches could be used to display the number of ships in the 3D scene. I did some related work on rendering symbolic abstractions of 3D environments in MASSIVE-3 many moons ago.

I no longer have a copy of the EVE source code to check whether any of this is possible and even when I was working on CREST I didn’t look at the simulation code in EVE much at all, but this might be one way around the O(n2) problem that currently limits the size of EVE battles. However they choose to tackle it, I wish CCP Veritas and the newly rehydrated Team Gridlock all the best in their scaling work and look forward to reading stories of ever more epic space battles for the next 10 years.

Osprey Therian

2013-12-15T23:50:00+00:00

In mid-2004 I first started exploring Second Life. Version 1.4 had just been released and Philip Rosedale had said in the press release “My fantasy is to be Uma Thurman in Kill Bill, and now I can. I’d pay $10 for her yellow jumpsuit and sword moves and I’m sure other people would too. Custom Animations are going to liberate the world of Second Life in ways I’m sure I can’t imagine.” Plenty of people responded by making sword fighting moves, but the software and network latency in Second Life made actually having a satisfying sword fight hard, so I decided to play around with Second Life’s scripting language, LSL, to see if I could build an interesting turn based sword fighting game. Once I had a prototype up and running I realized that it might be fun to turn it in to a trading card game and so asked on the Second Life forums if anyone would like to help with the artwork. Osprey Therian replied.

I had no idea who Osprey was in real life, but in Second Life she was friendly, funny, enthusiastic, determined and a ball of energy. Together we photographed hundreds of avatars and Osprey turned them in to georgous Combat Cards, she created hilarious custom animations with rotating limbs for our robot themed cards and dozens more to accomodate avatars curled up in to a ball as tinies. We sold thousands of combat cards, made thousands of real life dollars and ploughed some of that in to getting real life Combat Cards printed which we sold for Linden Dollars using a vending machine in Second Life. We built a community that met up every Sunday to play Combat Cards and ran tournaments with every new release for several years in Europa. Much of this was only possible thanks to the way that Osprey threw herself in to the project with an energy, passion and determination and commitment that I have rarely experienced in Second Life or real life.

We rarely talked about real life, mostly just meeting up in SL and getting things done. Partly this was because started working for Linden Lab and didn’t want that to affect our relationship. Eventually I let it slip somehow and Osprey confessed that she sort of knew anyway, from various hints and things I’d mentioned over the years. With that secret out we vaguely started making plans to meet up in real life and in 2009 got the chance.

While visiting Linden Lab’s Seattle office I hired a car and drove to Olympia where a woman called Vivian Kendall, who I had never met before, let me in to her house and made me a salad. In some ways it was a very strange encounter. I wasn’t a bald, yellow, Simpsons like mad scientist, Osprey wasn’t a rakish, swashbuckling rogue and we weren’t swordfighting, dancing or floating across Second Life in a hot air balloon, but we knew each other. “You’re just you”, Vivian said as we ate together. And Vivian was just Osprey. Much frailer in real life, but full of the same energy and passion that spilled out across Second Life. After lunch we looked at some of Vivian’s real life paintings and although she regretted not being able to paint any more she talked enthusiastically about the second life that Second Life had given her to create and socialize as her real life had closed in. After an hour or so of chatting we took a picture, I left and we went back to our second lives.

I only heard about Vivian’s passing a couple of hours ago via Joe Miller and so I unfortunately missed her memorial yesterday, but I am very grateful that I got to meet up with Osprey one last time to celebrate Second Life’s 10th birthday a few months ago. We talked and danced, listened to music and Osprey showed off yet another amazing Second Life avatar that looked incredibly life like until she pushed a virtual button and made her feet enormous. It was perfect.

Whenever people claim that Second Life failed I think of Osprey. Second Life allowed many of our lives to be enriched by the wonderful Osprey Therian and provided her with a platform for her creativity when painting in real life became impossible. That is success enough for me. But Second Life was just the platform: the art, energy, love, creativity and passion were Osprey’s alone. I will miss her enormously and remember our time making Combat Cards together forever.

Parse By The Sea

2013-10-19T18:37:00+01:00

A few weeks ago Facebook London hosted the Parse By The Sea hackathon at the Brighton Dome as part of the Brighton Digital Festival. The idea was to take one of our internal hackathons on the road and invite members of the public to join us, turning a hackathon in to an open studio offering a glimpse of an important part of Facebook Culture.

The Dome cafe bar was a great venue with the Founders Room soon packed with eager hackers listening to presentations and watching live coding demos from API partners Withings, Deezer, Pusher, Unity and Parse. Soon the rest of the Cafe and Mezanine were collonized by teams of hackers. The WiFi and 100Mbps connection supplied by Metranet held up admirably to the 12 hour pounding dished out by 100 hackers each with multiple devices and before we knew it it was time to head back in to the Founders Room for the prototype forum where hacks were presented and prizes awarded.

Deezer were delighted by the number of high quality music hacks including Party Relative Track Evaluator by Paul Blundell, Music Puzzle by Alice Lieutier, Flapdoodle by Ryk, Charlie, Phil, Luke, Matt and PlayHear by Joe Birch, Ivan Carballo and Mark Dessain.

Inspired by the talk of life logging at dConstruct this year I decided to work on a music based hack with Andy Pincombe from Facebook and Sara Gozalo from the BBC. Mood Music analyses the mood of your music listens using the EchoNest API and plots it alongside a sentiment analysis of your Facebook status posts. We didn’t get far enough along to draw any conclusions from our experiments, but it would be nice to see if music listens are a trailing or leading indicators of mood and maybe even build a Samaritunes app which determines the songs which pick you up and suggests them to you if you start to get down.

Other interesting hacks included Batsh, a compiler which generates bash and Windows batch files, Identify by Saqib Shaikh, an app which identifies objects by their bar codes for blind users, and Ninja Ear, an audio based game for blind users that moves objects around the stereo field.

The clear winner of the Parse and Facebook prize was Frictionless Photo Sharing by Ben Chester, Nick Kuh and Jose Jimenez. The app automatically saves new photos to albums and pushes them immediately to other devices sharing that album. The team managed to build iOS and Android versions of the app overnight and it was was amazingly slick: Nick demoed the real time photo sharing by taking pictures of the prototype forum audience and having them appear immediately on another device connected to the demo screens. A worthy winner of the Parse Pro account and Facebook ads prizes which we hope the team use to get Frictionless Photo Sharing in to the iOS and Android app stores and on to everyone’s devices.

There are a few things I’d change if I organize something like Parse By The Sea again. We normally run internal hackathons overnight on Thursday and wanted to stick to that schedule for authenticity, but it meant that lots of people who wanted to come couldn’t make it: if we open up a hackathon again we should definitely run it over a weekend. It was also unfortunate that Parse By The Sea clashed with Over The Air which meant people who would have liked to have gone to both had to pick one or the other. Somehow we also managed to forget to bring any Red Bull, a problem with Elena quickly fixed by buying up all of the supplies at the local Tesco, but an inexcusable slip when hackers are trying to stay up all night.

Overall though, everyone seemed to have a great time and built some amazing hacks: thanks for coming along and making Parse By The Sea a big success.

Facebook Hackathons

2013-09-16T21:50:00+01:00

I’ve been a big fan of hackathons since one of the first Yahoo! Hack Days I attended at Alexandra Palace was struck by lightning. The lightning caused the fire alarms to go off which opened the roof to let the torrential rain pour on to hundreds of geeks and laptops. The lighting strike also did a wonderful job of breaking the ice: within minutes hundreds of attendees were huddling in the foyer talking about the weather while others busily snapped the few stalwart hackers who cracked open umbrellas and continued to code regardless.

Since then I’ve been to more Yahoo! Hack Days, Masheds, Music Hack Days and a Euro Foo Camp and built a realtime multiplayer augmented reality submarine torpedo game, an augmented virtual reality carbon emission visualizer, turned snake in to a music sequencer, put together the London Geek Community iPhone Oscestra and learned a pile of technologies from Reactable and Processing to Ubuntu and Django. But no one hackathons like Facebook.

Every six weeks hundreds of Facebook engineers get together on a Thursday evening under a huge crane to form teams and hack through the night on anything that isn’t their normal job before taking the next day off. It’s a huge opportunity to learn, meet people, experiment, try new ideas, learn new technologies, have fun and grow as a software developer. Running hackathons this frequently, on this scale and giving engineers a day off every six weeks is a huge, risky investment for Facebook, but one that pays off handsomely: many of Facebook’s features, dozens of internal tools that I use every day and the open source Buck build tool that I currently work on were all started at hackathons.

Now Facebook London has taken hackathons even further by adding cream teas at midnight and taking them on tour.

I had enormous fun building a catapult on top of Whitstable Castle and reenacting Monty Python and the Holy Grail at my first Facebook hackathon and I’m looking forward to the next one at the Brighton Dome on the 26th of September. The Brighton hackathon will be special as it’s the first time we’re opening a Facebook London hackathon up to the public as part of the Brighton Digital Festival. The format will be the same as a normal hackathon: it will start on Thursday night and dozens of the super smart Facebook London engineers will be there hacking on amazing projects until the next morning. The only differences from a normal internal Facebook hackathon are that external developers will be joining us and so we’ll be building on top of the Facebook, Parse, Deezer, Unity and Withings APIs rather than hacking on secret Facebook code.

If that sounds fun and you can convince yourself or your boss that taking a day off work to learn is worthwhile, send an email to brightonhack@fb.com and let us know that you’d like to experience a Facebook hackathon for yourself. I’m looking forward to seeing what we can build together.

Brighton Digital Festival

2013-09-04T13:49:00+01:00

The Brighton Digital Festival starts this week and I’m very happy to be helping out with Facebook London‘s contributions: Parse By The Sea, a mobile app Hackathon featuring Parse on the 26th of September, and helping to Connect The Brighton Digital Festival by sponsoring Metranet to provide high speed internet connectivity and improved WiFi infrastructure in the Brighton Dome. If you’d like to come to the hackathon, please send an email to brightonhack@fb.com and tell us about your mobile apps. I’m looking forward to seeing lots of great hacks at Parse By The Sea and to finally get online to blog, tweet and post from dConstruct and the Brighton Miki Maker Faire this year. I hope to see you there.

Final Score

2013-07-04T22:11:00+01:00

Using Reader on my HTC Wizard on the loo was probably responsible for my biggest increase in clue ever.

Goodbye Reader, you’ll be missed.

Pelican Powered

2013-07-02T19:13:00+01:00

Almost exactly 5 years ago I set up The Creation Engine No. 2 as a Byteflow blog running on Django when the original Creation Engine blog hosted by Linden Lab stopped being a suitable place for my thoughts on technology as a platform for creativity.

Byteflow and Django served me well until late last year when Recaptcha finally crumbled and I found myself spending an increasingly tedious amount of time cleaning up spam comments.

I considered just replacing the comment system with Disqus and Akismet, a particularly slick combination which I used on Creatarr, but without comments Byteflow’s full Django openid account system started looking pretty archiaic and heavyweight, especially when compared to the Octopress on github blogs that all the cool kids are using.

After some playing around with various modern static frameworks I settled on Pelican, a python framework with some nice, responsive themes built with Django based Jinja 2 templates which would be easy for me to hack around.

In a couple of hours I had a new git repository containing my blog posts imported in to a content directory, a fork of the pelican themes in a theme directory, my jimpurbrick.github.com repository in an output directory and all of the pelican dependencies listed in a requirements.txt ready to be pip installed in to a python virtual environment.

Moving jimpurbrick.com to gh-pages simply required adding a CNAME file to the jimpurbrick.github.com repository and pointing DNS to github and it was possible to emulate Bytemark’s clean URLs with Pelican by combining the post date and slug in it’s URL and storing each post in an index.html file so that requests to the clean URL at github return the index.html file.

The same hack works to support the existing clean feed URLs which are valid Atom and RSS feeds, which could be consumed by the late Google Reader despite the “.html” extension causing github to return the feeds with an HTML content type.

ARTICLE_URL = "{date:%Y}/{date:%m}/{date:%d}/{slug}/"
ARTICLE_SAVE_AS = "{date:%Y}/{date:%m}/{date:%d}/{slug}/index.html"
FEED_ATOM = "feeds/atom/blog/index.html"
FEED_RSS = "feeds/rss/blog/index.html"

A few theme tweaks later and I have a lightweight responsive, lightweight blog that allows me to author posts offline, supports all of the existing jimpurbrick.com permalinks and is hopefully ready for the next 5 years of The Creation Engine in the mobile first, post Google Reader era.

One Universe, Many Scales

2013-01-10T23:19:00+00:00

One epic meta-game design I first remember talking about a decade ago while working on Warhammer Online is the multi-scale online game: a system of interconnected games in which you choose to be a solo operative, work in a small group, or command epic forces or huge space fleets and influence a single universe however you choose to contribute. It’s a recurring game design meme that I’ve talked about several times since and I’m sure many others have had similar discussions around the globe ever since multiple computers were connected together.

So, I’m super excited to see CCP games take a huge step towards realizing this epic game design dream today by linking the internet spaceship game EVE online with the brand new PS3 first person shooter Dust 514. Players piloting giant spacecraft in EVE online will be able to swoop down from space and interact with other players running around on the planet’s surface playing Dust 514. This is very cool.

I’m also very excited that the two games are connected using the CREST API that I helped to build: an API that will be usable everywhere. Not only will you be able to interact with the EVE universe at every scale from the human to the intergalactic, the clients used to connect to the universe will work on every scale of device from phones to desktops and every scale of interaction from web tools built by 3rd parties, through 5 minute casual experiences to epic space battles played out in full 3D over hours and campaigns played out over years.

Today’s connection of EVE and Dust is a historic moment, but it’s just the beginning of what will be a very exciting second decade for the universe of New Eden.

Creatarr

2013-01-09T15:28:00+00:00

cc image by vdu, j4mie

One of the things I’ve been tinkering with since leaving Linden Lab is Creatarr: a creative, collaborative social game. Creatarr’s goal is to bring some of the magical collaborative creation found in Second Life to a wider audience and to push creativity in social games and the web beyond virtual farming and impact text on animal pictures.

I quickly got busy building the CREST API for CCP and I’m likely to have even less free time when I start my new gig, but Facebook are happy for me to continue to tinker with Creatarr and I like shipping code, so I’ve decided to make Creatarr public and run it for as long as people are playing. There are plenty of rough edges, but there are also some neat ideas and plenty of fun to be had, so head over to creatarr.com and dive in.

Thanks to @mrkemeny, Irene Soler, Chris James, @yandle and @profaniti for helping to build Creatarr.

Following In My Father’s Footsteps

2012-11-12T19:28:00+00:00

From 2 years before I was born, until just before I started working on Second Life at Linden Lab, my Dad worked at an innovative technology company with a large consumer photography business: Kodak. From January next year I’ll be working at an innovative technology company with a large consumer photography business: Facebook.

Looking at the march of technology from the perspectives of these companies is amazing. I had a summer job building my first web application for Kodak while I was studying Computer Science in Nottingham and remember one of the researchers there joking that film needed to last a long time as a roll would often have pictures of christmas trees at either end with a summer holiday in the middle. Photography was so expensive that people would only take a few dozen pictures a year. Now we happily take a dozen pictures of our lunch, wouldn’t consider buying a telephone without a built in multi-megapixel camera and people upload hundreds of millions of images to Facebook every day.

While the cost of creating photos has fallen to almost zero, their value hasn’t. Some of my most enjoyable moments recently have been looking at and commenting on the latest pictures of my brand new nephew, Charlie, on Facebook and so it goes for Facebook’s other billion users. Photos that are now so cheap to create that Kodak has filed for chapter 11 protection become social objects that are so valuable that Facebook can host the photos for free and still make a good business from advertising around the conversation.

Working for Facebook might seem like a strange move after a decade working on 3D environments, but virtual worlds like Second Life and EVE are also social spaces, just with virtual nightclubs or space battles as the social objects. While 3D environments allow more immersion than Facebook, the price is a much higher barrier to entry. Although a few people from my family tried Second Life while I worked at Linden Lab: most of my family use Facebook already. My brother could create a gallery of pictures of my nephew in Second Life and we could meet there to talk about them, but then most of my nephew’s other aunts and uncles wouldn’t be able to join us. Ubiquity trumps immersion. Virtual worlds like Second Life still need their iPod moment if they’re going to cross the chasm from niche technology used by gamers, early adopters and academics to become a mainstream communication technology. Even though Second Life is free to use and paid for by the publishers of the 3D content, it’s still too hard to navigate for most people to use almost a decade after its launch.

Facebook is already used by a billion people to keep in touch, while still evolving and developing at an incredible pace. I’m going to help new uncles connect with new nephews around the world while working on new technologies, which I think is going to make Facebook a fun and rewarding place to work.

After that, who knows? My Dad’s working on some pretty amazing stuff these days: if I keep following in his footsteps and change keeps accelerating, the next thing is science fiction now, just as Second Life and Facebook were in 1975.

Caching Shared, Private Data With Ningx

2012-11-11T20:23:00+00:00

As with many other social services, a large amount of the data in EVE Online and Dust 514‘s New Eden universe is shared between subsets of users. Some corporation data should only be accessible to the corporation’s members, market prices should only be accessible to capsuleers and infantry in the region for example.

In order to enforce these rules, the EVE cluster performs a number of access control checks whenever a request is made from an EVE client to the cluster. As a large fraction of calls to the CREST API require these checks to be performed, it would be nice to perform them in Nginx to avoid the overhead of having to make a request to the EVE proxy before returning the cached responses from Nginx. However, duplicating the access control logic within Nginx and trying to keep the two access control implementations in sync is likely to be error prone. As the spying metagame in EVE is arguably bigger than the game itself the consequences of getting the access control logic wrong could be huge. Internet spaceships are serious business.

Fortunately, it’s possible to combine and reuse the load balancing and vary header support techniques previously discussed to avoid both excessive calls from Nginx to the cluster and access control logic duplication.

In addition to annotating responses from the cluster with the address of the proxy containing the character’s session, we also annotate the response with the character’s location, corporation and various other character meta data. The same logic that performs access control checks in the cluster can then add these response headers to the list of vary headers when generating a cache key for a later request on behalf of the same character. Rather than duplicating access control logic, Nginx just needs to make sure that only response headers from the cluster are used for these access control vary headers. If a particular URI is annotated to vary on language and region for example, Nginx will allow the language to be supplied by the client, but the region must be supplied by the cluster in a previous response for the same character.

By reusing the stateful load balancing and vary header support we added to Nginx we’re able to cache data shared between multiple characters without duplicating complex access control logic implemented by the EVE cluster: reducing the CREST load on the EVE cluster without breaking the metagame.

Thanks to @jonastryggvi for working with me on the Caching support and @CCPGames for allowing me to blog about it.

Adding Vary Header Support To Nginx

2012-10-14T17:12:00+01:00

Although Nginx supports proxy caching it doesn’t provide support for the HTTP Vary header out of the box. This is a problem if you want to use Nginx to proxy different versions of the same URI which Vary on Content-Language or proxy different representations of a RESTful resource specified via the Accept header.

Fortunately it’s relatively easy to add support for the Vary header using the Nginx Lua module and a small amount of Lua, which is much easier than building and maintaining a 3rd party module and doesn’t greatly impact performance.

First, we define a dictionary in the nginx config which will store a mapping from URIs to Vary headers:

lua_shared_dict uriToVary 10m;

Next we define the default location in the nginx config.

location / {

    # make subrequest to /proxy_request, then store response headers
    content_by_lua '
        local vary = require("vary")
        local response = vary.ProxyRequest()
    ';
}

This will use the lua ProxyRequest function to make a subrequest to /proxy_request then store the Vary header in the response in the dictionary.

function ProxyRequest()

    -- make subrequest and capture response
    local response = ngx.location.capture("/proxy_request", {
        method = GetRequestMethod(ngx.var.request_method), body = ngx.req.get_body_data()})

    -- forward HTTP headers from response
    for k,v in pairs(response.header) do
        ngx.header[k] = v
    end

    ngx.shared.uriToVary:set(ngx.var.request_uri, response.header["Vary"])

    -- forward status and body from response
    ngx.status = response.status
    ngx.print(response.body)

    return response

end

Finally, we define the /proxy_request location.

location /proxy_request {
    internal;

    # set defaults
    set $noCache 1;
    set $cacheBypass 1;
    set $cacheKey nil;

    # rewrite using stored data
    rewrite_by_lua '
        local vary = require("vary")
        vary.RewriteCache()
    ';

    # proxy request
    proxy_cache_bypass $cacheBypass;
    proxy_no_cache $noCache;
    proxy_cache_key $cacheKey;
    proxy_cache API_CACHE;
    proxy_pass $proxy$request_uri;
}

This will use the lua RewriteCache function to combine the uri with the vary headers to generate the final cache key used by the proxy_cache module.

function RewriteCache()

    local varyOn = ngx.shared.uriToVary:get(ngx.var.request_uri)
    local cacheKey = nil

    -- if vary unknown for this uri, bypass cache and do not cache
    if varyOn == nil then
        return
    end

    cacheKey = ngx.var.request_uri .. GenerateCacheKey(varyOn, ngx.req.get_headers())
    ngx.var.noCache = 0
    ngx.var.cacheKey = cacheKey
    ngx.var.cacheBypass = 0

end

function GenerateCacheKey(varyOnStr, requestHeaders)

    local cacheKey = ""
    for part in string.gmatch(varyOnStr, "([^,%s+]+)") do

        if requestHeaders[part] then
            cacheKey = cacheKey .. ":" .. requestHeaders[part]
        end

    end

    return cacheKey

end

The first time a URI is requested the cache will be bypassed, but the Vary header from the response will be stored in the shared dictionary. The second time the URI is requested the cache key will be generated from the URI and the appropriate request headers specified in the vary header and the response will be cached. When the URI is subsequently requested with the same set of headers it will be served from the cache.

Note that when the shared dictionary is full it will evict old entries using an LRU scheme. Nginx will generate “ngx_slab_alloc() failed” errors when this occurs, but these can safely be ignored.

Thanks to @jonastryggvi for working with me on the Vary support and @CCPGames for allowing me to blog about it.

Load Balancing Stateful Services With Nginx

2012-07-30T05:49:00+01:00

The EVE online network architecture uses stateful proxy servers which manage sessions for players connected to the cluster via the EVE client. The client sends requests to the proxy which are forwarded on to sol servers maintaining the game state and the sols send notifications to the proxy which are sent on to the client.

In developing the CREST API we extended the EVE proxies to talk HTTP, then added nginx reverse proxies to the service to provide SSL termination and caching while shielding the EVE proxies from potentially malicious requests.

So, how does nginx know which EVE proxy to send a request to? In the first instance, it just guesses. We set up a set of proxies and use proxy_pass to have nginx just pick one.

upstream eveproxies {
    # List all eveproxies
}

location / {
    proxy_pass http://eveproxies;
}

The proxy can then use the CCP cluster’s RPC machinery to find the character’s session. If nginx has been lucky the request is processed and the response sent back to nginx and from there to the player. If no session exists for the character on any proxy a new session is created and then the request processed as above. If the character session is on a different node the proxy returns an X-accel response to a location which extracts the correct proxy URI from the path and resends the request.

location ~* ^/internal_redirect/(.*) {
    internal;
    proxy_pass http://$1$is_args$args;
}

The performance of this approach can be greatly improved by caching the mapping of authorization headers to proxies, which can be done using a dict and a small piece of lua.

lua_shared_dict tokenToProxy 10m;

location / {

   content_by_lua '
        -- make subrequest and capture response
        local response = ngx.location.capture("/proxy_request", {
            method = GetRequestMethod(ngx.var.request_method),
            body = ngx.req.get_body_data()})

        -- forward HTTP headers from response
        for k,v in pairs(response.header) do
                ngx.header[k] = v
        end

        -- forward status and body from response
        ngx.status = response.status
        ngx.print(response.body)

        -- cache backend for next request
        ngx.shared.tokenToProxy:set(ngx.var.http_authorization,
            response.header["X-Backend"])
    ';
}

location /proxy_request {

    internal;
    set $crestProxy "http://eveproxies";

    rewrite_by_lua '
        ngx.var.crestProxy = ngx.shared.tokenToProxy:get(
            ngx.var.http_authorization)
    ';

    proxy_pass $crestProxy$request_uri;
}

In a configuration with multiple loadbalancers we potentially have to pay the price of one proxy redirection per nginx process. This could potentially be improved by using a shared cache for the authorization to proxy mapping or by using ip affinity to map all requests from a client to a single nginx box, but in practice where the number of requests from a client is much larger than the number of loadbalancers, this improvement is likely to be negligible.

This mechanism ensures that most HTTP requests go straight to the correct proxy without the load balancers having to maintain any state. A new load balancer can be added to the cluster just be being told the addresses of the eve proxies and will quickly start routing requests to the correct location.

Brighton Mini Maker Faire: The Movie

2012-05-24T14:08:00+01:00

A great video of the Brighton Mini Maker Faire last year by Andrew Sleigh showing the making of You’re The Boss 2. Applications for this year’s Maker Faire are now open and I can’t wait to see what everyone comes up with this year!

Super Hyperpolyglot

2012-05-05T19:03:00+01:00

A few years ago nearly all the code I wrote was in C++, but increasingly I’m finding myself writing in a variety of mostly C-style languages and having to perform crunching mental gear changes as I switch between them.

In the interests of making these language switches less painful I thought about listing the commonly used features of the languages I commonly use in a side-by-side format. Luckily I’m a lazy programmer, the web is large and there’s nothing new under the sun, so I quickly found Hyperpolyglot which provides commonly used programming language features in a side-by-side format, which is what I wanted. Nearly.

Hyperpolyglot organizes it’s language comparisons in to several catagories: scripting languages, C++ family languages, embeddable languages and so on. In my case (and I suspect in many cases) the languages I wanted to compare were spread across several pages.

After briefly considering some cut and paste to get what I wanted I started playing with Google Spreadsheets, which has a very nifty importHtml function which allowed me to pull the Hyperpolyglot data in to several sheets which can be combined to produce arbitrary language comparisons.

It’s not perfect as different languages have different features and in some cases the Hyperpolyglot data doesn’t use exactly the same terms across tables (“version used” vs “versions used”) and I’m not a spreadsheet ninja, but it’s good enough to generate PDFs like this JavaScript Python Java C++ Comparision. As a Hyperpolyglot derivative work, The Super Hyperpolyglot Spreadsheet is licensed under the Creative Commons Attribution-ShareAlike 3.0 License, please let me know if you improve it.

100 robots Vs The Audience

2012-01-04T16:44:00+00:00

A couple of years ago I had great fun putting together the London Geek Community iPhone OSCestra at Open Hack London and I’ve been controlling Ableton Live with iPhone tapped to my guitar as part of 100 robots for a couple of years now so when @andybudd suggested I do a digital music thing for the Brighton Digital Festival I immediately thought that it would be fun to combine the 2 projects by doing a 100 robots performance with audience participation.

The iPhone OSCestra was effectively a distributed collaborative mixing desk with each person controlling the volume and effect parameters on one channel of a playing back Ableton Live set. For the 100 robots performance I wanted to go further and have the audience actually adding parts to the musical performance, so @toastkid and I added extra drum, bass, synth and sample tracks to the 100 robots live set and filled them full of samples that could be triggered by the audience.

While having the samples adjust in tempo to match each song was relatively simple, transposing them to match the key of each song was more complicated. First I built a custom slice to midi preset which mapped the sample transpose to a macro control and used it to slice all of the samples to MIDI tracks, then mapped all of the transpose controls to a single MIDI controller and added a MIDI track which output the appropriate controller value for each song to a MIDI output which was looped back in to Live to transpose the samples.

The next question was how to avoid the performance turning in to a mush if multiple drum tracks or bass parts were playing concurrently. To avoid this we put dummy clips on the normal 100 robots which muted the normal parts when the audience triggered parts were playing. In some cases we let the audience parts add to the music, in others the audience parts would play instead of the normal tracks.

A final question was how to avoid max and I getting lost when the normal parts we play along to were replaced by unfamiliar samples. To deal with this we set the clip quantization on the audience triggered clips to values longer than the clip length. This meant that even if alternate baselines were constantly being launched, we would still hear the normal bassline for a while at the end of each quantization period, so we would know where we were with the track. To tune these settings we did some fuzz testing with semi random MIDI data to see how much madness we could deal with and still manage to play the songs.

With the tests done it was time to perform with 100 robots and 100s of people at the Brighton Dome and Museum.

Many thanks to Steve Liddell for recording the Brighton Museum set, @aral for letting us experiment on his update conference and to everyone who participated and watched. If you’d like to host another performance, please get in touch and if you like the music, please check out the 100 robots blog and consider buying our album from bandcamp.

100 robots Attack!

2011-12-09T15:06:00+00:00

Lots of exciting 100 robots news! Our debut album, Attack!, has been professionally mastered by Chris at Melograf Mastering who has done an amazing job and made the album sound incredible. The new version is already available at bandcamp and will be available on itunes, amazon and many other download services on Monday. To celebrate the launch we’re playing live at The Hope in Brighton tomorrow night and have set up a new blog where we’ll be giving away a track from the album free every month and I’ll be doing most of my 100 robots related music blogging from now on. Head on over and subscribe to the feed so you don’t miss out. Hope to see you at The Hope tomorrow!

The JavaScript Jungle

2011-10-03T02:47:00+01:00

There was a slide in the early talks that Cory Ondrejka used to give about Second Life about alien abductions in Second Life. One of the most exciting moments in Second Life for the early Lindens was when a resident constructed a UFO and flew around the world abducting other residents and then returning them to the world with a commemorative t-shirt. It was exciting because it was unanticipated. The Lindens had created a virtual world that enabled interaction and someone had taken it and run with it to create a fun and engaging experience.

So, once I’d finished implementing a simple interest management and collision detection system for the Brighton Digital Festival JavaScript Jungle to enable interactions, I thought I would implement an alien abductor as a hat tip to Second Life.

The JavaScript first adds a UFO from You’re The Boss 2 to the supplied div along with an SVG canvas containing a hidden translucent tractor beam path before binding to the see and tick events. The tick handler implements a state machine which either moves the UFO towards a random spot, a target creature that the UFO has seen or drags the target off screen for diabolical experimentation.

The most interesting part of the code on line 155 which replaces the target’s position method with one which returns the target’s position, but doesn’t update. This allows the UFO to move the target while the position updates made by the target’s own code call the new read only position method. Tom Parslow‘s boids look especially mournful flapping around and turning towards the flock while being captured.

While the alien abductions in Second Life and the JavaScript jungle are meant to be fun and mostly harmless, the same mechanisms that enable them can be used for griefing in virtual environments and malware in software at large. The ability for scripted objects in Second Life to self replicate caused dozens of problems with grey goo attacks for every amazing virtual ecosystem and many malicious cage attacks for every playful alien abductor.

The message passing concurrency model adopted by LSL actually made direct attacks on other scripts of the kind used by the JavaScript Jungle UFO very hard, but things are much harder in JavaScript’s browser environment even when separating scripts in iFrames.

Luckily projects like Caja and Belay (which is being worked on by another ex-Linden, Mark Lentczner ) are working on the problem of making multiple scripts work safely in the same browser.

The challenge for sandboxes like Second Life and the JavaScript jungle is to allow interesting and meaningful interactions with emergent properties and unanticipated consequences without allowing malicious scripts to destroy that environment. Building the JavaScript Jungle was a lot of fun and made for another great Brighton Digital Festival project. Many congratulations to @premasagar, @ac94, @purge and everyone else for making it a success. Maybe next time we can try to build a secure JavaScript Jungle that is both secure and expressive.

Data Is Not Art

2011-10-01T00:11:00+01:00

This week I experienced two remarkable combinations of music and the moving image.

Natures 3B from Quayola on Vimeo.

This evening I watched Nature — Mira Calix and Quayola’s audio visual piece which took video footage of flowers blowing in the wind and used motion tracking technology to generate music from the footage. As a concept it was interesting, unfortunately as music it was terrible. The beauty of the footage betrayed the folly of the concept: if a human were to compose music based on the beauty of flowers the way they moved in the breeze might feature, but wouldn’t be the basis of the entirety of the piece. The colour, form and memories triggered by the flowers would surely feature. Turning the flowers to a network of points modulating parameters reduced them to an interesting if psuedo-random system and the resultant synthesised music was predictably cold and pseudo random.

By contrast, a few days ago I had the pleasure to watch Manhatta, a black and white movie about Manhatten made in 1920 by Charles Sheeler and Paul Strand and accompanied by a new soundtrack by the Cinematic Orchestra. Where Nature used machines to generate it’s soundtrack based on an algorithmic interpretation of the movement of flowers, Manhatta uses humans to generate it’s soundtrack based on the emotional impact of the moving image on the musicians. The result is infinitely more moving. The music adds emotion to the moving image, combining feelings of wonder, awe, fragility and insignificance — a uniquely human reaction to the images of the worlds most amazing city that cannot possibly be understood or rendered by an algorithm, no matter how clever.

Art is a human reaction to our world, not something that can be captured in an algorithm.

You’re The Boss 2

2011-09-12T22:53:00+01:00

A week ago over 5000 people streamed through the foyer of the Brighton Dome to see and build hundreds of amazing things at the first Brighton Mini Maker Faire. Luke and I went along with 2 laptops, a scanner and a pile of pens, paper, glue and scissors to make a video game with what felt like most of those 5000 people.

We arrived at 9:30 in the morning and were still working out how to plug out laptop in to the big plasma screen when the doors opened at 10:00. From then until the doors closed at 17:00 our table was a tornado of cutting, gluing, drawing and colouring as dozens of children and adults dived in to the task of drawing bosses for our shoot ‘em up with wild abandon. For a while my picture scanning, data wrangling and game copying efforts kept up with the stream of submissions and people were delighted to see their creations flying around on the big screen within minutes of their creation. Soon enough though, the stream turned in to a deluge and by midday I had a sizable backlog of pictures to process.

Despite working non-stop all day with only a 20 minute break to grab a milk shake and have a quick look around I ended up with a backlog of dozens of pictures at the end of the day. At that point another problem emerged: the game is designed to slowly get harder at each level, but with so many bosses to add the game would get impossibly hard before half of the bosses were seen. Realizing that I had a lot more work to do before the game would be finished I released an initial version at the end of the faire and collapsed in an exhausted heap at the after party.

All of this is by way of being a long winded explanation as to why “You’re The Boss 2” wasn’t finished a week ago. Last night I finally got around to scanning in all of the remaining images, tweaked the difficulty curve to make it possible to get to the end and released “You’re The Boss 2 Extended” which can now be downloaded here.

Despite being one of the most exhausting days of my life, it was also one of the most enjoyable. It was incredibly rewarding seeing dozens of children and adults alike delighting in creating something fun together and watching Thomas Truax perform with his DIY instruments while talking to a professional gingerbread house maker made for a truly magical end to the day. I’m very proud to have been part of the first ever Brighton (not-so) Mini Maker Faire and look forward to taking part in many more (although I might bring along a friend to help next time!).

I hope you enjoy playing You’re The Boss 2 as much as we enjoyed making it.

From Magic Circles To Magic Portals

2011-09-11T21:18:00+01:00

The Brighton Digital Festival continued this weekend with BarCamp Brighton 6 which was super interesting and lots of fun as always.

I was a bit worried that my Terra Nova style talk on the philosophy of games, virtual worlds and magic circles would be too esoteric, but the room was packed and the talk generated some great discussion.

A video of the talk is now available at The Internet Archive thanks to @stevepurkiss and the slides are available on SlideShare. Thanks to everyone who came along to my talk and BarCamp and to @jaygooby and @profaniti for organising a wonderful event.

dConstructing Augmented Reality

2011-09-08T15:45:00+01:00

One of the events that kicked off Brighton Digital Festival was dConstruct, the always thought provoking conference run by clearleft.

As usual I found most of the sessions interesting, but not always relevant as there’s a heavy design rather than development focus. The most relevant talk this year was Kevin Slavin’s final talk, Reality is Plenty, which argued that augmented reality is not the next big thing, just as it wasn’t in 2005.

Despite Kevin having a dig at Second Life and having spent a lot of time working on Augmented Reality with Blast Theory while at Nottingham University, I mostly agreed. While there are definitely use cases which benefit from augmented reality (fighter pilot navigation systems and things like Carbon Goggles which are all about making invisible aspects of objects visible) and virtual reality (simulation and virtual meeting spaces) there are plenty of others which are better served by other interfaces. Environments like Second Life are particularly exciting as they allow people to quickly prototype systems to discover which applications work and which don’t.

With both AR and VR it’s tempting to argue that they allow for intuitive interfaces as they model or overlay the real world: people know how to navigate a 3D space so they know how to use a 3D environment and they know how to use AR as they can see. Anyone who has done their time climbing the Second Life learning curve or trying to use AR to find their way around will know this clearly isn’t true. Apparently more abstract interfaces like maps, which talk to the mind rather than the senses are often much easier to use.

There’s a lot of work to be done to make both AR and VR as easy to use as 2D interfaces, let alone as natural as using real world senses. Now that the huge technical problems around networking virtual environments and tracking real world objects with mobile devices are starting to be solved, it is mostly UI work that needs to be done to make these technologies more widely used.

Even if the UX issues are solved there will still be many cases where speaking to the mind is much better than speaking to the senses.

Introspecting Python Decorators

2011-08-25T17:05:00+01:00

Over the last couple of years I’ve found myself using python decorators to annotate handlers for web requests more and more, both when using Django and with micro-frameworks like mnml and newf.

Where the same functionality is required for all handlers, or the required functionality can be determined from standard request or response headers, using WSGI or Django middleware is fine, but where the required functionality is varies based on the handler its much cleaner to use a parameterised decorator than poluting the environment or response objects just to control the middleware. Functionality can be added to a framework as a suite of decorators and plugged together in an aspect oriented way like lego to easily build up sophisticated behaviours.

Unlike other mechanisms for implementing macros, templating or aspect orientation that introduce a new language, python decorators are pure syntactic sugar that under the hood are simply rewritten as python expressions:

@requires_oauth_scope("email")
def notify_friends(request):
    pass

Is simply shorthand for:

def notify_friends(request):
    pass

notify_friends = requires_oauth_scope("email")(notify_friends)

This simplicity is powerful as it allows decorators to also be used as normal functions, for example to build up higher level decorators that bundle common decorator configurations, but it also means that decorators potentially interact badly with another powerful Python feature: introspection.

In the above example the undecorated notify_friends function has the name “notify_friends”, but the decorated function has the name “requires_oauth_scope”. When decorators are used extensively, this can seriously impact the usefulness of introspection for debugging or generating documentation.

Decorating your decorators with the functools @wraps decorator, which copies the name of the wrapped function over to the wrapping function solves this introspection problem, but introduces another: the decorators now become invisible to introspection. In the example above the name of the decorated function would now be “notify_friends” as in the undecorated case, but we wouldn’t know that the function had been decorated or not.

A potential solution to this new problem is to store the details about the decoration in another attribute that can be inspected at runtime. In addition to copying over the name attribute, functools.wraps also copies over the target dict by default, allowing it to be used to store information about the decoration and be correctly copied over when decorators are chained:

from functools import wraps

def requires_oauth_scope(scope):

    def decorator(target):

        target.__dict__["my_project_requires_oauth_scope"] = scope

        @wraps(target)
        def wrapper(*args, **kwargs):
            # return target(*args, **kwargs) or FORBIDDEN if token does not have required scope

        return wrapper
    return decorator

By constructing decorators in this way we get the benefits of python decorators and more declarative C# style attributes that are visible to introspection.

You’re The Boss Lives!

2011-08-17T18:21:00+01:00

Back in 2005, while I was working on Second Life in Nottingham, before Linden Lab Brighton existed, I ran a workshop as part of the Screenplay “Boss Frenzy!” day at the Radiator Festival which allowed children to collaboratively create a computer game by drawing or making bosses with collage.

Dozens of people came to the Broadway in Nottingham and got busy with pens, pencils, paper, scissors, glue and magazines to design bosses for our “You’re The Boss!” shmup. We had an amazing time and created a charming and delightful game which I talked about on the original Second Life blog.

I immediately thought of it when we started planning the Brighton Maker Faire a couple of months ago and was delighted when the project was accepted. Unfortunately 6 years of bit rot had taken it’s toll and disaster loomed after discovering that I’d hosted the Game Maker files on the web space provided by an old ISP account and didn’t have them on my patchy backups. Luckily the ever amazing Torley had a copy of the executable and with the help of a decompiler I was able to recover the Game Maker files I needed to run the project again.

So, if you’re near Brighton on the 3rd of September and like the idea of collaboratively making an arcade game with scissors, glue and pens then please come along. If you have a Windows machine then check out the game we made in Nottingham in 2005. I think it’s still charming and delightful 6 years on. You can download it here.

This time round I’d like to make the game completely out of Creative Commons licensed works, so please suggest CC licensed books, comics and pictures that might make good source material in the comments, or bring them along on the day.

Google+ First Thoughts

2011-06-30T04:55:00+01:00

After months of rumours it’s finally here, so what is Google+ like? My first thoughts are that it’s super slick and that Circles definitely makes it different, but I’m not sure better.

Limiting the distribution of shared information will likely also limit the growth of the network, something that’s not going to help Google+ grow to Facebook’s size. Will the limited sharing encourage more sharing? I’m not sure. There have certainly been a couple of times when I’ve held back from sharing inside Google Reader as I know not all of my Facebook friends will want to see it when it’s sent to my wall via FriendFeed but that doesn’t happen often.

When sharing inside Facebook directly I already have the choice of publishing to my friends via my wall, or to a particular group wall and I make that choice when I share. People have the choice of joining a group, or or adding me as a friend, or both. I choose where I publish when I publish and they choose what they subscribe to. Having to partition contacts up front, before I have anything to share, is harder. Maybe it will become more natural, but currently it feels weird. The sharing itself is also harder, feeling a lot more like composing an email, having to choose recipients than just a place to post.

Circles apart, Google+ definitely feels somewhat early and skeletal. Hangouts look like a nice group video chat feature, but it’s difficult to judge with so few people currently on the network. Sparks doesn’t look like it will ever be as useful as Google Reader to filter information on interests and, given the focus on social sharing, feels like a bootstrapping mechanism more than a long term feature. Mostly Google+ feels like a weird, empty, alternate reality version of Facebook with more primary colours, which is to be expected.

There’s a long way to go, but I’m glad Google has made a start. Google+ feels like it could be both a real competitor and alternative to Facebook, which is a good thing. One horse races are never very interesting to watch.

“100 robots attack!” Album Out Now!

2011-05-19T09:30:00+01:00

100 robots first album, “Attack!” is now finished and available to download now from bandcamp. I’m so glad that it is done and very proud of the result. It’s the first album I’ve made since 2005 and the first I’ve produced using Ableton Live, which once again proved to be an amazing piece of software. The ability to quickly cycle through libraries of samples to find the right sound, easy parameter automation and super flexible routing using drum racks were a huge help.

It’s also the first time I’ve tried to put together a big rock/dance production at home which made mastering tricky as we wanted both a big loud rock sound and huge slabs of sub bass. Because the of the huge sub bass, the Fletcher-Munson effect meant that while the RMS loudness of our initial mixes were normal, the a-weighted RMS values were very low, making the mixes sound very quiet when burned to CD.

The mixes couldn’t simply be turned up without clipping or compressing the mixes which would introduce distortion or reduce the dynamic range of the music. Not wanting to get sucked in to the loudness war we ended up in a complicated 3 way trade off between a-weighted RMS, sub bass weight and dynamic range. Audioleak and the Pleasurize Music tools were both really helpful during this process. We ended up with an an album that hit the sweet spot of -14 dBFS A-weighted RMS, has an average dynamic range of DR6 (admittedly less than the recommended DR10) and hopefully still has enough sub bass to work on a big system. A couple of people have commented that it sounds over-compressed, but most people seem to like where we ended up.

I hope you enjoy the album and that you can join us at the launch parties at the Hydrant in Brighton on the 31st of May or at the Maze in Nottingham on the 14th June — they’re going to be great nights!

Attack! by 100 robots

21st Century JavaScript

2011-03-12T14:05:00+00:00

The slides and video of my talk at AsyncJS on Thursday are now online. The video is pretty murky, but the sound has come out fine and you can see enough of the slides to be able to follow along at home. The talk focuses on ways to bring useful software engineering patterns to JavaScript, patterns that will be increasingly important as JavaScript applications become larger and more complex.

Thanks to Prem for inviting me to talk and to everyone who came along to the Async session for the fascinating discussion.

The Why and How of Automated Testing with Python and Django

2010-11-04T09:54:00+00:00

Jamie has just uploaded the movie of my talk “The Why and How of Automated Testing with Python and Django” which I gave at BrightonPy a week ago (and this time it really is a movie, clocking in at a feature length 1 hr and 35 minutes). The audio on the video is fine (and arguably the laptop-eye-view video is improved by chopping my head off for large parts of the talk), but it’s tricky to see the slides on the video, so I’ve uploaded them to slideshare.

The talk rambles a bit in places and there are a couple of things that betray my static language roots for example you can’t actually use unit tests to discover dependencies as easily in python as you can in C++. I’m also already evolving the JS testing stack I talk about here: moving from qunit, qmock and Selenium to jsmockito and possibly JsTestDriver. Overall I think it’s a pretty good overview of how an agile software engineering process can be screwed together.

Many thanks to @garethr for donating his Fabric scripts, Spike for his database migration cameo, Si for recommending Hudson, Dave for hooking me on automated testing and j4mie for organising the night and wrangling the video. If you’d like me to help your organisation improve its agile engineering process, please get in touch.

Goodbye Babbage Linden, Hello Doc Boffin

2010-10-23T14:04:00+01:00

In June 2004, not long after Cory had introduced me to Second Life, version 1.4 was released which added Custom Character Animations. In the accompanying press release Philip said “My fantasy is to be Uma Thurman in Kill Bill”, “I’d pay \$10 for her yellow jumpsuit and sword moves and I’m sure other people would too.” I’d been looking for something to build in SL and also been thinking about melee combat systems in RPGs which traditionally just leave the tanks hacking away while the others get loads of different fun and interesting abilities to use. At the other end of the spectrum arcade fighting games give players lots interesting choices to make, but require twitch reflexes that require low latencies that are difficult to achieve over networks let alone in SL. Building a tactical melee combat game in Second Life sounded like the kind of interesting challenge I was looking for, so at the end of 2004 Doc Boffin and Jaladan Codesmith set out to build what would become Combat Cards.

The early versions of the game were built in to weapons and employed a simple llDialog interface for selecting moves, but the core mechanics were very much as they are now. HUDs were introduced In October 2005 with Second Life 1.7 and I immediately started thinking about converting the game in to a trading card game — a business model that seemed to fit perfectly with Second Life’s micro currency based economy.

A trading card game needed an artist and after looking for one on the SL forums I was very lucky to find the wonderful Osprey Therian who preceded to blow my mind producing amazing artwork and taking incredible pictures of the fantastic avatars of Second Life for what became Combat Cards.

Working on the game while working at Linden Lab gave me insights in to how Second Life felt from a residents perspective. Despite Second Life’s flexibility, it’s a lot harder to build complex systems than it should be. Building systems that can send out product updates is fiddly, error prone and something that should be in the platform, LSL’s memory limitations mean that I often spent more time cutting scripts up or trying to save memory than building features. When the number of cards and so data increased, Combat Cards ended up having to incorporate a paging system to load lines of notecard data in to memory asynchronously in order to continue to work. This hugely frustrating and time consuming experience led directly in to the discussions and design around Script Limits which will allow Mono scripts to request as much memory as they needed.

Learning about building businesses in Second Life was also incredibly valuable. As a multi-player only game, Combat Card’s biggest challenge has always been getting enough people together at the same time to play, something that has resulted in a series of wonderful parties and regular events often hosted by the amazing Kat Burger. It also resulted in the exploration of linking Second Life with social media that led to Combat Cards arenas tweeting game results and then the LSL Twitter OAuth Library that allowed players to tweet results from their own accounts without disclosing their Twitter passwords. When we finally found a print on demand service that allowed Combat Cards to make the jump to RL it also allowed us to explore the possibilities for linking RL and SL businesses that resulted in the system for buying gift certificates for L\$ in SL that can be redeemed for physical Combat Cards in the online web shops.

Keeping my Babbage Linden and Doc Boffin identities separate for over 6 years has given me incredible insight in to what it’s really like to be a Second Life resident, but it has been exhausting. There was an awkward moment in 2006 when I had to tell Philip that I worked for him when he came to check out Combat Cards, Osprey only found out that I was a Linden in 2008 when I emailed her a version of the RL rules sheet that Word had helpfully annotated with my name and I had to come up with a dweeby Doc Boffin voice to disguise my identity when commentating on Combat Cards matches on YouTube. It’s a huge relief to finally be able to come out of the closet and talk about Combat Cards openly. I’m incredibly proud of what Osprey, Jaladan and I have achieved with the help of Kat, Comragh, Spin and our amazing player base, to whom I apologize to for sometimes not being able to devote as much time as I’d like to Combat Cards. My other Second Life as Babbage Linden often kept me pretty busy.

Now that I’ve left Linden Lab I hope to still find some time to work on Combat Cards and hope that it will now be easier to pursue the full publication of Combat Cards in real life that Osprey’s amazing artwork deserves. I’m very happy to announce that Combat Cards 3.0 and the long awaited Robot Series of cards will be launching on 31 October and hope to see you all at the launch party at 2PM Pacific (Second Life time) at the Combat Cards Arenas in Europa. I’ll leave you with Osprey’s latest amazing promo for the event.

Spawning Django Blogs

2010-10-18T16:25:00+01:00

Since leaving Linden Lab I have been talking to a number of people about doing freelance consulting and development work while I get my start-up off the ground and last week got round to setting up a UK limited company so that people will actually be able to pay me.

Setting up a company is insanely easy these days: if you go to companies made simple it will cost you less than £17 and 10 minutes of form filling. Coming up with a name is harder, but within a couple of hours I found that 18dex was available as a .com TLD, twitter account and facebook username. Meaningful 5 character .coms are pretty tricky to come by these days, so I snapped it up and 18 Dexterity Ltd. was born — a pretty fantastically geeky name for an agile software engineering company I hope you’ll agree.

A few minutes later I had a holding page up for 18dex.com, but it looked pretty sad with no content, so I started thinking about setting it up as a blog. I have a stack of relevant software engineering posts on jimpurbrick.com from the last few years, but they are sandwiched between less relevant posts on 100robots, Second Life and various miscellany. I didn’t want to move the software engineering posts from jimpurbrick.com as they’re part of what I do and regularly updating a single blog is quite enough work. I also didn’t want to copy the posts from one blog to another as it would potentially end up with 2 independent comment threads on each blog. There would be no definitive version of a post, a blatant violation of Don’t Repeat Yourself.

Luckily Django includes a piece of machinery to deal with this problem in its sites framework, something I’ve been meaning to have a closer look at for some time. The sites machinery simply lets you associate a piece of content with a site and keeps track of the current site, allowing you to filter the content in the database to only show a subset on each site.

While the byteflow blog engine I use for jimpurbrick.com supports the sites framework, each post is associated with a single site via a ForeignKey. In order to allow posts to be shown on both jimpurbrick.com and 18dex.com I had to change that ForeignKey field to be a ManyToManyField: a single line change in the python code, but something that requires a little wrangling to massage the existing data to fit the new model.

I’ve been using the excellent South in all my recent projects to allow me to easily migrate data across django model changes. Although jimpurbrick.com dates from long before South was available I managed to convince south to manage the migration by dumping the blog_post table to json, dropping the table and recreating it with south, reloading the data and then letting south migrate the data to the new ManyToMany schema. While this was slightly more fiddly than it could have been it means that the blog app is now being managed by south, which will make future development on the blogs much easier.

Once I had migrated the data to the new model and associated the software engineering posts in jimpurbrick.com with both sites in the django admin interface all that remained was for me to clone the jimpurbrick.com directory with mercurial to create an 18dex.com directory and choose and tweak a byteflow theme for the new site.

Once again I’ve been very impressed with Django and Byteflow, which have proven to be incredibly powerful tools that are very easy to work with. In a few hours I was able to create professional and personal views on to my blogging which can be easily administered from a single interface and allow comment threads and users to easily flow between them. If you’re just interested in my software engineering posts, head over to 18dex.com, if you want to hear about music, Second Life and everything else I get up to, stay subscribed to jimpurbrick.com. If you notice anything broken on either blog, then please leave a comment to let me know.

Another Age Must Be The Judge

2010-09-29T16:15:00+01:00

Almost exactly 6 years ago, the incredible Cory Ondrejka and I met for the first time in real life (having previously blogged together on Terra Nova) at the Austin Game Conference 2004, where we got on like a house on fire. Several months later I joined Linden Lab and (as James and Jim Linden were already taken) Babbage Linden was born. The first task Cory asked me to do was embed the Mono virtual machine in to Second Life as a next generation scripting engine. It was a wonderful project to work on, involving authoring a new LSL compiler back end to generate CIL bytecode, a scavaging garbage collector to allow assembly unloading and a microthread injector to allow 10s of 1000s of scripts to run concurrently on Mono in a single process (work that has been described in detail in talks at ooPSLA, Lang.NET and FOSDEM ). As a long term R&D project it was put on hold a number of times to make way for more important projects like HTTP-Out, Message Liberation and Het-Grid, but eventually we shipped a Second Life simulator that embedded Mono in 2008.

Running LSL on Mono in Second Life was a huge win, allowing scripts to run 100s of times faster in some cases and reducing the average memory footprint of scripts in Second Life by a third, but the big hairy audatious goal for Mono in Second Life was always to enable other languages that targeted the Common Language Infrastructure to run in Second Life. After waiting until the end of last year for Mono 2.6 to implement the bytecode verifier and CoreCLR security sandbox which allowed us to safely run other languages on Mono inside the simulator we started work on adding support for C# in Second Life at the beginning of this year. A team of Linden engineers in Brighton and California did an amazing job overcoming an array of challenges and got to the point where we had Silverlight chess demos, run time configurable script profilers and scripts that used .NET reflection APIs to visualize other C# scripts running in our development simulators earlier this summer.

Alas, tomorrow is my last day at Linden Lab and Babbage Linden will never get to see C# scripts running in the wild in Second Life, but I very much hope that I do. I hope that C# support is eventually added to Second Life and that I don’t have to wait 170 years to turn the handle. As another Babbage said when he failed to build the Difference Engine: “Another age must be the judge”.

Meaningful Choices

2010-09-27T17:23:00+01:00

On Friday I jumped on the train to London to attend Playful 2010, a one day conference put on by mudlark of World of Love fame. Despite billing itself as a day of cross “disciplinary frolicking” and featuring designers, podcasts, discussions of narrative, iphone augmented paper games and Disco Snake the thing that stood out for me was a thread running through the talks that addressed a fundamental of game design: meaningful choices.

Jonathan Smith talked about the dangers of giving people too much freedom in his talk about the Lego Games. Lego is almost a shorthand for freedom: the easy to understand system of knobs and anti-knobs that allows 2 4x2 blocks to be combined in 9 million ways an ultimate sandbox aspired to by games and virtual worlds like Second Life. This open, free system led Travellers Tales to add lots of open, free features to it’s early Lego games that were largely ignored by players who need boundaries and feedback from the game to determine ‘what I want versus what’s expected of me’. Choosing freedom and rebellion is more meaningful when it is clear that I am exercising my freedom and not doing the expected.

Margaret Robertson talked about and in the current sandbox game du jour, Minecraft, which has enough terror and threat in its horror filled night to make the choices made during the day meaningful and to reward mastery of it’s sandbox — a sandbox that compelled Margaret to stay up until early in the morning carving her slides out of earth, building them out of wood and animating them with flowing water and flames burning down the assertion that “games = points”.

It was this misguided assertion that Sebastien Deterding talked about in his look at the ‘gamification’ of the world around us. When all that gamified web sites like foursquare do is allow the accumulation of points and badges there are no meaningful choices, no mastery, no way to rebel against expectations, no play and no fun. Gamification results in loyalty schemes that are no more meaningful than Progress Quest.

The importance of being able to rebel against expectations was echoed by Alexis Kennedy’s talk about delicious misery in Echo Bazaar, a social game that would be another meaningless progression to inevitable success if it weren’t for contrarian missions that allow players to opt-in to getting their characters exiled for scandal or driven insane by demons. These missions inflict real harm on characters, but when properly signposted are the most enjoyed and shared missions: allowing players to be badass. When a game makes success inevitable, misery and failure is play and meaningful escape.

Pat Kane, formerly of Hue and Cry and more recently author of The Play Ethic gave a fascinating talk about wordplay, humour and his journey from disillusionment at the comedy industry, to fascination with humour through the Old Jews Telling Jokes’ stories of Jews laughing in the face of persecution. When misery and failure is inevitable, humour and play is rebellion. An ultimate, meaningful demonstration of freedom and humanity when all hope of victory is gone.

Disco Snake

2010-09-15T17:25:00+01:00

Rock Band does a great job of inspiring people to play music, can you develop a game that inspires composition? Lumines and Rez create music while you play, can you make games where music creation is the goal, not a side effect? Pictionary does a great job of using game mechanics to overcome creative block, can you use other game-like constraints to inspire creativity? These were among the questions I asked at GameCamp 2 a few months ago and I was keen to explore them at Music Hack Day London a week ago.

The spectrum of potential game-like musical composition tools is huge, ranging from traditional recognisable music interfaces like keyboards and step sequencers at one end, through things that are designed to be both music interfaces and games like Fractal, Rez and Lumines in the middle to things that are recognisably games at the other. While the middle ground is incredibly interesting, 24 hours at a hack day isn’t really long enough to develop a brand new revolutionary hybrid game/music interface, so instead I decided to repurpose an existing game as a sequencer and picked the simplest one I could think of — Snake.

With the interface chosen, the next thing to do was to think about how to map the interface to music composition. The core mechanic in snake is eating food placed on a grid. Grids have a venerable history in music as step sequencer interfaces with time growing form left to right and pitch or samples selected on the y axis. It seemed natural to map food position to note parameters in a similar way. Using the order in which food is selected to determine the order of notes played frees up the X axis to map to a parameter instead of time and also makes playing the game feel more like a progression through a composition: each piece of food adds to the sequence which is continually looping, the music plays and the composition progresses, there is no turning back or revising. By mapping the X axis to velocity pseudo rests can be added to the sequence by selecting food on the left.

Selecting notes requires some deviation from the normal snake mechanics which normally only make a single piece of food available at any time. This restriction would mean that players wouldn’t compose music, simply reveal it as they ate one piece of food at a time. At the other end of the spectrum turning every square in to food would mean that the next selected note would have to be adjacent to the last note, also overly restrictive. Making a limited number of pieces of food available at any time provides a nice middle ground, allowing the player some freedom in the choice of the next note selected, but not total freedom, a restriction which can lead to serendipitous melodies.

The other major mechanic in snake is colliding with your tail, which ends the game, but becomes harder to avoid as you eat food and get longer. One option would be to use that mechanic to intentionally end the game and the composition, but instead I mapped it to sample selection allowing the player to switch between sounds and start a new sequence to build up multi-timbral polyphonic music. By making the world toroidal players can simply let the snake circle around the world when they have finished composing.

A lot of these design decisions came out while implementing the game using processing/processing.js and HTML 5 audio — a technology stack I’d played around with a bit previously, but wanted to explore further. In the end, for this kind of application I don’t think processing brings enough benefit to outweigh the difficulties it adds to debugging. When running on top of Java errors are often reported as mangled Java call stacks and when running in the browser different errors appear as mangled JavaScript. While I can see the attraction to language designers and implementers of building on top of existing technology it often results in having to implement in one language and debug horrible unrecognisable code in another. Incompatibilities are also horrible. With a couple of hours to go I had the entire game running on Java, but was presented with a blank canvas with no useful Firebug errors when I exported to processing.js and having to perform a binary search by commenting out chunks of code to find the error. Not pleasant.

HTML5 audio is also a somewhat fragile technology. Generating an Audio element for each sample playback event leads to current browsers grinding to a halt while resetting and restarting audio elements often causes glitches and delays. Another problem is that JavaScript timers don’t provide enough accuracy for tight sequence playback timing. In the end I rebranded both bugs as features by switching from very transient drum samples which sounded messy to dubby bass and melancholy bell samples that work quite nicely with glitches and unintentionally loose timing.

At 10PM on Saturday night everything had come together enough for me to lose myself in an hour of ambient bleepy electronica and by the time the presentations started at 3PM on Sunday Disco Snake was done.

I’d like to thank all of the organisers and hackers that made Music Hack Day London a wonderful experience and have been pleasantly surprised at the positive reaction that Disco Snake has generated over the last week. The space between music interfaces and games is a very fertile one that I’ll be exploring further in the future and while it’s not there yet, I hope HTML5 audio fulfils its promise of bringing interactive music applications to everyone on the web in the very near future.

HTML 5 Audio Redux

2010-09-04T12:01:00+01:00

My recent experiments in to using Procssing.js and HTML5 audio to generate multimedia web applications didn’t get very far. I first tried generating a new HTML 5 audio element for each audio event, which quickly caused the browser to grind to a halt, and my attempts to reuse audio elements by resetting the playback position didn’t seem work, leading me to conclude that HTML 5 audio was only really useful for playing back long audio files, not for building sequencers that play back many short samples. When I spoke to @rem about my findings he was convinced that resetting audio elements should be possible and this weekend’s Music Hackday London has provided the perfect incentive and opportunity to dust off my experiments and start tinkering again. An hour in and sure enough I’ve managed to get audio elements to reset: it seems that the trick is to set currentTime after calling play() on the element, something that seems very counter-intuitive, but seems to work (at least in Firefox 3.6.8 and Safari 5.0.1 on OS X 10.6.4). Now I have reliable sample play back it’s time to start playing around with more interesting interfaces in Processing and there are 26 hours of hacking left: game on!

Some Games Never Die

2010-08-02T01:30:00+01:00

While goofing around asking UK indie game developers for their top 5 games of all time at World of Love, I was very pleased to hear that the amazing ZX spectrum strategy game Chaos featured in multiple lists.

I love Chaos so much that I developed Law, a Chaos remake at university as a way to learn Java. It turns out that a bunch of other people love Chaos too: a year or so ago one of the administrators of the Chaos Remakes Wiki got in touch with me to say that he’d been able to pull a copy of my original web site from an archive and wondered if I still had a copy of the game itself. The reminiscing at World of Love was enough for me to finally wade through decade old backups looking for a copy of Law and I’m happy to say that I found a copy and that it still runs on modern Java runtimes.

If you remember the original Chaos, head over to the Chaos Remakes Wiki and indulge in some retro gaming nostalgia. If you’d like to tinker with it (please fix the yellow text on grey dialogs and add AI wizards!) the code is available under the GPL license from BitBucket.

World of Love

2010-06-26T17:03:00+01:00

Thanks to a tip off from David Hayward, I managed to snag a last minute ticket for the World Of Love independent games conference organized by Pixel Lab, sponsored by Preloaded and hosted by Channel 4. I’m glad I did.

The day kicked off with Chris Delay from introversion demonstrating Subversion, a typically minimal game inspired by Mission Impossible (the TV show, not the movies). It ticked a huge number of boxes for me as a game, but the most interesting thing about the demo is that the game is nowhere near finished and it’s not often you get to see a game this early in production. I suggested to Chris that the game should feature Sporty Spy, Posh Spy, Ginger Spy and Scary Spy. Look out for those in the final version.

Possibly the most inspiring session of the day was Terry Cavanagh’s talk on game jams. Setting the scene with a description of his stalled over ambitious uber project, Terry the rattled off an amazing list of games he made at game jams like Sinewave Ninja which ultimately morphed in to the amazing v six times. I’ve had a ton of fun building mashups at Hack Days so I can imagine adding games to the mix would be amazing. I predict game jams will be coming to Brighton in the very near future…

Definitely the most amazing talk of the day was by Eskil Steenberg who was delighted to be talking at the first conference dedicated to his game, Love. After a brief tour around a beautiful procedurally generated and fully dynamic world, Eskil showed off the amazing tools that have allowed him to build an on line game on his own. A suite of networked art tools allowed him to model then procedurally UV map and texture a 3D model and then demonstrate how altering the model would result in updated UV maps and procedural textures in real time. It was like being given a tour of the future and when Eskil ran out of time I fully expected him to pull out a time machine to allow him to keep going.

The rest of the day included lots of really useful advice for indie game development including talks on business, finance, law and marketing which ended with the Frozen Synapse developers bursting in to blast the attendees with water pistols to demonstrate Kieron Gillen’s last marketing rule — you’re creative, so be creative with marketing.

Overall I prefer the many tracks and everyone gets involved format of GameCamp and at times the talks devolved in to extended biographies, but mostly it was a fun, thought provoking and inspiring day. I spent the evening asking the attendees for their top 5 games (it felt like it was that kind of event) and was very pleased to hear Chaos featured in multiple lists (it’s one of my favourites too, I developed a remake at university. On the strength of the UK indie scene demonstrated at World of Love I’m sure we’ll be seeing more indie games in top 5 lists in the near future.

HTML 5 multimedia

2010-06-07T23:14:00+01:00

I’ve been morbidly fascinated by the Rich Internet Application technology blood bath for a while now: Whirled,Metaplace and others tried to stuff virtual worlds in to web pages using Flash, Second Life stuffed Flash in to virtual worlds via Webkit, Unity stuffed Mono in to a 3D engine and then took on the world and Silverlight and Moonlight stuffed the CLR in to web browsers and Erik Meijer stuffed a CIL interpreter straight in to Javascript.

All good fun and there are fortunes to be won and lost to be sure, but the smart money seemed to be on waiting for the dust to settle and then using the winning technology. Recently, however, amazing technologies like V8, Node.js and the resulting browser Javascript arms race have been adding weight to the Google viewpoint that all you need is Javascript: a philosophy made more pragmatic by Apple’s decree that all you get is Javascript.

A week or so ago I decided to test the hypothesis by building a drum machine using only HTML 5 and Javascript. My first discovery was that while the canvas element is perfectly capable, it’s a very low level API, even for building something as rudimentary as a step sequencer interface. After looking at a number of drawing libraries I settled on processing.js as a higher level drawing API, something I’ve been meaning to play with since we used it to build SLorpedo at Hack Day a few years ago. Processing.js is a neat hack, that despite an incomplete API and some subtleties around casting does a great job of running processing sketches within a browser without a plugin. It also uses a sloppy parser enabling you to drop arbitrary Javascript in to your processing sketch, which makes it easy to just create Audio() objects within the sketch to playback audio. Unfortunately while it was easy to add audio playback, the playback itself was pretty disappointing: Firefox just spluttered and belched sadly while Safari did a decent job of playing beats for a couple of minutes before its timing went to hell and then the browser crashed. The shiny future may yet be HTML 5 and Javascript, especially when the experimental extensions to Firefox become widely supported, but we’re not there yet.

Always Watching Out Now!

2010-05-17T10:14:00+01:00

Always Watching is now available to download from iTunes, amazon, 7digital, juno download and songrilla — buy it now!

If you’d like to remix the song or video, you can get the parts under a Creative Commons Sampling Plus Licence via BitTorrent.

Read more about the making of the track and the encroaching survellance state here.

GameCamp 2

2010-05-10T20:56:00+01:00

A couple of years ago, Aleks Krotoski and a group of friends spanning the web, games and technology fields decided to bring the FOOCamp and BarCamp model of unconferences to the world of games and invited me along. I had a great time at the original GameCamp and missed it last year, so when I heard about the return of GameCamp a couple of months ago I jumped on a ticket and eagerly got on the train early on Saturday morning to participate in another inspiring mind expanding day. I wasn’t disappointed.

The cultural differences between the worlds of games and the web we touched on in a couple of sessions. “The PC Is Dead, Long Live The PC” quickly turned in to a discussion of open platforms like the PC versus closed, console like channels. While the long term view was that in 50 years open will prevail, the present sees controlled channels like XBLA, the various Apple stores and Steam in the ascendant. Some people will wait until titles are available on a particular channel, suggesting that they offer some advantages in terms of convenience, support or peace of mind. While this may be OK where there is competition between channels, games cannot be as easily distributed via multiple channels, with platforms like Steam requiring relatively invasive changes to be made to allow things like overlay menus to be displayed over game UIs. Where choices between channels is not possible the whims of platform controllers can make development extremely risky when policy changes or simply under staffing can delay or scupper a release.

Steven Goodwin asked why open source can build Linux, but not games. While the first answer is that Linux is a platform that can be shared by anyone whereas games are more individual expressions of creativity, that still begs the question why aren’t there more open source game platforms? Games seem to slowly be moving towards more shared and open infrastructure, but still lack the equivalent of the LAMP stack, HTML, CSS and JavaScript provide a shared web platform that allows web developers to share tips and tricks at BarCamps.

Luckily, the inability for game developers to give talks on the equivalent of squid configuration leaves room for lots of interesting talks on higher level game design concepts. 2 of the most interesting were hosted by Margaret Robertson, the first was on Curiosity — an urge which is hard to explain in classical or behavioral economics, and which is more powerful when the unknown is close and definite, a closed box on a table that must be opened, than when the unknown is distant and amorphous. The session turned in to an interesting comparison between risk, where outcomes are known and curiosity when the outcome is unknown, how both can be manipulated to make games more compelling and whether that manipulation could be a force for good as well as evil. The second of Margaret’s talks was about a forthcoming audio only binaural iPhone game and the challenges of navigating a world without light, which sounds fascinating, if hard.

Tom Armitage hosted a session which asked “What Do Cows Call Thermodynamics?”. The answer is, probably nothing, but it still affects them. So it is with games, which are ultimately defined by their rules and mechanics which can be used very creatively. The rule that Yorda is afraid if you don’t hold her hand dramatically shapes your relationship with her, the rule that you aim better while doing a stunt is what turns action quake in to a John Woo simulator.

Another arc that ran through GameCamp 2 was a discussion about creativity. Pictionary and Scrabble were used as examples of games that foster creativity while players of World of Warcraft show amazing creativity despite the game in a session that had many echos of the Playfish talk at Develop last year. At the other end of the spectrum, a session on procedurally generated content asked could algorithms create good content and if they could, how would they know?

My “Social Music Composition Games?” session at the end of the day continued this arc. I first played Rock Band at the first GameCamp and since have played it so much that I ended up starting 100 robots with Max. Since then I’ve been playing with tools like Ableton that have very game like interfaces and games like Lumines that have very sequencer like interfaces. Could you use interfaces like these to build games that do for music composition what Rock Band does for music performance? If so, how would you judge the compositions? Something that combined the interface of Lumines or the Tenori-On and Digg like filtering and tagging might be very interesting here…

Always Watching The Watchers

2010-05-01T15:44:00+01:00

On May 17th, the first 100 robots single, Always Watching, will be released online via Amazon, iTunes, emusic, Rhapsody, napster, spotify and many more digital outlets.

Always Watching has been one of the most satisfying projects I’ve ever worked on. Using a commodity PC and the incredible Ableton Live music production software, Max and I were able to compose, record, arrange and produce the track, sharing versions online using the free and open source Subversion revision control software and downloading freely reusable samples from the amazing freesound online sample site.

With the music done we were able to produce a DIY video for the track, filmed and directed by our friend Chris Cole again using digital technology that would have been out of reach of anyone but film studios a few years ago. After an incredibly fun day running around Brighton recording shots we could again get additional material from the internet, in this case footage of internet luminaries Chris Anderson, John Battelle, Sherry Turkle and Lee Tien interviewed about online privacy for the BBC virtual revolution series which were released online with a permissive license that allowed us to reuse them.

With the video in the can it was time to promote the track online using the social network sites MySpace, Facebook Sound Cloud and Last.fm, make a remix pack available via Bit Torrent and sell the track via Zimbalam, a site that that makes music available for sale on all of the major online stores, using artwork that we found on Flickr and that Rainer Messerklinger kindly let us use.

It really has been an amazing and eye-opening experience. Using cheap digital technology, the internet and a DIY spirit we have been able to create, promote and sell our music to the world and while I don’t expect to make a ton of money from selling the track, being able to sell it is important.

Computers and the internet have put the means of production back in to the hands of musicians, creatives and other workers in the digital economy. Whereas musicians in decades past would have had to rely on recording facilities and production and distribution chains owned and controlled by major labels, musicians now can choose to do it all themselves and potentially get much better deals. Historically record deals have been incredibly unfair on artists who have to pay for their recordings from their royalties but still don’t own their recordings once they are paid for. Right now sites like Zimbalam, TuneCore and CD Baby are fiercely competing to provide the best deal to musicians who are doing it themselves.

The last time ownership of the means of production changed hands from workers to factory owners the disenfranchised rose up to smash the machines until they were suppressed by the government. This time the disintermediated are turning to the government to defend and enforce the old business models by crippling the new machines that are handing back the means of production to the workers.

Always Watching is a song about biometrics, click tracking, online privacy, Phorm, governmental data loss, corruption and the increasingly Orwellian surveillance state. Even while we’ve been recording it the state has rushed through the Digital Economy Bill which further endangers our digital rights and freedoms. With a general election coming up, it’s even more important to always watch the watchers.

Battle of the Battle of the Bands

2010-03-25T19:11:00+00:00

Somehow, 100 robots have ended up playing 2 different Battle of the Band competitions on consecutive nights in Brighton: at The Providence on April 2nd and The Lectern on April 3rd.

So, which band is the best and which battle of the bands is better? Early indications favour The Providence, which seems to have a better PA, but The Lecturn is near the University. It could go either way.

Anything you can do, I can do meta: join us for both nights of the Battle of the Bands tour and see who we declare the winner of the Battle of the Battle of the Bands!

FOSDEM X: The Movie

2010-03-14T22:06:00+00:00

A video of my FOSDEM talk about Mono in Second Life and our plans for the future of scripting is now online (the slides are also available here ):

Watching back, I was surprised to hear myself say “Hooray!”, “Shit” and “Crap” quite so often…

While you’re catching up on FOSDEM talks, I recommend Miguel, Jeremie and Alan‘s talks from the Mono track. Unfortunately it doesn’t look like the very interesting talks on the XMPP track are available online, but I’m going to be catching up on lots of the talks I missed out on, including the key note talks on Saturday morning which I missed due to the very enjoyable beer event on Friday evening…

FOSDEM X

2010-02-10T13:52:00+00:00

Last weekend I went to the 10th Free and Open Source Developers European Meeting in Brussels. This year was the first time that FOSDEM had hosted a track on Mono, so I went along to find out what’s going on with Mono, tell the Mono folk what our plans are for C# and fill in some gaps.

I started Saturday on the monitoring track which included a terrible talk about an interesting tool that I hadn’t heard of: SystemTap — a scriptable system monitoring tool designed to allow diagnosis of problems at run time on production servers without the usual instrument, compile, analyse loop. stap looks really interesting and useful as a tool for augmenting or replacing our current simulator performance tools.

After the stap talk I headed over to the XMPP track for the rest of the day and saw some great talks on BOSH, onsocialweb, pubsub, strophe.js, collecta and node.js. Federated, open social networks seem to be a big thing at the moment (@blaine was talking about them at @scalecampuk ) and there was lots of interest in using XMPP to build them as it already has standards for identity, presence, friends and events. Given that jabber and XMPP is a decade old it makes you wonder why the standards weren’t used the first time round. A possible reason is that XMPP doesn’t have it’s rails/django yet and still looks pretty clunky to work with although Strophe.js may help. Another reason may be that XMPP hasn’t been the web up until now, although BOSH may be the bridge that’s needed there.

While everyone else was thinking about using XMPP to build Twitter and Facebook I started thinking about what an open, federated virtual world platform built on XMPP might look like. I wasn’t the only one. The realXtend folks turned up to show off their latest new from the ground up viewer which uses XMPP and jingle for voice and IM integration and were obviously thinking along the same lines. As realXtend seem to be moving away from SL tech now, expect an XMPP based back end from them soon…

I spent Sunday camped out in the Mono room which was interesting from a cultural point of view. Miguel de Icaza seems to have completed his transition from champion to enemy of freedom in the open source community’s eyes. Last time he was at FOSDEM he was accused of talking about “Coca Cola” when showing off the closed source Unity engine that uses Mono, so stayed strictly to open technologies in his talk this year. Luckily, due to Microsoft’s Community Promise and open sourcing of the DLR, IronPython and IronRuby, that includes a lot of the .NET platform and gave him lots to talk about. Most of the legitimate worries of patents around Mono have been resolved, but talking about [C#][] and the CLI at FOSDEM still requires a poster asking people to leave their religion at the door, apparently.

In my Second Life talk, I gave a summary of the interesting things we did to get LSL on Mono working in 2008 and then outlined our plans for C# in the future including lots of question marks around how we’re currently planning to implement them. Lots of my questions were answered after the talk and it turns out that the Unity developers are wrestling with the same problems at the moment, so we should be able to work together over the next few months to make a lot of progress.

Overall FOSDEM was hugely informative and enjoyable and I have a big shopping list of exciting new technologies to play with over the next few months. Hopefully the Mono room will become a regular fixture and we’ll be able to head back next year.

An Open Source, Guitar Mounted, Multi Touch, Wireless, OSC Interface for Ableton Live

2009-12-17T10:58:00+00:00

(100 robots images by Steve Marshall )

Ever since playing with iPhones as music interfaces with the London Community iPhone OSCestra at Open Hack London in May I’ve been wondering how I could use my iPhone as a controller in my rock/electronic band 100 robots. The 100 robots set up has Max and I playing live drums and guitar over a number of tracks played from Ableton Live. If I could mount an iPhone on the guitar I could manipulate the tracks playing from Ableton making the whole experience more varied and live and less like 2 people playing over a backing track.

The biggest problem with using the OSCestra set up with 100 robots is that we run Ableton on Windows with 100 robots so that we can use a number of plugins that aren’t available on OS X. This stopped us using the OS X Osculator to convert OSC data from Mrmr in to MIDI data that we could feed to Ableton — the really simple and easy solution that I recommend if you’re using OSC and Ableton on OS X.

Some quick Googling showed that we could potentially use the open source and incredibly powerful pd to read OSC and send MIDI to Ableton, but pd seemed a bit heavy weight and complex to use just for controller mapping in a live environment which needs to be stable and predictable under heavy load while streaming 6 audio tracks and recording 2 tracks live.

Some more research I discovered LiveAPI: an open source project that gives access to the Python interpreter embedded in Ableton Live. LiveAPI allows you to write python code which listens to events from Ableton and allows control of Ableton from python code. Conveniently LiveAPI also includes LiveOSC an OSC server that quickly allows you to map OSC messages from applications like Mrmr to Python methods that use LiveAPI to control Ableton.

In the end it only took a couple of hours and a few lines of Python code to rig up Mrmr on the iPhone to control Ableton on Windows and a few minutes more to build a guitar mount for the iPhone from a cable tie and a piece of gaffa tape.

Using the iPhone live with 100 robots:

(Cinematography by David Packer)

Despite being a really quick hack to build, LiveAPI is somewhat fiddly to set up, so I thought I should document the process of wiring things up. If you’d like to build your own open source, guitar mounted multi touch, osc interface for Ableton Live 8 running on Windows, follow these instructions:

Install Mrmr on your iPhone or iPod touch
Design your Mrmr interface using a text editor. If you have a Mac, you can use the interface builder. The 100 robots mmr file is here
Upload the mmr file to a web server.
Connect the iPhone to the same network as the computer running Ableton.
Run Mrmr on the iPhone, download the mmr file from your web server to get your interface running on the iPhone
Download LiveOSC
Unpack the LiveOSC zip in to a new LiveOSC folder created inside the Resources/MIDI Remote Scripts directory in your Ableton installation.
Edit Resources/MIDI Remote Scripts/LiveOSCCallbacks.py to add new callbacks for Mrmr to the __init__ method of the LiveOSCCallbacks class. Widgets are numbered sequentially from 0 in the mmr file, so this line registers a callback for the first widget in the file. The 100 robots callbacks look like this:

“”” 100robots callbacks “”“self.callbackManager.add(self.toggleBass, “/mrmr/pushbutton/0/iPhone1”)
Add methods to Resources/MIDI Remote Scripts/LiveOSCCallbacks.py to respond to the messages from Mrmr. These can use LiveAPI freely to control ableton. The 100 robots callbacks toggle the first parameter of effect racks on different tracks to turn them on and off:

def toggleBass(self, msg): “”“Called when a /mrmr/pushbutton/0/iPhone1 message is received.”“” track = 38 device = 0 parameter = 0 value = msg[2] LiveUtils.getSong().visible_tracks[track].devices[device].parameters[parameter].value = value
Select LiveOSC as a control surface in the Ableton preferences. This will load the LiveOSCCallbacks.py and set up your mappings. Interact with the controls in Mrmr and see Ableton Live respond!

The full, modified 100 robots LiveOSCCallbacks.py.

My presentation on the hack at the £5 App Christmas Special which includes more details on the Ableton Live routing we use.

@scalecamp

2009-12-07T15:49:00+00:00

On Friday I jumped on the train to London to attend the first scalecampuk, an unconference about scalability, at the Guardian offices.

The sessions were all very interesting and mostly very relevant. I learned new things about XSS and CSRF and Django’s defences against them from Simon Willison, new things about messaging, pubsub, queues and data stores (process 1 message at a time, use message hospitals, send URLs to unavailable data that can be polled for with JavaScript and that just check memcache entries) lots about Varnish ) and it’s use at Wikia from Artur Bergman (Wikia runs off 18 apaches and 8 varnishes with 60GB of RAM and SSDs to serve 25 million pages and 950Mbps at peak, Varnish is generally better than squid ), but you need a modern kernel).

Lots of the talks were about moving storage, caching and queuing out of the application and just writing a small piece of business logic to tie them together. Against this background Alex Evans’ talk about the back end for Media Molecule’s Little Big Planet stood out like a sore thumb. Having not enjoyed using a Java web stack, Alex has just rewritten the whole of the back end as proprietary technology as a single binary in order to know the code from end to end. While it may be true that having custom physics or rendering middleware might distinguish Little Big Planet from other games, I can’t believe that custom technology to serve HTTP requests is going to be a competitive advantage. I hope Alex’s good ideas become Redis contributions rather than a maintenance nightmare and barrier to agility.

The lightning talks were also very good. Simon’s “ScaleFail” talk about the Guardian MP expenses app was hilarious (lesson: do load testing) and Gareth’s talk about Dumbo (a Python Hadoop client) was very useful.

At times it felt like the talks were suited to an ops audience, but “Dev’s should know about this!” was a regular refrain. Don’t worry: I listened and learned a lot. Thanks to everyone who made it a great day.

4 Robot Attacks!

2009-11-21T18:06:00+00:00

Incredibly, 100 robots have 4 gigs lined up in the next 3 weeks: tomorrow we’re playing at an electro/rock night at The Freebutt with Bang Bang Eche, Son of Robot and labasheeda, then next Thursday we’re playing at a more hip hop themed night at The Hope with Tactical Thinking and L-Mo. On the 2nd of December we’re playing at the music hack themed £5 App Christmas Special, where I’ll also be giving a talk about my open source guitar mounted iPhone multitouch Mrmr/LiveAPI/OSC wireless Ableton Live interface and then using it to play live. Finally on the 11th of December we’re playing at the Linden Lab Brighton Christmas party along with the other real rock band that formed from the remnants of the all conquering Linden Lab Brighton virtual Rock Band.

Whew. It’s going to be a busy few weeks. If you can come to any of the gigs, please do. It’s going to be fun: we’ll be playing brand new songs including our first excursion in to Rock/Dubstep and trying out new ways of performing. If all the gigs weren’t in Brighton I’d call it a tour…

Bouncaline

2009-11-03T20:28:00+00:00

Last week I took some time off to spend with Luke and Natty during half term and we spent Wednesday having a lovely time finishing off a game we started a couple of months ago: Bouncaline.

Luke has been interested in making games for a while: he made a level for the You’re The Boss game at the Radiator festival in Nottingham in 2006 — when he was 3!

More recently Luke started designing a game that I was helping him put together in Game Maker. He drew lots of backgrounds and characters that we scanned in and there were vague ideas about treasure hunting game play, but it felt a bit like Luke was biting off more than he could chew.

So, when Luke and Natty inherited a trampoline over the summer I suggested that we build a bouncing game and we started building it with Scratch, an educational programming environment that I’d been meaning to experiment with since seeing that it had been ported to Second Life.

Scratch has a very simple model based on plugging together blocks that is similar to the Lego Mindstorms environment. Luke quickly got the hang of it and built a significant portion of the logic with just a few leading questions. Like Mindstorms and LSL it uses multiple flows of control within the same scripted object for complex behaviour, which can take some getting used to when making an object that simultaneously waits to be touched and for a timer, for example.

In some respects I wish Scratch was a little purer — although message passing concurrency is possible, it’s very easy to share state between objects — something we shouldn’t be encouraging the programmers of tomorrow to do. It’s also harder to do multiple levels or screens than with Game Maker, but given Luke’s propensity to lose himself in Zelda style epics, the tight focus might help learn the basics of logic.

Overall it’s a delightfully easy and rewarding environment to use. After spending a couple of hours finishing the logic, we went in to the garden to take pictures of the trampoline and Luke and Natty striking poses for the animations and quickly got them imported in to Scratch along with some very cute drawings and sound effects by Luke.

Scratch also makes it very easy to share your work on the web, allowing Luke to proudly show off his handy work to his Grandparents over the weekend and for me to proudly share the game with you here. I hope you enjoy Bouncaline!

Use the left and right arrow keys to move and try to collect the food.[Learn more about this project][]

100 robots vs 100 geeks

2009-09-05T13:42:00+01:00

We’ve just about finished setting up the 100 robots gear at BarCamp Brighton 4 in a derelict building that’s going to make the gig feel like an illegal rave. If you’re at BarCamp please come downstairs to hear us sing songs about the surveilance state, Twitter and the Iran election, gene therapy cures for aids, world of Warcraft love affairs and lots more at 8:15 this evening. If you can’t make it we’re also playing at the Prince Albert on Trafalgar street in Brighton at 8 PM on the 24th of October and if you can’t make it to either you can watch the videos from the Dance of the Dead zombie prom which are now on YouTube. You can also listen to and download some of our tracks for free from last.fm or myspace and add yourself as a fan to the facebook page.

Evolving Develop

2009-07-20T23:41:00+01:00

As usual I headed down to the Metropole on the sea front last week to attend the annual Develop conference in Brighton. Unusually, this time I was attending the Evolve day which shifts the focus from console development to online, mobile and social games, which I had helped create as part of the steering commitee. I was very impressed.

The first talk I attended was not strictly part of the evolve day: I switched over to the Games:Edu track to listen to Alice Taylor talk about her work building games for Channel 4. In a previous era, Channel 4 spent £6 million a year on public service programming for young people which ended up being shown in the mornings when the only young people at home were off sick. In order to reach a wider audience all of that money was switched to online programming and, because 14-19 year olds love them, games. Since then, Alice and Matt Locke have toured the country commisioning small developers to develop games like Sneeze, Routes, 1066 and future games battling STIs in privates and making science fun for girls with Ada Lovelace. It all sounds like loads of fun and a great fit for Second Life (which already has a fair amount of sex and science adventures of its own), but the key here is availability. Alice is going where the kids are. Millions of people play the Channel 4 games using technologies like Flash which are ubiquitous: an order of magnitude more people than use Second Life regularly or used to watch the telly from their sick beds.

Next up was “Browser Based Games Past Present Future” which sounded perfect: which of the competing technologies is going to win the battle for the 3D browser canvas, which should we use to make Second Life more accessible to some of Alice’s teens? Unfortunately the retrospective and predictive parts of the talk were extremely limited and the talk was mostly a plug for Pirate Galaxy: an online Java based Eve. Luckily it looks incredibly well done. In particular the in world economy which allows either time or money to be converted in to energy and from their in to experience and eventually space ships looks very slick: to begin with energy is plentiful and little is needed. Slowly the screw is turned making the urge to invest in energy ever more inticing. There are also limits on the amount of short cutting that can be done by investing money, with game play still required to gain experience which is needed to buy the best ships. It’s all a long step forward from the experiments with economies and mudflation we grappled with at AGC, SIGGRAPH and on Terra Nova.

The highlight of the day for me was the talk by Kristian Segerstrale, CEO and co-founder of Playfish who make some of the most successful games on Facebook, including Pet Society: a game which allows you to collect rainbow poos and is as popular on Facebook as Rhianna and the Simpsons. Kristian talked about how social games are different: no longer focused on creating paths for solitary players to experience fear, horror, wonder and suspense, social games are toolkits for cooperation, competition and expression for friends. Social games have been responsible for most of the growth in the games industry over the last year and while the Wii and Rock Band have let friends gather and play together, games on social networks let friends play together online. Where traditional games spend years and millions in development and then launch with marketing splurges and shelf space negitiated with retailers, social games might intially be developed for 10s of thousands, sit on an infinite shelf and are marketed virally through recommendations from friends. Where traditional games rely on the intuition of a games designer who hopes to get it right, social games rely on feedback. After launch social games are deluged with information. Marketing is driven by numbers, buy buttons are A/B tested with users, designers analyse play, further investment and development desisions are based on usage, the skill is not in intuitively knowing what players will like, but by mining and filtering a slew of data to find out. Kristian’s talk felt a lot like Raph Koster’s dinosaurs talk from a few years back: it even used a similar meteor strike slide, however, this time around the small mammals weren’t micro user generated virtual worlds but pets doing rainbow poos and restaurant sims where you can hire your mum as chef.

It will be interesting to see how the small furry mammals evolve over the coming years.

The London Geek Community iPhone OSCestra

2009-05-12T00:34:00+01:00

On Friday evening while mulling over potentially interesting hacks to build at Open Hack London I remembered an idea I’d had a while ago: there are now loads of interesting ways to use iphones as music interfaces and the iphone to hacker ratio at hack days tends to be around 1, so you could probably put together an entire iPhone orchestra.

With only a few hours left before heading to London I started rummaging around on the internet to find the bits I needed. I’d looked at the various iPhone music interface apps over Christmas and ITM MidiLab had been the easiest to use, but although I could start up multiple iTouchMidi servers listening on different ports, I couldn’t send the output of the servers to different MIDI ports, making it impossible to distinguish between multiple iPhones.

Next I looked at the OSC based iPhone apps: OSCemote, TouchOSC and mrmr. Of these, mrmr was the easy choice as it is free as in beer and speech, allowing me to extend it if needed. It also allows custom interface design via scripting allowing for potentially interesting UI hacking at open hack. OSC is also an open standard, so as a last resort I’d be able to build a server that could listen to multiple devices.

With the client settled on I started looking at existing software to run on my laptop to convert OSC data in to MIDI to control Ableton. The first thing I looked at was pd, an incredibly powerful data processing environment that can understand OSC and generate MIDI. As well as being incredibly powerful, pd also has an incredibly steep learning curve and time was running out, so despite having used it in the past and wanting to use open source software for my hack, I eventually gave up on pd and tried OSCulator.

OSCulator is incredibly easy to use. Within minutes I had multiple OSC servers listening on different ports, my iPhone had connected to each of them and I’d set up mappings from dozens of OSC inputs to MIDI controllers. OSCulator also supports up to 8 Wiimotes connected via bluetooth, so I chucked a couple of wiimotes my bag, tested the iPhone could connect to an Ad Hoc WiFi network created on my MacBook Pro, threw a Dr Who MIDI file in to Ableton and then got some sleep.

After booking a slot for the non-existant iPhone orchestra during the hack demos, I set out to make it exist. With a combination of arm twisting and volunteering I convinced 8 plucky hackers to join the orchestra then spent a few hours auditioning synth patches in Ableton and assiging MIDI controllers to their parameters and tweaking iPhone accelerometer smoothing settings in OSCulator to get a couple of Wiimotes working as drums.

I managed to organise an hour’s rehearsal on Saturday afternoon where we spent the first half trying to connect all of the devices and the second huddled around the laptop trying to hear the audio from the built in speakers. After a bit more tweaking I set up a 3rd Wiimote to launch loops and start and stop the set, allowing me to get in on the fun while conducting and borrowed an amp for our second and final rehearsal.

The performance was a hoot. We’d been having trouble getting all of the devices to connect to OSCulator at the same time and Simon Willison’s iPhone refused to connect for the final performance, which freed him up to concentrate on hamming it up with a look of intense concentration. I also managed to completely lose track of where we were in the music, so Jon Markwell’s haunting theremin solo section ended up following an embarrasing silence when his part wasn’t actually playing. All in all though, I think we did pretty well and it went down a storm with the assembled geeks.

Many thanks to Ryan Alexander, Jonathan Markwell, Natalie Downe, Nigel Crawley, Matt Jarvis, Simon Willison and Matthew Smith for indulging me once again at hack day — it was loads of fun. There are more videos and photos of the performance in my delicious stream.

Lang.NET 3 Years On

2009-04-27T11:12:00+01:00

It was incredibly satisfying to be able to go back to Lang.NET 3 years on to be able to say that we actually managed to make all the crazy plans we had for Mono in 2006 work. My talk is now online here. Lots of people hadn’t seen the 2006 talk and were blown away with us adding support for continuations on the CLR and enough new stuff to keep those that had seen the first talk interested. In particular the anecdote about flywheel exploits for the Mono scheduler got a laugh from Anders Hejlsberg.

The other highlights on Tuesday were Mads Torgeson’s talk, which gave some nice insights in to the process that led up to the final C# 4.0 Dynamic design. Mads did a good job capturing some of the concerns that static advocates have with dynamic languages. Gilad Bracha’s talk on Newspeak and the Hopscotch IDE showed what’s possible with a really dynamic language: extending the IDE and debugging it from inside itself. The access that newspeak has to it’s call stack was particularly interesting: it would be much easier to move a newspeak stack around than build the infrastructure we needed to move a CLI stack. I spoke to Gilad about his experiences building newspeak on Sqeak afterwards. His impression is that Squeak is runtime mostly used for education and has no support for security or running untrusted code. Having spent a decade seeing the various security problems with bytecode verification in Java, Gilad isn’t convinced that a bytecode level sandbox is the right approach, but although he has some ideas for object capability based security for the post squeak Newspeak implementation it seems a long way off.

The highlight on Wednesday was definitely Lars Bak’s talk on V8, which I had missed last year at JAOO. The mechanism for discovering emergent types in dynamic languages to allow indexed lookup instead of hash table lookup is a very nice hack. Lar’s super competitive heckling of everyone at Microsoft for the rest of the day was also fun. Other highlights included Erik Meijer throwing coins around while talking about mathematical duality and Amanda Lauter and Luke Hoban talking about F#. Potentially relevant to Linden Lab if we get to the point where we can support debugging scripts in Second Life was Herman Venter’s talk on the Common Compiler Infrastructure a newly open sourced library which can allow CLI assembly rewriting while preserving debug information.

The Meta Introduction to Domain Specific Languages was a really good opening for the DevCon, but the talk most relevant to Second Life was Paul Cowan talking about DSLs in the Horn Package Manager. Paul talked about creating DSLs by extending Boo, something that should be possible when we get to the point where Second Life can accept arbitrary CLI assemblies. I got a first Boo script compiling against the Second Life assemblies at the DevCon and have some plans to experiment building a DSL for virtual ecosystems in Second Life over the next few weeks. Supporting C# as a general purpose language and Boo as a meta language for building DSLs in Second Life would be an excellent combination.

A lot of the talks at the DevCon seemed to involve doing terrifying language somersaults to create more natural DSLs that run on the JVM or CLI which then can’t be easily debugged due to the huge chained expressions or nested types that the languages boil down to. There seems to be a large opportunity for disaster here when these DSLs need to be extended or maintained in 10 years time after the original authors have moved on. Although Martin deflected a lot of these questions by saying you can get bad frameworks as easily as bad DSLs, I feel a lot more comfortable unpicking a bad framework or wrapping a library than trying to fix or extend a broken language (maybe several years reimplementing LSL’s quirks did that).

The ultimate promise of DSLs was hinted at by Magnus Christerson’s talk which demoed Intentional’s amazing Domain Workbench. Instead of building DSLs on top of mainstream runtimes, the Domain Workbench models the domain and can then project the model as code or using domain specific projections like interactive circuit diagrams that can be manipulated and debugged interactively. Magnus started his talk saying that we used to have to enter programs on punch cards that evolved in to sequential programs and that we don’t need to do that any more. If the Domain Workbench’s promise is fulfilled it could change the way we develop software forever.

100 Robots Vs 200 Zombies

2009-03-27T23:50:00+00:00

I may not have blogged much recently, but I’ve been hard at work writing new songs about the financial meltdown, the surveilance state, gene therapy cures for hiv, anger and guilt for the new band I’ve put together with Max Williams and Aleks Krotoski: 100 Robots. We’ll be performing the new songs along with rock/dance/electronic versions of Thriller and Re: Your Brains among others to 200 zombies at Dance Of The Dead: a charity zombie prom in London in aid of St Mungos on April 4th. If you’d like to come along, dance, rock, shamble and groan tickets are available here. I’m always happy to dress up as a zombie, throw in playing music and supporting a band called the The Tits Of Death and it’s clear that this is going to be the best gig ever!

Music Again!

2009-01-12T20:42:00+00:00

Since moving to Brighton 18 months ago I’ve been pretty busy finding my feet, moving house twice, sorting out schools and setting up Linden Lab Brighton, so I haven’t had as much time to make music as I’d have liked. It hasn’t helped that my brother Roo, who collaborated with me on Vanishing Trick has gone from being a medical student to an opthalmologist, so has been pretty busy too.

I’ve still been reading create digital music though, so couldn’t resist buying Luke a copy of Korg DS-10 for his birthday just before Christmas. It’s a great piece of software that reminds me a lot of ReBirth (which is now free!) — the same infectious acid sounds and a fun interface that you can’t resist tweaking. Within hours Luke was coming up with screaming synth noises that would have made the Chemical Brothers proud, so I told him that when he had a track finished we could record it on to the computer, add some more sounds and make a CD.

30 minutes later I had Luke to thank for finally convincing me to unpack my bag of midi and audio cables for the first time since we rolled up in Brighton. While adding bits to Lukes DS-10 and Electroplankton creations, I took the opportunity to finally play around with Ableton Live properly and was completely bowled over. It’s one of those pieces of software that as a software engineer you can’t help admiring. It makes you want to use it and turns the complex process of sequencing and producing music in to joyful fun. I’d been a Cubase user for 10 years, but I’m not going back.

Over Christmas I put together a Live rig that lets me use my ancient Yamaha MFC05 MIDI controller to switch between drum beats, record guitar loops and automatically switch between effects settings without touching the computer. With some tweaking I’m going to get it to do the same for my Nord Modular and switch patches on both the Nord and my POD allowing me to quickly record, compose, arrange and perform music from 5 foot pedals. I’ve also got ITM set up on my iPhone which I’m planning to mount on my guitar giving me a wireless X/Y touchpad that can control any number of Ableton parameters.

I also finally got round to playing around with circuit bending for the first time. Last Christmas Roo got me a reissue Stylophone, which is a fun toy, but whenever I read about circuit bending online I kept thinking it would be fun to try connecting the headphone output of the stylophone to the MP3 input. In the end it only took an hour or so of poking around inside the Stylophone while telling Luke about electronics to find some bend points that turn the mild mannered Stylophone in to a wailing banshee of feedback distortion that’s more Hendrix than Harris. The modded Stylophone is shown below and I’ve added annotations to a picture of the opened up Stylophone on Flickr that shows the points that I connected. If you’d like to hear the evil sounds it makes there are a selection of Creative Commons licensed samples on Freesound, but I advise turning the volume down and using headphones if you give them a listen.

It’s great to be having fun making music again. Thanks Luke and Roo!

[]: http://www.flickr.com/photos/jimpurbrick/3186312458/ “Bent Stylophone by Jim Purbrick, on Flickr”

Babbage Linden In Real Life

2008-12-14T14:03:00+00:00

When I heard that the theme for the Linden Lab Christmas party was going to be steam punk, I knew I had to go as Babbage Linden. Since 2005 my avatar in Second Life has sported a victorian suit from Neverland and a steam arm, originally from a Steambot avatar which I updated to a more recent design from Marcos Fonzerelli after Joe Linden started washing his face in my sink.

I had a suit that was close enough and a bit of riffling through local shops and ebay got me a waistcoat and cravat that were a pretty good match, but I knew the arm was going to need a lot of construction, even if I went for the first version from the Steambot. After some Googling trying to find out how to construct a conical frustum I remembered the export to world project that had converted Second Life objects to paper craft models. So, after checking that Marcos didn’t mind me exporting his geometry from Second Life, I decided to do that.

Installing OGLE proved to be really easy - just dragging the replacement OpenGL DLL and supplied config to the Second Life directory worked fine, but my first few captured scenes were full of unwanted clutter. In the end I found that using the advanced menu to turn off all render types apart from Basic, Volume and Bump and the UI feature allowed me to capture just the steambot arm placed in front of me in Second Life.

After opening the .obj file captured by OGLE in Blender, exporting it as a DXF and opening it in Pepakura Designer it was clear that the model was far too complicated - the cones and spheres created dozens of faces. Going back in to Second Life I broke the steambot arm in to 1 piece for each cardboard part I expected to make, stripped off all of the spheres, made the finger tips in to boxes instead of cones and then used the Second Life preferences to set the object mesh complexity to minimum, which reduced the number of faces on each cylinder to 6.

With these simplifications made the models looked much more managable when opened in Pepakura Designer, but it was still worth playing with open faces to simplify the parts in to quad strips. With these tweaks made I determined the correct scale. I placed my forearm on a couple of sheets of A4 and then adjusted the scale in Pepakura Designer until the steambot arm covered approximately the same amount of paper, then noted down the scale so I could use it when printing each part.

After printing the parts out on A4, I pinned them to some think double ply corrugated card from some old Dell boxes and then cut out the shapes and assembled them with gaffa tape, PVA and paper fasteners. I replaced the spheres with some polystyrene spheres from a craft shop and replaced the shiny with half a dozen coats of copperchrome spray paint.

I had a load of fun and the finished arm is amazingly sturdy, surviving 6 hours of Christmas party relatively unscathed. Who knows, maybe I’ll get another chance to wear it at an SLCC in the future. A full set of pictures with notes is available here.

m0cxx0r And Return Types

2008-12-03T22:04:00+00:00

The core of m0cxx0r is the creation of an object that records method calls and compares them to expectations. This is done by using C++ placement new to create a VTableDonor object in allocated memory the same size as the object being mocked and then returning the memory as a m0cxx0r::Mock class which inherits from T, the class of the object being mocked.

When methods are called on the mock object instead of invoking the methods in T, the virtual methods in VTableDonor are called instead and are able to record the calls made and compare them to expectations. The problem is that the signature of the original method and the VTableDonor method may not match.

In order to be able to find and compare parameters the VTableDonor methods take a single parameter which they can use as a fix point to find other parameters that may be passed to the call via pointer arithmetic. Luckily the rules for parameter layout are fairly simple, so if you know the address of the first parameter, it’s easy to find the others.

Unfortunately the same isn’t true for return values. Depending on the return type, space for the return value might be pushed on to the stack as a hidden parameter, a pointer to a heap location might be pushed or the caller may expect the return to be saved in a register. The rules for which mechanism is used depends on some combination of the compiler, platform and sometimes which C++ features the return type uses. To make matters worse the this pointer is also pushed as a hidden parameter which can become corrupted when there is a return type mismatch. All of this makes it very difficult to call a VTableDonor virtual method with a void return type in place of a virtual method on T with a non-void return type and have everything work correctly. You can see why people generally use the much simpler C ABI to nail binaries together.

After a lot of research and some trial and error I’ve managed to get m0cxx0r working with virtual methods returning primitive types and non-POD types by value in Visual Studio 2005 on Windows and using g++ 3.3 on Linux. The new code can be found here. I’m still having trouble getting it working on g++ 4.0.1 on Darwin where dyld seems to be noticing my monkeying around, causing the process to exit with a _dyld_misaligned_stack_error — hopefully it will be possible to work around.

A potentially better solution is used by mockitopp, a brand new dynamic mock framework for C++ that I found on my travels around the internet today. Where m0cxx0r uses a compiler generated VTableDonor class and then attempts to work around the signature mismatch problems, mockitopp builds the mock vtable at run time which has the advantage that the entries can be made to match the signatures in the class being mocked. It looks to be a promising approach and I’m looking forward to investigating mockitopp further.

New Widgets

2008-11-25T23:21:00+00:00

It’s that time of year again where people start asking what I’d like for Christmas and I start wondering what they’d like in return. It’s just the sort of problem that should be solved with social software. Over the last few years I’ve had an Amazon wish list which suffices for books, music and software, but doesn’t allow me to add fun things like board games, sensors and [lego] (http://shop.lego.com/Default.aspx).

I’ve thought about building a wish list service that worked against any web store a few times and was talking to my old friend Tom about this problem at the weekend when he came to stay with his lovely new daughter Beth. We both agreed that someone must have built it already and so it goes: boxedup provides you with browser buttons that allow you to easily add any product any where on the web to a social wish list service. It also supports the other essential feature — allowing your friends to reserve items in a way that’s visible to them, but invisible to you, so everything stays a surprise until the big day.

I’ve added a boxedup widget to the side bar so you can see what interesting schwag I’ve uncovered from across the web in a wonderland style. While I was at it I added a friendfeed widget so you can see what I’m reading, bookmarking and uploading in a simon willison/boingboing style too.

Now I just need to get everyone I know to set up a boxedup list too and my Christmas shopping will do itself.

Measurement vs Modelling

2008-11-19T00:37:00+00:00

I’ve just been at a really interesting cafe scientifique in Brighton where Philip ‘Critical Mass’ Ball talked about using physics to model the behavior of people en mass. When modeling people as particles you can create surprisingly realistic simulations of real behavior in corridors, traffic jams and panics. As fascinating as this is, I only think this I’d useful on situations where there is little historical evidence to rely on and where the cost of change is high. In the case of parks it is much better to ship a park in beta without any paths and then close the park in November to pave the cow paths than it is to model the park up front and hope that your model bears some resemblance to reality. Physics has invented models of reality just as reality has invented methods of measurement that don’t require modeling. Jeremy Keith is Philip Ball’s nemesis, whatever he may say.

m0cxx0r on Windows

2008-10-27T21:32:00+00:00

In order for m0cxx0r to be useful for writing tests at Linden Lab, it needs to work on all of the platforms that we target with C++ applications, so today I tried building and running m0cxx0r on Windows.

Initially it looked good: m0cxx0r built in the default Visual Studio Debug configuration, but then crashed on construction of Mock objects due to accessing unitialised memory. This was relatively easy to fix, just requiring a call to memset to zero out the memory that would become the m0cxx0r::Mock object.

The next problem was harder to fix. One of the hacks at the core of m0cxx0r is pointing the mock object’s vptr at a donor vtable populated with methods that record calls to the methods. The problem is that the signatures of the original and replacement methods may not match, so multiple parameters may be passed to a method expecting a single parameter. This shouldn’t be a problem as long as the caller manages the stack unwinding: the caller just pushes parameters on to the stack which are ignored and then popped the back off again.

Although m0cxx0r just worked when compiled with GCC on darwin, the run time checks performed in Debug by Visual Studio caught the stack pointer mismatch and stopped execution. In Release the situation was even worse: the tests just crashed out without error. Luckily after some poking around I was able to turn of the stack pointer run time check in Debug and after some trial and error I found that disabling optimisations in the Release configuration with the default __cdecl calling convention allowed the tests to run without error in Release.

With these property changes made, m0cxx0r built and ran it’s tests fine in Visual Studio 2005 on Windows. Get the Visual Studio 2005 project and solution files along with the m0cxx0r code from Google Code.

m0cxx0r - Compiler Generated Mock Objects For C++

2008-10-26T23:45:00+00:00

A few weeks ago at JAOO I felt insanely jealous while watching Erik Doernenburg demo Mockito: I wanted dynamic mock objects in C++. It turns out that it’s really hard. However, after a few days hacking around I found that it’s not completely impossible. The results of my hacking are now available under a BSD license here. m0cxx0r lets you write tests like this in C++:

typedef m0cxx0r::Mock<ProductionClass> MockClass;
MockClass* mock = MockClass::create();
mock->expect("foo", &ProductionClass::foo);
mock->expect("bar", &ProductionClass::bar, 42);
mock->expect("baz", &ProductionClass::baz);
mock->foo();
mock->bar(3);                                                     
mock->verify();
MockClass::destroy(&mock);

Most importantly you don’t need to hand code a test double for ProductionClass: m0cxx0r generates it for you. The code needs lots of love: it’s all in a single file and the interface will need iterating a few times, but I think it’s a good start. Please download it, have a play and let me know what you come up with. I’ve only tested it on gcc version 4.0.1 on darwin, so I’d be interested to know if it works on other platforms as it uses some code layout assumptions that might not be portable. I’ll write some blog posts over the next few days that explain how it all works.

Like Second Life

2008-10-23T12:26:00+01:00

Was without a doubt the phrase I heard most often yesterday, especially if you include variants like “Not Like Second Life”, “A bit like Second Life” and “Unlike Second Life”. Whatever else it’s achieved, Second Life has definitely become the frame of reference for the small and somewhat myopic crowd that made up the delegates at the sparsely populated Virtual Worlds Conference in London yesterday.

Vastparkis not like Second Life because it works in a web browser. Everyone on the web integration panel seemed to agree that virtual worlds in a browser is the next step, so I was glad to be there to question the TechCrunch consensus. How does having a world in a browser help? What does back and forward mean to a virtual world? What does it mean for presence to have 10 tabs open looking in to different parts of the same virtual world? Why would you want your view further constained by extra web browser widgets? Isn’t 3D in the browser going to be a blood bath for the next few years? Aren’t you really just using the browser as a download path? I suggested that the final question was the real reason that developers are pushing virtual worlds on the web and that the integration that most people want is to be able to use existing web and 2D media while using virtual worlds and use web services as a universal data bus between virtual worlds and other web aware platforms.

MPEG-V is not like Second Life because it’s a standard defined by 35 companies which is much better than the emerging Linden led standard according to Dr. Yesha Sivan in what was the worst talk I’ve heard in a long time. Not only did he make the standardisation process sound like a 3 year political bun-fight by people who didn’t know much about virtual worlds and who might come up with a bad standard, he managed to spell MPEG and Google incorrectly, called Sun’s Darkstar, Blackstar and attributed a Ugotrade quote to Philip Rosedale amongst other clangers. He was roundly rebutted by a large part of the audience including Tara5 Oh who questioned the need for old fashioned standards processes in the web era. Thank goodness for rough consensus and running code.

Most of the virtual worlds talked about in the investment panel were not like Second Life, but were nearly all Club Penguin clones. This copy the big exit attitude was called out by one of the audience as it seemed to be at odds with a lot of the talk about wanting to back the first in a market, but at least one of the panel is still looking for a successful 18+ social world play. The panel ended with a show of hands from people wanting money and people wanting to invest, but the economic climate made the whole affair very muted with lots of the panelists saying that they are slowing down rates of investment as it’s difficult to get existing companies off their books.

As with Virtual Policy 08 and the Virtual Worlds Forum the most valuable parts of the conference were the spaces between sessions. I had another very worthwhile discussion with Adam Frisby of OpenSimabout C# script compatibility between OpenSim and Second Life. The straw man design we talked about was to have an idiomatic .NET interface for event handling that can be used by C# scripts and adapted for LSL scripts and a set of static library methods for manipulating the world that would be used directly by LSL scripts and wrapped by user created libraries to provide an idiomatic object oriented interface. Adam was particularly interested in the idea of user created wrapper libraries as it would allow the creation of an OpenSim interface library that could be ported to Second Life and implemented in terms of the ll* static methods. OpenSim could then agree to support the common behaviour of this library in Second Life and OpenSim instead of having to support the gamut of ll* methods some of which don’t map well to OpenSim internals. As well as defining a common set of events and ll* static methods that are supported on both platforms there would need to be a way of extending the interface with new events and library methods. In addition Adam was interested in making the event propogation configurable so that a single script could respond to events on many objects in a scene. This would effectively add a script interest management layer to OpenSim’s scripting interface. Where platforms provide differing interfaces to scripts we would also need to decide how scripts query the available interfaces or how they behave when interfaces are not available.

Overall a worthwhile trip, but not because of the conference. This Friday I’ll be talking at the online head conference about conferencing in Second Life which has the advantage of requiring no travel making marginal conferences like the Virtual Worlds Conference less risky to attend while allowing all of the serendipitous networking opportunities that make real life conferences worthwhile.

Anything But Java

2008-10-06T13:28:00+01:00

Last week I was invited to talk at JAOO Denmark. Originally a Java conference, JAOO is now a very broad software development conference covering everything from agile to language design to distributed systems.

The stand out talk on the first day was Gregor Hohpe‘s Programming the Cloud which enumerated some of the problems with building distributed systems without call stacks, transactions, promises, certainty or ordering constraints and then outlined some approaches to overcome them including looking at real life situations which also have to deal with the lack of distributed transactions. For example at Starbucks your coffee is made concurrently with your payment being taken and then problems are fixed up afterwards if you can’t pay, they can’t make the coffee or they get the order wrong. The throughput gained from optimistic concurrency is greater than the loss of having to fix things up, even if it means that sometimes you end up giving away free coffee.

Unfortunately I missed Lars Bak’s V8 keynote on Tuesday, but was really impressed by Successfully Applying REST by Stefan Tilkov which enumerated REST patterns and anti-patterns shining some light on the subtleties of a technology which initially seems straight forward but turns out to have some pot holes for the unwary.

The highlights on Wednesday were seeing Guy Steele and Dick Gabriel give their 50-in-50 talk again (which is still not available on-line, but one of the highlights is here) and seeing the new WeDo lego robotics platform for kids which will be available next summer. The most relevant talk was Test Driven Development, Take 2 by Erik Doernenburg which got me thinking about how to do dynamic mock objects in C++. My talk on embedding Mono in Second Life went down well and elicited some good questions, although as a fringe topic it wasn’t heavily attended.

Other highlights included Erik Meijer’s keynote on fundamentalist functional programming, Bill Venners talk on Scala, hearing Patrick Linskey conclude that the way to make Java scale is to use Scala or Erlang, James Copland reinventing OO, playing guitar at the jam session and hearing Erik suggest to Lars that we compile LSL to CIL and run it on V8 modified to capture thread state while Erik was spilling half bottles of Champagne over people and Lars was swaying and stumbling around the room.

[]: http://www.flickr.com/photos/jimpurbrick/2918267608/ “The Shakespeare Language by Jim Purbrick, on Flickr”

dConstructing dConstruct

2008-09-18T12:03:00+01:00

A couple of weeks ago the great and the good of web development descended on Brighton for the wonderful clearleft produced dconstruct conference and once again I’m glad I went along.

Steven Johnson kicked off with a talk about how Dr. John Snow’s innovative data visualization of a cholera epidemic and the wisdom of dead crowds helped convince people of the water borne nature of the disease. It was an interesting story, but it mostly ended up being a plug for his book and geoblogging aggregator outside.in.

Next up, Aleks Krotoski talked about how games had spent decades creating incredibly compelling user experiences in silos without much contact with each other the academic HCI community or the web. Meanwhile the web is very interested in creating similarly sticky experiences using virtual rewards to encourage participation. Aleks’ conclusion was that the two communities should talk and I agree.

Daniel Burka talked about similar themes in his talk about the evolution of Digg. The most interesting anecdotes where about how top diggers started off as a good incentive, but became a disincentive when new users saw how unachievable the scores had become and how the recommendation engine is now a good way to encourage some of Digg’s passive audience to get involved.

Matt Jones and Matt Bidaulph talked about their successful Silicon Roundabout startup dopplr. Jones talked about visual design and delighters which sounded a lot like Alek’s virtual rewards in games. SL uber-hacker Bidaulphtalked made another gaming analogy, talking about how embedding dopplr in other sites and vice versa achieves a similar seamless experience to streaming maps in games: removing the load screens and jumps that used to bedevil console games and still are the normal experience when using the web. He also talked about the importance of using message queues and asynchronicity in services like dopplr which pull information from across the web.

Joshua Porter‘s talk on Leveraging Cognitive Bias in Social Design was the stand out talk for me. He talked about exploiting people’s tendency to pattern match to generalise isolated positive case studies on web sites and on framing account creation as something to do to avoid losing features rather than something that gains features as a way to play on the tendency to value losses greater than gains. His description of the how the 9x mismatch between customers (who over value the application they already have by 3 times) and developers (who over value the application they have developed by 3 times) creates a huge barrier to application adoption was particularly interesting.

Tantek Celik‘s talk about using hCard and rel=me links to create portable, auto-updating social network profiles and data to reduce the fatigue induced by inviting all of your friends to many social networks was the most practical session of the day. I’m going to try playing around with rel=me links and Google’s social graph API here soon.

Jeremy Keith gave a grandiose talk to end the day which wove together psychohistory from Asimov’s Foundation Series with Critical Mass and The Wisdom of Crowds to talk about how network effects and power law distributions cause some social software to explode in popularity while others wither, but that despite The Tipping Point being sold in business sections as a how-to book, it is fundamentally a retrospective and that predicting or engineering tipping points or network effects is notoriously hard. It was a great talk and the conclusion that social software is more of a lottery than a science is valid, but still: you have to be [in it to win it] (http://secondlife.com).

On Lifecycles And Spimes

2008-08-03T23:22:00+01:00

It was immensely satisfying to see Bruce Sterling commenting on Carbon Goggles in his Beyond The Beyond blog for wired last week, not only because I’m a big admirer of his work, but because his 4 year old Spime neologism came up in the original discussions about Carbon Goggles at EuroFOO 2 years ago.

Sterling’s original description of Spimes make them sound extremely sophisticated and active objects: recording and publishing information about their construction and ownership, usage, possible modifications and alerting owners about the need for maintainence and so on. Our current reality is one of more passive objects which are annotated via the web: despite being able to run web servers, the possibilities for modifying Linksys SLUGs are independently published on the web; the lifecycles of passive books are tracked and determined using services like bookcrossing and bookmooch. Everything is web enabled right now: a subject I gave a talk on at BarCamp Brighton last year.

The current model relies on human identification and administration to grease the wheels of dumb objects. We see a Linksys SLUG and google to find out information about it. We enter the information added to a bookcrossed book to find out about it’s sequence of owners and route around the world. Augmented reality takes a step towards automating the process: objects are still passive, but RFID readers replace humans in the identification of objects, automated processes pull information on the object from external databases and augmented reality overlays display the information over the object in a way that gives us x-ray like abilities. We can see the details of the construction, components, chemistry and recycling options for objects. Able to make visible the invisible, to see the full picture beyond feature lists and prices.

Sterling talks about the “need to document the life cycles of objects” and this was the original plan for Carbon Goggles. Everything from an apple to a supercomputer has an Id in Second Life and so the goal was to compare the carbon footprints of everything over it’s entire lifecycle. The apple is cultivated using machine tools, transported, refrigerated and stored and has a carbon footprint just like an object that actively emits carbon like a motorcycle. In many cases the carbon costs of creating and destroying objects can dwarf the carbon they emit in their use. It can be more carbon efficient to buy a second hand car than to buy a new hybrid, despite the later’s frugal emissions while in use.

Unfortunately collecting data on entire life cycles is incredibly difficult. While people can measure the electricity usage of an appliance and add it to the AMEE wiki, it’s much harder to find out the emissions produced by the entire chain of companies that have built transported and assembled the myriad pieces that produced that object. When I last met Gavin in London he told me that the goal is for AMEE to provide this complete lifecycle picture of everything, but we’re a long way off. Environmental costs have been externalities outside company accounting for a long time. AMEE intends to add this missing accounting, but it’s tantamount to annexing every company’s accounting process and is likely to be just as complex as counting the pounds and pence.

In the future we will be able to automatically see everything there is to know about everything around us and be fully aware of the impacts of our consumption. Right now services like bookmooch, freecycle and bookcrossing allow us to add Spime like intelligence to objects if we’re prepared to do a lot of Spime wranging. Experiments like Carbon Goggles give us a glimpse of what the future in the real world might look like. We’re going to be a lot more aware, which is lucky, because we’re going to need to be.

Jon Blow

2008-08-01T00:20:00+01:00

At the recommendation of John and Alice I took a break from Develop Online to listen to Jon Blow‘s talk at Games:Edu this week and was totally blown away.

Jon talked about whether games are poised to enter a golden age similar to films in the ‘30s, when they transitioned from visual spectacle to an art form capable of touching people emotionally. Currently many games are broken by the conflicts between the game play rewards and the needs of the story. The canonical example is Metal Gear Solid, which pauses all interactivity to deliver exposition, but even more nuanced games suffer from the lack of control over the framing of the story. A narrative is likely to be much less powerful if the protagonist is jumping around while another character opens their heart. Equally the illusion of interactivity is completely broken by a character that refuses to acknowledge the player’s actions by simply reeling off scripted dialog.

I wonder whether games too often sacrifice interactivity in the pursuit of realism. When you can simulate a city full of cars, the desire to populate it with people is almost overwhelming, but without solving the hard AI problem the only way to add people that say anything nuanced is to script them. The world seems more real, but adding scripted people to the center of the world compromises the interactivity that should be fundamental to a game. When we read a book we accept a lack of agency as we are empathizing with a character and following their journey through the narrative. When we’re in a game the story should be ours and the world should respond to our actions. There will be limits to our freedom, but placing scripted characters in the world rubs those limits in our face. Many forms of art touch us without having to realistically represent people. No one would mistake the people in Guernica for real people, but the work touches us and the image could be interpreted as a game environment without solving the hard AI problem. Maybe games should spend more time trying to be Guernica and less time trying to be The Godfather.

Sharing Carbon Goggles Visualisations

2008-07-08T23:01:00+01:00

Second Life has benefited greatly from growing in popularity alongside video sharing services. Many people’s first glimpse of Second Life or a particular Second Life experience is through the lens of a YouTube video. When promoting real world brands in Second Life, videos of the Second Life experience that can be viewed by a wider audience on the web are often an important part of the campaign. Even for experienced residents like me, it’s often a video posted on New World Notes that inspires me to fire up the Second Life viewer to take a look at an amazing new build or experience.

The goal of the Carbon Goggles demo and tutorial videos was to make it clear what Carbon Goggles do and how to use them, but videos are also a great way to make the Carbon Goggles visualisations themselves available to a wider audience on the web. As well as being an ambient augmented reality application that allows Second Life residents to passively learn about real world carbon costs, Carbon Goggles can be used to quickly create images and videos that illustrate real world emissions.

If you annotate new objects with carbon emission data using Carbon Goggles, please consider recording some footage of the newly annotated objects and adding it to the Carbon Goggles vimeo group. I’ve added a vimeo badge to carbongoggles.org to show the newest videos. As well as allowing Carbon Goggles users to share the locations of annotated objects in Second Life, carbongoggles.org now shares visualisations of carbon emissions data to everyone on the web.

Mashed 08: T + 1 Week

2008-07-03T21:15:00+01:00

There were a number of great projects at Mashed that I wanted to blog about. Unfortunately, by the time I’d got round to setting up a blog I somewhat missed the boat. So, instead I’m going to revisit some of my favourite Mashed projects and see where they are 1 week on. Carbon Goggles has gone live and grown an annotation interface in the last week. Hopefully some of the other projects have also survived the journey home and gone on to greater things.

Team Bob was undoubtedly my favourite of the many BBC/subtitles/video/web mashups. A great visual gag rather than a useful service, I’m not sure this will go live, but there is now a video on line that serves to show this technically impressive and very amusing hack.

CurrentCost Live was the winner of the social responsibility prize at Mashed (somehow beating Carbon Goggles!) and was a great project. Starting with a CurrentCost meter Dale from IBM and team published electricity usage data online, comparing and analysing it to award XBox Live style achievements and trophies for saving energy. It doesn’t look like the project is live at the moment, which is a shame as I have a slug. It would be great to hook it all up and pwn people by turning my lights off while saving the planet.

The project that struck me as the most useful was Opening Times, a service that takes your postcode and tells you the opening times for all your local shops. I was really hoping it would go live as a service as I could see myself using it all the time. Turns out I shouldn’t have worried: not only is Opening Times live and kicking, it looks like it has been since April…

Mashed gives you a straight 24 hours to kick off a project and break the back of it with a team of great people, but it’s great when the development doesn’t stop when the beanbags leave the building. Hopefully some of the projects that started in a crazy whirlwind of hacking, mashing and rocking will continue to blossom over the coming weeks.

A Collaborative User Generated Ambient Augmented Virtual Reality Scientific Visualisation The Size Of Denmark

2008-07-01T19:57:00+01:00

2 years ago at Euro FOO 2006 who commented that climate change would be much easier to deal with if we could see carbon dioxide. The second was with Claus Dahl who observed that Second Life is a great platform to prototype large scale augmented reality applications as every object in Second Life has an Id and you can give away free augmented reality glasses in the form of heads up displays (HUDs).

A year later I started to experiment with the latter idea with SLateIt, an augmented reality application that can be used to find, tag and rate virtual objects in Second Life. Although I think tagging, rating and recommendation systems have a bright future in navigating the vast quantities of people, places and stuff in Second Life, SLateIt mostly came about as a way to demo augmented virtual reality in Second Life without a large data set to associate with objects in SL.

Finally, last week, the awesome team of Max Williams, Ryan Alexander, Andrew Conway, Simon Willison, Natalie Downe and Chris Waigl helped me bring the two ideas together by mashing up SLateIt, SecondLife and Gavin Starks’ new AMEE emissions data base to create Carbon Goggles. Instead of mapping Second Life object Ids to tags and ratings, Carbon Goggles maps Second Life object Ids to AMEE URLs. The HUD queries carbongoggles.org for emissions data for nearby objects and, if found, overlays a sphere on the object with a volume corresponding to the monthly carbon emissions of the object. In 24 hours we managed to hack together a working system to demo at Mashed and 2 days later added an annotation interface that allows new objects to be annotated with emissions data.

Carbon Goggles has had some great coverage over the last week, but I really hope the story doesn’t end there. The goal is to annotate objects across Second Life to produce a collaborative user generated ambient augmented virtual reality scientific visualisation the size of Denmark. Together we can add an extra layer of information to Second Life allowing people to learn to make more informed decisions in real life while living their Second Life. If you’re part of a group in Second Life that would like to help annotate objects, host Carbon Goggles vendors in world, create videos or images of Carbon Goggles visualisations or would like to help in any other way, please join the Carbon Goggles group in Second Life and get in touch.

Hello World

2008-07-01T09:21:00+01:00

Well, not exactly. Having blogged previously on Terra Nova, the original Creation Engine and currently on the Official Second Life Blog, I’m not exactly stumbling blinking in to the blinding light of the blogosphere. Recently a number of things have come up that I’ve wanted to write more than 140 words about, but that wouldn’t fit on the Official Second Life Blog any more, so I’ve finally stopped mooching off other people and set up my own blog.

One reason I hadn’t got around to it sooner is that I’ve been torn between platforms. Although it’s been tempting to throw up a WordPress blog every time I’ve had something to talk about, I really wanted to build a blog in Django that I could tinker and experiment with. Although it’s just a matter of plugging bits together, it still takes a few hours to get a basic Django blog up and running and longer to add all the bells and whistles. I finally managed to break the impasse last week when I came across this list of Django blog engines and after some routing around decided to go with byteflow which has all the bells and whistles but is made of standard Django bits and is eminently tinkerable.

So, that’s what you see here: a default byteflow blog running on Django trunk running in [mod_python][] as a virtual host (alongside the slateit.org and carbongoggles.org Django apps) inside apache2 running on ubuntu dapper on a virtual machine hosted by bytemark. It took long enough to get round to, but once I’d found byteflow it only took an hour to set up. I’ll be kicking the wheels and tinkering over the coming weeks, but if you find anything broken, please let me know.