Open Space Coding Day (31st Jan 2009) – Wrap Up
Wow, what a day! Really, really think the early wake up time and travel were worth it! This is a wrap-up of my first ever “Open Space Coding Day” (OSCD).
WARNING: This is a long read! I wanted to get all of my experience out on to this blog for possible discussion! I have tried to separate the basics of the day to my “diary-like” narrative, but that can be a bit of a grey line.
Having proceeded to run off in an orderly fashion out of London Waterloo in the wrong direction and correcting myself, I ended up at the Conchango offices. For me, this was real nice to see what I would consider to be a “modern developers office”. Put simply, my working environment sucks, and it was nice to see others have much nicer surroundings. I only hope I can one day get myself into such an office. The Conchango team as well as the other guests were very welcoming.
Once we had arrived, Alan Dean opened with a brief run down of the Open Spaces Principles/Philosophy, and we got straight in to coming up with the sessions that we would like to take place. For me, I didn’t suggest anything – I think I had a brain freeze, and it was difficult to not think “oh, that would be cool” when other people were coming up with suggestions, this really kinda threw me off.
It was later unanimously agreed that the voting/suggestions may be better performed before the event to allow plenty of discussion and help gear the day so everyone can get the most out of it. This is an excellent demonstration of what I would consider to be an “agile process”, do something, see what is wrong, fix it. Equally it was good to see Alan totally open and responsive to feedback rather than seeing it as an insult (I know many hosts might).
This was real odd for me, I am quite used to “corporate style” sessions where session hosts had a plan, and you are really just along for the ride. With OSCD we were completely in control. You basically join a session, and then all participants are masters of their own destiny. It was good to see how quickly the process naturally evolved. Within our own group it soon became abundantly clear that some members were a lot more familiar with the technologies being discussed. They ended up becoming the driver, writing the code to express what the rest of the group were discussing. Groups then proceeded to naturally pick the equipment that made sense. I think it was obvious that projectors were the common favourite. Discussion and coding then continued until the session is completed.
This is my experience of the day. Just to reiterate, the sessions discussed were not the only sessions running, these are just the ones I participated in. Other sessions included:
- Creating reusable build scripts.
- “Hands on Secure Development” with Barry Dorrans.
- OpenRasta + Static Analysis.
- (I’m sure there were a couple more but they escape my memory! Please let me know and I will add them!)
Session One (Testability of MVC Frameworks)
I had to go along to this one. To be honest I have never used an MVC framework (such as ASP.NET MVC or MonoRail) but it is definitely one of the things on my “ToDo” list for this year. Just because I am an ASP.NET developer, it does NOT mean I like WebForms! So, I joined the session as a complete n00b, pretty clueless as to what the frameworks are and how they work.
As discussion began, I let people know I was bringing down the group but they were kind enough to give me a brief synopsis of how MVC frameworks work and what they do for web applications. Jeremy Skinner kindly took the drivers seat for the session. His laptop then ended up hooked up to the projector, we began discussing from there, and code was produced. About half way through we had written enough supporting code for the basics of what we were discussing, and then really started getting to the crux of the issue - how the hell do you test visual look and feel to business specifications, with a reasonable ROI? We began weighing up various options such as:
- testing against hard-coded expectations of the HTML that is rendered to the page.
- Pushing the tests to the object model and making assertions about the object that is passed back, in relation to styling/formatting (e.g. add a CSS property to the objects and assert that the correct CSS is applied to the object under certain conditions).
These were the main two things that I think really emerged as possible approaches, but both had a lot of pro’s and con’s. Hard –coding the HTML expectations is very brittle, but doesn’t impact the object model. Enhancing the object model with “view-like” concerns seems a little odd, but does offer the opportunity to actually make assertions with code that is a bit more malleable.
We all agreed on one thing: Currently no solution that is available is going to be:
- Easily understandable.
In short, there are many variations of implementation, but they are all so hard no-one wants to do it :) (i.e. the reason too many people are still using MS Project).
Is the session a “failure” because we didn’t come up with a solution? Absolutely not. I found the session very thought provoking, I think any coder worth bothering with would at least have an interest in solving difficult problems. My brain was absolutely whirring after this session. Mission success.
A big thank you to Jeremy for driving and the excellent knowledgebase on MVC that is his head, also thanks to Alexis Kennedy, Gojko Adzic, Mike Wagg and the names of the other two gents escapes me (sorry guys, please let me know).
So eat-o’clock came around so we all piled out in different directions. Myself, Emyr and Barry ended up grabbing an ostrich sub from the local market! Awesome!
Session Two (Managed Extensibility Framework - MEF)
This is another thing that I know little/nothing about but really wanted to find out more, so I went along.
Again, this demonstrated the really cool thing about the evolutionary style that Open Spaces promotes. This session worked a lot differently to the first session. Rather than have one driver and lots of discussion, we soon realised that the concept of MEF is very simple –we just wanted to all get coding and seeing how it works and have a play. So laptops out and on we decided to pair up.
I paired with Andy who was very helpful (thanks again Andy!) we then started talking about what we would like to do with MEF. In the interests of keeping thing simple for my peon brain, I opted for a “string transformation plug-in". The idea being that we would be able to build additional transformation routines and just plug them in to the already-built host application. We started real simple with some in-assembly uppercase/reversal transformations. The acid test was to then move these to a completely separate assembly and just be able to load/execute them at run time.
This went really well, we actually got working code pretty quickly, and it was real nice to see the code working totally dynamically (i.e. comment out a whole class, replace the DLL in the running app and see the transform mechanism disappear). Obviously we only scratched the surface of MEF, but it was a hell of an introduction for me.
Closing the day was pretty quick, final "thank you’s” to the excellent host Conchango and directions to the pub for those that were staying! (sadly I had to leave to get a train back).
A very productive day. Great opportunity to network, plenty of scope to learn and experiment. I will definitely be wanting to attend any other sessions that take place! All those interested, Alan did also make a good point of “this style is not copyrighted – if you want to run your own, do it!”. So, if you know of any similar sessions being hosted by yourself or someone else, get the word out. Let me know, I will be happy to spread the word!
Finally, just to once again thank you to all those that I have the privilege of meeting for their time, patience, hospitality and initiative – it has really been appreciated by this geek :)