• Week 38

    8 July 2013

    Week 38: two weeks to go before Playable City launches.

    The telephony code is roughly where I want it to be, which is good; there's a big content influx going on in the run up to launch, and any tweaks to the logic will come in response to what it feels like with the final language in place.

    The main focus of this week's work was the public website: shelling out the basic back-end structure, and focusing on two live visualisations that are probably the most technically complex part of it.

    The public site is entirely separate to the telephony application: that way any popularity on the public internet won't affect the gameplay experience. So to represent any kind of data on the public site, we need to build some data-emitting endpoints on the telephony application. Once those were in place, spitting out sanely formatted JSON, I could start prototyping the visualisation around that data format.

    The visualisations began as single HTML pages, using static inline JSON to seed them. Once I'd built up the representation of that code, moving to D3‘s d3.json method to suck the data over the network was not so hard – but it's important to break these problems down in the right order, and the most important problem in this case was: given some JSON, how do we build both animation and interaction around it?

    (As a side note: despite the evented complexity of what's going on, I'm reminded again of how much I enjoy working in D3; one of my favourite New Things I Learned This Year and well worth your time if you've not encountered it: it's useful for all manner of things).

    By the end of the week, we had made a good amount of progress: the beginnings of a public site, the IA and design nearly complete, the beginnings of a back end, and importantly, the complex viz largely prototyped (meaning all that was left would be to incoprorate the actual designs/markup).

    Almost nothing other than Playable City this week, as things should be: the only other things of note were a few discussions about workshops in July/August, and components for Sore slowly arriving.

  • Week 37

    1 July 2013

    Two main focuses this week: Playable City, which moves ever-closer to launch, and Sore, which is in early development stages.

    The majority of Playable City work focused on two completely new kind of object. Most objects behave in the same way, and follow the same rules. However, we wanted to add some objects that behaved totally differently. One type has something that resembles a “dialogue tree” in it, with a degree of branching; the other is how objects advertising the game – posters, banners, and the objects they're attached to – behave.

    The latter was a variant of what we already have, and not too complex to rig up; the former was more complex. Once Sam had worked up some example flowcharts of what he thought such dialogue should feel like, I implemented them as simple command-line sketches, printing and receiving input from STDIO. That helped me debug my logic around how I was choosing what piece of content to show next – and meant that once I'd solved the logic, I could port it into the stateful, database-driven Playable City code without also having to decide how it worked.

    I also began thoroughly documenting the processes and logic involved to make them visible to the rest of the team, and to aid decision making. That's also going to be useful as we try to put together a “burndown” – a canonical list of everything left to do.

    Sore is still very much in development, but a long meeting on Thursday hashed out what it might be better, derisking some parts of it, adding a few new features, and over the weekend I spent a little time pulling together two prototypes: one, of the software that will drive out; the other, of a book it can produce. It's an unusual project: a creative collaboration, but very much whatever I want it to be, so pushing it to some unusual places. In this case, into materials that are going to be interesting to work with: equal parts software, hardware, and print.

  • Just a quick note to highlight the interview with Keith Stuart over at the Guardian Gamesblog that Ben and I conducted about Hello Lamppost.

    We've spoken about it loosely to a lot of people, and there's been a lot of high-level press doing the rounds – excitingly – but it was great to be able to go into a bit more depth about our influences and approach, and how the Playable City relates (or not) to the Smart City. It was also great to be able to cite the peers and friends that have influenced the project more explicitly.

    You can read it at the Guardian Gamesblog.

  • Week 36

    23 June 2013

    I spent a day in Sheffield this week, for a short piece of design consultancy with Rattle. A really good workshop: some suitably curvy thinking, good sketching, and the result was a somewhat curious piece of media invention: inventing a media format for data visualisation.

    A second day in the studio wrote this up with sketches, notes, and animatics. I think it's gone in an interesting direction, though it'll be interesting to see how it develops once it's in the hands of makers: that's where the meat of this work will be.

    On Hello Lamppost – Muncaster – this week, the big news was the launch of the trailer. That's had a great response, from both friends and the media. My colleagues at PAN sure do know how to make charming, informative short films.

    Lots of meaty work on Hello Lamppost, too: defining and designing the final types of interaction, and also working out what we need the website to do. The coming weeks are going to be very busy on that front, burning down to launch, but we've got a plan in place: it should turn out well. Ben's written a great update about everything we've been doing over at the Pan blog.

    And finally, some communication work – pitching, discussing, scoping – about a project called Sore; bringing the likelihood of it happening closer to the event horizon.


  • Hello Lamppost Trailer

    19 June 2013

    Hello Lamppost launches in just under a month. This is the trailer we shot in Bristol a few weeks ago for the project.

  • Week 34

    10 June 2013

    A quiet week, but worth documenting nontheless (if only to remind me of the shape of the year).

    The majority of making-work was focused on Playable City – primarily firming up some infrastructure, making a few things more robust, and poking at the forecast.io API to see if there was anything to be done with it.

    Otherwise, lots of new business development: some research and a proposal for an art project in September, and a mentoring project I can hopefully write more about shortly.

    And, the realities of business: finalising tax returns, talking to accountants; continuing maintenance on live projects.

    It's often on these quiet weeks that weeknotes feel more like a chore than a joy, but I'm holding onto them: they're useful as a practice, to see the ebb and flow throughout the year. Some weeks are busy, and this one was bitty and quiet. But the main thing it reminds me is how busy things are going to get quite soon. Onwards.

  • Week 33

    3 June 2013

    A short week, thanks to a pleasant and much-needed sunny Bank Holiday Monday.

    This week involved a bunch of travel. Tuesday was a day in Brighton to discuss a potential art commission, currently referred to as Sore. Lots of interesting thoughts and discussion, but I need to sit down and process it offline a bit. So that's going to be a focus of early Week 34.

    Thursday was a trip to Bristol for the next tests and demonstrations of Hello Lamppost, our Playable City commission.

    A secret: I find playtesting painful.

    It's a similar pain – but not identical – to user-testing. If you've ever stood on the dark side of a two-way mirror, and watched someone stab with a mouse at a product you've designed, failing to achieve a task you were sure was straightforward… you'll have a glimpse of that pain.

    But the element of testing games that I find uniquely painful is what we're testing for. I've watched users fail to complete tasks, which was annoying, because we were designing for utility, for functionality: helping people achieve goals swiftly and simply.

    When I test a game, I'm testing to see if it's fun. Well, and many other things: is it balanced? Is there a skill curve? Would you come back to it? How do experienced and new players work together?

    At the bottom of that, though, is a summation of all those questions: is it fun? Did it entertain?

    Watching somebody explicitly not have fun with something that's only purpose is (in one way or another) to entertain – well, that's more awkward than any transactional website test I've done.

    So for the duration of playtests, I'm pretty on edge.

    First tests are always particularly tough – they should be; they indicate what's going to need work. I'd be worried if they weren't. And our first test, a few weeks ago, showed up lots of edges and holes.

    Thursday was our second playtest in Bristol, and it was a notable improvement on the first – and satisfying and insightful in its own right. Lots of the rough edges from the first test were sanded away; the new elements of charm were all picked up on; and whilst it may have failed or had obvious holes, they didn't seem to have the disarming effect of the first test, where players would be jolted out of the experience quite hard.

    Also, the 12-year-olds we tested it with definitely enjoyed it, which was a really positive sign. (As was the enthusiasm of the project sponsors, who saw it later that night).

    A good day, then: all the work of the previous week, and of some of this, paid off, and we've got a much clearer sight of the critical path for the final month. And, slowly, I began to get over my hatred of how playtesting makes me feel.

    The week ended with a bit of maintenance work on Concert Club, filing down some rough edges and fixing some bugs that our early users have caught.

  • Week 32

    28 May 2013

    Much of this week was spent refactoring Muncaster – the Playable City codebase.

    It's the kind of code that gets fiddly to work with quickly. In making a conversational interface, you quickly move away from the kind of architecture that's very simple to model in Object-Oriented languages and frameworks, and into something that's much more about flow and state. As such, there's lots of flow control and logic.

    The catch here is that, in the Playable City design, there's very little complexity to the “state” end of things, and very little happens on state-transition; instead, most of the weight of the work comes down to the flow control: what to say next, given what we know.

    It's been very easy to get into a “mazy of twisty passages, all alike", especially as we try to adapt and modify the code based on playtests; there are so many dependencies that you end up walking through the control flow yourself as you code it a lot.

    So my goal this week was to build something more final to build upon, tearing out things that didn't work, and removing as many if statements as possible.

    By the end of the week, a large amount of conditional logic had been torn out, and replaced with many, many tiny POROs, all responsible for building up fragments of a conversation, and none of which know anything about state other than the conversation they're given to work with as input. In some ways, it's not much simpler, but it's proving much easier to modify, tweak, and extend, and that feels like it's been really worth it. Logic has been torn out of the ActiveRecord models, and also become far less dependent on the database, which feels like an architectural win – and should make delivering Week 33's playtest easier.

    On Tuesday, I took part in a collaborative experience design workshop, run by Experientia. I said “yes” to this in part to see what that process was like from the other side of the table, and watch another design firm at work. It was super-rewarding on that front, and gave me some useful thoughts about future practice; also, I got to make lots of drawings with felt pens, which possibly bemused the other participants, but was a great work-out for my design brain.

    And, of course, the other big news of the week was that Caper launched Concert Club. This is Detling: the project I've been talking about for the past couple of months. I'm really glad to see it in the world, even for its limited prototype lifespan: there are some interesting lessons to learn from it, and it's been a lovely build process. I wrote more about it in this longer post last week, and I'd encourage you to find our more if you haven't already.

    Week 32 was a lot of code, then, and the usual last-minute wranglings to get a project live, but lots of nice pay-offs. In Week 33, we'll get to put that code to use.

  • Week 31

    20 May 2013

    Monday and Tuesday were spent in Bristol at the Pervasive Media Studio, running our first playtests of Hello Lamppost. Lots of useful feedback, lots of things to patch up and fix, and excellent support from the extended team at PMS.

    The middle of the week saw the final demonstration of Detling to the BBC. That should be launching in a few days – and I'll share more details of it then. It was a good demo, but also exciting to consider what the prospects beyond the early alpha will be.

    There was a short piece of work towards the end of the week – Wilton – with After The Flood. I've known Max for a while, but it was good to work with him, even on a tiny engagement. A short period of sketching, thinking, and producing some illustrations of interfaces around data.

    And then at the end of the week, I took the talk about data from last week at Telefonica, and showed it to a few people at Decoded. I think it went down well.

    Lots of thinking and fixing on Hello Lamppost – and by the end of the week, a plan of attack to build what we hope will be the final platform for it. That's for week 32, though.

  • Week 30

    12 May 2013

    Back to Playable City – Muncaster – this week. I spend a few days with Sam at Pan, really honing down the conversation mechanic and making sure the design supports everything we hoped it would. And then, for the second half of that work, focusing on getting a working implementation for playtests next week.

    Conversation-systems – as I have learned many a time, most notably in Havasu – inevitably turn out to be messy tangles of procedural code, so it's worth working hard to keep the codebase as sane as I can. That tends to involve drawing lots of flowcharts, documenting not only the expected routes through the system, but also the way the software implements those – which for various reasons isn't always the same. It's a good, visual way to make sure I don't get lost in a maze of my own making.

    On Wednesday, I went to Telefonica Digital to give a short talk about data visualisation at an internal hackday. That was a good excuse to do some new thinking, and I'm pleased with the new talk that emerged; some useful ideas to continue to think on, and which will no doubt feed into future talks. Thanks to Paul for the invite.

    I also spent an afternoon working one final feature into Detling that we all agreed needed to be slotted in; it really closes the loop of the alpha, and makes the potential of the product much more obvious. Nice to drop it in at the last minute with relative ease. We're showing the project to the BBC next week.

    And finally, this week's freelancer top tip: GOV.UK has ICS files for bank holidays. Thanks to subscribing to that a while back, I remembered to take Monday off. Ice cream and the smell of the sea are a very restorative way to kick the week off.