Tag Archives: Developer Day

DDD Scotland

Last weekend was Developer Day Scotland. Much like the original Developer Days that I’ve been along to many of based on the Microsoft Campus that relaunched with a new team running them, this was a relaunch by the Scottish Developers. As there were some interesting sessions on the agenda, and since I fancied an excuse to take the West Coast Main Line over Shap and through the Southern Uplands – something I usually only glimpse whilst driving the M6 and A74(M), I grabbed myself a ticket and headed north.

The conference was held at the Paisley Campus of the University of the West of Scotland. The Reading Developer Day’s are relatively unusual being held at a company site, but then few companies have the kind of setup Microsoft have that is suitable. Having said that the experience of attending a DDD at a University showed up several advantaged, not least that they have much more space, and in particular the main hall is large enough to take all the attendees – at Microsoft the prize giving at the end of the day ends up being done with all the attendees stood in the foyer and the organisers stood on the stairs!

This conference I was very much picking sessions to tie in with upcoming work, rather than just sessions that piqued my interest as I have done at other DDD events.

First up I kicked off with Filip W talking about Interactive Development with Roslyn.

Filip started off with a quick recap of the history of C# as a language – enough to make me feel a little old as I can remember my first experiences with the early versions of C# back with Visual Studio 2003. This was to highlight that the way developers worked with C# hasn’t changed much over the years, which is why the new Roslyn compiler is such a game changer.

He started off with a simple feature, dotnet watch that allows you to run a specific command as soon as a source file changes. This needs the VS2017 project format, but allows a great deal of flexibility in how you work with code.

From there he moved on to Edit and Continue. Edit and Continue has been around for longer than C# – it was an often used feature of VB6 that was demanded in .Net as people moved across. It has however been problematic, as a general rule of thumb tending to support a version behind the current cutting edge C#. There have also always been a number of limitations, in particular not being able to change lambda functions at all. Roslyn has changed that. Finally it has now caught up with the current C# 7.

For the next part of his talk Filip talked about C# REPL, what is known in VS2017 as the C# Interactive Shell.

The C# REPL didn’t exist before Roslyn, because as a compiled language the kind of interactive functionality just wasn’t possible. With Roslyn, Microsoft has introduced a special mode that relaxes some of the parsing rules to make interactive development possible, including the ability to use syntax that normal C# code would reject as illegal.

Interestingly as Filip explained, each line is still compiled, which does give the interactive window some interesting advantages over interpreted interactive languages, allowing developers to interactively step back through compilation. It also integrates in with the current open solution allowing developers to manipulate and explore the current solution in more complex ways than previously.

C# REPL exists in several forms. It can be run directly from the command line, whilst the C# Interactive window in Visual Studio is a WPF wrapper around the C# REPL that leverages extra functionality. There is also an “Execute in Interactive” right click menu option to immediately run the code under the cursor. The final variation of it is Xamarin Workbooks which uses Markdown format text, and uses the C# REPL to execute any code blocks in the document. Output can also be sent to the iOS or Android emulators as well as running locally.

Filip finished off by discussing Live Unit Testing, something I’ve already been using in VS2017. This runs tests as they are actually being coded – it doesn’t wait for code to be saved. It does this by hooking in as a Roslyn analyser. It’s straightforward to write a custom analyser ourselves perhaps to enforce coding standards, or guide other developers in the way to use a library – indeed some third party library developers are already including analysers to do just this.

For session number two, I stayed in the main hall for Jonathan Channon talking about Writing Simpler ASP.Net Core.

Jonathan started by talking about a project he had worked on where speed had been an issue, and they had tracked the problem down to the large numbers of dependencies being inserted using dependency injection. The issue being that the inversion of control mechanism used to insert the dependencies was using reflection.

The issue is with the way we do SOLID in ASP.Net, so Jonathan used a series of examples showing how we can go from a solution heavily dependent on injecting dependencies and using mocking frameworks for testing, to something that uses no dependency injection or mocking frameworks at all. He has his examples for the talk online in a GitHub repository.

What is perhaps most interesting about his final solution is that the technology he is using has been around since the earliest days of C# – using delegates and static methods, along with his own Botwin library to simplify building an API going to a much more functional programming style model than is used in traditional ASP.Net.

Jonathan also highlighted a number of other blogs and videos. Mike Hadlow blogs on much the same technique highlighting how much less code using a functional style produces. Posts from Mark Seeman and Brian Geihsler also talk about how SOLID principles lead to a profusion of dependencies making codebases difficult to navigate.

Given that so much software these days follows the SOLID principles, this was a challenging different view on how systems should be developed, one of those “everything you think you know is wrong” type sessions.

The next session I attended was Paul Aikman talking about React.js and friends, which was one of my must attend talks as I was due to start working with React.js the following week for the first time. Paul has posted his slides on his website.

Paul started by taking us through how his company has eventually arrived at using React.js, starting out with Webforms augmented by JQuery, through Knockout and Angular 1, before settling on and sticking with React.

He also highlighted how there has been a gradual shift from performing a lot of processing on the server side with minimal client side functionality to the current situation where customers are expecting a rich and responsive experience interacting with websites that mean clients are now a lot fatter. He also discussed why having started with Angular 1, his company took the decision to shift to React, which effectively came down to the significant changes between Angular 1 and 2 meaning that they would effectively have to learn a new framework with Angular 2, so they went out to what they regarded as the best at the time, and changed to React.

He then gave a rapid overview of how React worked, which I found really useful coming to React for the first time during the following week. He highlighted that given the years of being told to separate logic and presentation with the MVC pattern, one of the biggest surprises with React is that it mixes logic and presentation together.

Paul also highlighted that React only focuses on UI logic, following the principle of doing one thing, and doing it well. There are additional libraries such as Redux and React Router that provide the additional functionality needed to build a web application.

After lunch, I decided to head along to Gary Fleming’s talk on API’s on the Scale of Decades which was on the problems with API’s, and how developers can write and API that can evolve over time rather than lock you in to poor early decisions. Once again Gary has his talk notes online which are well worth taking a look at. As a side note Gary was using an app called Deckset to run his presentation, that takes presentations written in Markdown syntax – considering the amount of time I spent reworking Markdown notes into a Keynote presentation recently, I’ve noted it down as something to look at further.

Gary’s talk was the one that promoted the most heated discussion of any I attended, both at the session, and also when I came back to the office. He started from the point that designing API’s is hard, but that what most developers want in an API is something that is both machine and human readable, changeable, testable and documented.

Gary started with a crash course in the concept of affordance, using Mario, and animals in a tree as examples! Gary was highlighting that in both the case of the game, and different animals using a tree in different ways it was through their knowledge and experience that they were interacting with the tree or we were playing the game, API’s should be similar. He used further examples where knowledge and experience allow us to interact with something – save buttons that look like floppy disks, even though many people now have never even used a floppy disk.

Applying this to our API’s the mechanisms for controlling them should be included in the information returned by the API, you shouldn’t separate them out.

Looking at a common affordance on an API, if there is a large dataset to return, generally we will page this, and there is a common set of affordances for stepping through the dataset. Going back to the days of the text adventure games from the early days of computer games, once again there was a common set of verbs with which to interact with the game.

A good tip Gary gave for thinking about the verbs and nouns to describe these affordances was to think about how you would ask voice assistants like Alexa or Siri to do what you want to do. He also suggested that well designed affordances are effective documentation for an API – if it is clear how to use an API you don’t need extensive documentation.

Gary then moved onto the problem of changing an API.

He used the example of the Ship of Theseus. In this thought experiment a ship over a long life has ongoing repairs such that eventually every single plank of wood and component of the ship has been replaced – is it the same ship? If we use this lens on an API, if over time we are changing our API, is it the same API, when do our changes take it from version 1 to version 2?

Gary’s suggestion was that we shouldn’t be versioning our API at all. To respond to the surprise from the audience he highlighted that we cope with this every day using websites, all of which change their API that we as users interact with. We apply our knowledge of the website and cope with the changes.

Gary then moved on to testing. His first example was asking the question of why we need brakes on a car? The obvious answer is to enable us to stop, but they also allow us to go faster. For the same reason we need tests on an API to allow us to change them faster.

Fundamentally, if we know that an API will inevitably change, we need to plan for those changes. He suggested that we should be using Consumer Driven Contracts, where the consumers of the API gives detailed expectations of how the API should behave, and then these form the basis of the tests against the API. He also highlighted the important of using fuzzers to ensure the API responds and handles unexpected data.

His final point provoked the most discussion, looking back at what he had been discussing he highlighted that JSON, which is what many APIs currently use is limited, and suggested that it is something we use by convention, rather than because it is the best tool for the job. He suggested that using HTML5 was a better option as it offered a richer interface that gave greater affordance to the users of the API. There was a good deal of incredulity from members of the audience, and indeed a similar level from our architect back at the office after the conference. Gary has subsequently said that there are limitations with using HTML5 also, but it was as much about getting people to question why they use JSON as proposing HTML5 as the solution.

My next session was also run by Gary, as I decided to pay a visit to the community room where he was running a Lean Coffee session.

The group came up with a mixed selection of topics to discuss. First off was a topic proposed by Becca Liddle who is the organiser for Women in Tech Scotland who asked about perceptions of women in technology companies. The discussion was wide ranging and covered a number of common issues around how women are treated both by company culture, and male colleagues, and also how male dominated tech culture can be off-putting to women and minorities. Becca had talked to a number of other women attending the conference earlier in the day and shared some horror stories of their experiences. Certainly food for thought as to how we encourage a more diverse workforce in IT. We also discussed what we were currently learning and broader issues around training, and also had a discussion about the impending changes being brought by GDPR which was in some ways a bit of a relief as it seems everybody is as concerned about it, and nobody feels they will be ready.

Next I went along to a session on Building APIs with Azure Functions by Kevin Smith. Again this was a session I attended because as a team we’re using Azure Functions in order to try and break up large bits of processing into horizontally scalable functions.

Kevin gave a good overview of the functionality available, highlighting the rapid development and simplified integrations, and also how they can be developed using Visual Studio. Kevin also has a good introduction on his website.

He also gave some good insight into the issues, including issues debugging them, and in particular problems with Microsoft breaking Azure functions. Ironically his final demo was also one that failed on the day I’m not sure whether it was because of a Microsoft breaking change!

My final talk of the day was Peter Shaw giving an Introduction to Typescript for C# Developers – once again it was a session I attended because we’re using Typescript for the upcoming work and the talk served as a good introduction.

First though a moan, Peter refused to use the microphone in the hall on the basis that he “had a loud voice”. Now he certainly did speak loud enough that I with good hearing could hear him without a problem, however experience looking after the sound at church is that if somebody does that there may well be people in the audience who have hearing difficulties, but nine times out of ten when challenged like this, they won’t feel comfortable in drawing attention to themselves as being unable to hear. At church the reason we ask people to use microphones is because however loud peoples voices are they can’t speak loud enough to drive the induction loop that many people with hearing difficulties will use, and speakers refusing to use the microphone leaves those people feeling discriminated against. Sometimes they will suffer in silence, other times they will complain to the sound crew, almost never will they complain to the speaker, who carries on in blissful ignorance thinking they have a loud voice and everything is fine. I hate working with a microphone too, so do many other people, but they are there for a reason, so if you’re a speaker, and there is a microphone, please use it!

Anyway, moan over, onto the talk. Peter started with an overview of why Typescript is important. More and more applications are moving into the browser, much as Paul Aikman highlighted in his talk on React we’re moving from applications where much of the functionality is in complicated server side C# code, to applications with richer client side experiences using Javascript. Similarly the growing variety of internet of things often use Javascript.

For developers used to the rich type-safe world of C#, Javascript can be a bit of a shock. Typescript is a language designed by Anders Hejlsberg who designed C# to open up Javascript to a back end developer used to C#.

As such the syntax is familiar to anyone who is used to C#, and makes the transition to Javascript development relatively painless.

Interestingly Peter highlighted that Typescript is more of a pre-processor than a compiler – ultimately what is produced is valid Javascript, but Typescript acts like a safety net enabling the developer to write enterprise scale Javascript applications.

There are a number of subtle differences however driven by the differences in Javascript. For example Typescript has Union Types that allow for the Javascript ability to change the type of variables. Undefined and null are still usable, however the Typescript team advise against them.

There is lots of Typescript support around. Many of the most common Javascript libraries already have typescript type files defined to allow them to be used from Typescript. Peter referred us to Definitely Typed as a good repository of high quality Typescript definitions.

As an introduction it was a useful talk giving me as a C# developer taking first steps into Typescript confidence that it won’t be a difficult transition.

After that we had the closing section of the Developer Day with the traditional raffle and prize giving, and as is traditional (and much to the disappointment of the kids because an Xbox X was one of the prizes) I didn’t actually win anything in the raffle. Was no bad thing however as I’m not quite sure how I would have got an Xbox back to Reading on the train…

DDD8 – Apples, Boots and @blowdart

Major embarass @blowdart session!  #DDD8Today was the eighth annual(ish) gathering of four hundred of the Microsoft Development community for a day of free technical training. Once again it was spectacularly over subscribed – sold out faster than Glastonbury (all the places went within fifteen minutes) and with no Microsoft speakers had the usual mix of sessions, some of which perhaps you wouldn’t expect to see at Microsoft.

The day started off cold – although there was no snow it was definitely a case of scraping ice off the car, and if you were in any doubt, one look at Rachel Hawley’s footwear could tell you! Having said that, as has become traditional at these events, bacon butties to warm you up awaited those who got there early.

First off a couple of observations. For a Microsoft Developer Day, it was a very good advert for Apple! Of the five talks I attended, two were obviously running off Mac’s. One was about iPhone development, so using a Mac was a given, although the presentation was also given using Keynote (and all the more slick for it) and rather than messing around with font sizes as all the PC based presenters have to do Chris Hardy used the built-in OS X zoom gestures to quickly focus in on what he was showing. The other Mac based presentation given by Ian Cooper wasn’t anything related to Mac development at all, but was presented in MacOS X, using the Mac version of Powerpoint, with a windows development environment running in VMWare. It’s not so long ago that developers would buy a Mac, largely ditch MacOS X and stick Windows on it – it does seem that even with the advent of Windows 7 that isn’t always the case now… The other massive advert for Apple was not surprisingly the vast numbers of iPhones in evidence. I certainly think it would have been worth somebody doing the same as Scoble did at Le Web to get a ball park figure of how many there were. There were a good few Google Android phones around, but few if any Microsoft based phones in evidence. This was also reflected in the sessions – no talks on Windows Mobile development, but there was a talk on using MonoTouch to develop iPhone applications!

As is normal for these days, what I thought I would attend, and what I actually attended were slightly different. I initially thought I’d just take up residence in Chicago 1 for the day, but in the end I fancied a change of pace.

First up I attended a talk by Ian Cooper on Real World MVC Architectures. This in part was because I’ve just done my first ASP.Net MVC project, and I was half expecting to find I’d done it all wrong, as to a large extent I’ve put it together as felt right rather than following any explicit paradigm. To my relief it seems all the talk of proper architecture seems to be sinking in, and the way I’ve constructed it is pretty much as was suggested, even to the point that I’ve used particular techniques without having read about them as yet in my MVC book in that I understood why they were being used but didn’t recognise the idea by name! I suspect the session might have been pitched a bit too much towards the beginner end of things for experienced MVC programmers, but for me it was certainly a good reinforcement of the techniques.

Next I slipped next door for a change of gear, and a non-technical talk by Liam Westley who was talking about how to be a small software development outfit and not go bust. To be honest, the principles Liam outlined can apply equally well to large software houses, a number of which I’ve come across who don’t get this stuff right, and even to people in a corporate environment like me as getting these sorts of things wrong will at the very least have your internal customers looking elsewhere for their software, or at the worst put you out of a job. Liam gave us a set of broad principles that any software developer should be doing as a matter of course – things like delivering properly tested software, applying proper logging (even in a corporate environment fixing a problem before the users have got round to reporting it scores serious brownie points), and understanding your users, all go to making people happy to give you their software work, and not go elsewhere.

For session number three it was a first for me, in that it was the first time that I have heard Jon Skeet speak. His name will be familiar to anyone who frequents Stack Overflow – and as his reputation is testament to he sometimes seems to answer C# questions within seconds of them being asked. What is slightly more surprising is that his day job is at Google as a Java developer. Even more surprising he fits all of that in with being a Methodist Local Preacher too – but I suspect that stands him in good stead for being able to deliver material well, as from the experience today his reputation is well deserved. The latest version of C# brings in some interesting, but quite complex new ideas, and he did manage to put them over in a way that even with the early start on a Saturday I pretty well followed them. Having said that whilst I liked the presentation, and many of the new features, I was less than impressed by the return of the ubiquitous VB variant data type, in the guise of the dynamic type. Whilst I am well aware that the way the variant and the dynamic work are rather different, it’s much more about how it will end up being used, or more likely abused. I’m with Jon Skeet on this in that I much prefer a situation where the types can be validated at compile time. Whilst there are legitimate reasons for adding dynamic, and as an exercise in language design the implementation is very impressive, as with the variant I am quite sure it will end up being thoroughly misused, and will lead to many a difficult to nail down bug.

Next up was lunch, and was the traditional scramble for a lunch bag. Unfortunately it seems that the entire occupants of the Chicago 1 side went the same way and got all the non veggie and non seafood sandwiches (I have to watch having too much of certain types of seafood with my gout) and as always it was a bit of a lucky dip as to what else you got, so I ended up with a sandwich, crisps and an apple that I wanted, and a can of diet coke and a snickers bar that I didn’t want. I know they’ve tried various things over the years, but I still think there has to be a better way than this, as it was pretty obvious looking around that not everybody wanted what was in their lunch and there was a lot going to waste.

The lunch time Grok Talks had relocated this year, and were in the atrium in building four. This certainly gave a bit more space, but did seem to make the security guards mighty jumpy – I got a stern “I’ve just seen you behaving strangely” from one for taking this picture – I just liked the look of the clear blue against the white of the building structure and was going to make some comment about the weather! The Grok Talks were marred rather by problems with the technology. For a start the speakers were badly positioned in relation to where the presenters were standing leading to endless feedback problems. The talks also took an absolute age to get started, and when they did people seemed to overrun, which as a result led to people who were further down the running order being disappointed. There were a couple of interesting talks though, and it was especially interesting watching Gary Short intensely watching somebody else demonstrate Code Rush! Looking at the response hopefully there will be a few more converts from Resharper, a jump I made many years ago!

After lunch was one of my personal interest talks. As an iPhone owner and software engineer I’ve always quite fancied giving an bit of iPhone development a go. The problem is that as well as learning a new platform and new environment, developing for the iPhone requires learning a new language, Objective-C. However Chris Hardy was demonstrating a way that I could leverage my existing C# skills using the Mono environment and an add on to it called MonoTouch. Whilst developers still need to be able to read Objective-C to understand what is going on, and still need to learn their way around the Apple API’s, it allows them to develop entirely in familiar C#, and even brings advantages in terms of some of the extra type safety that C# brings. I have to say I was pretty impressed at the environment and what it can do. I was less impressed by the price – $399 for a personal license, which only covers you for a year of updates, with even more for a corporate license – far too much for your average hobbyist programmer to even consider. I can’t help thinking that they are missing a trick here, and providing a low cost or free license for developers in return for a share of the revenues, maybe using some sort of phone home code to keep track would certainly broaden the base of programmers using it.

My last session of the day, to be honest I would have gone to even if Barry was just reading the phone book, as this was potentially his last appearance at a Developer Day before he loses the essential qualification for being allowed to speak of not working for Microsoft, as in a scant few days he will be starting a new job working for Microsoft at one of their offices in Redmond. As always there was the classic banter with people he knew in the audience, in particular Jon Skeet who was attempting to pose increasingly difficult questions it seemed. Barry also started off by hijacking the session next door as Ben Hall, the speaker had a birthday and was foolish enough to tell somebody! What I was also expecting, and got in spades were interruptions marking his departure from the UK development scene. His book Beginning ASP.NET Security featured in several. In the first Liam Westley gave a touching and heartfelt tribute, and said how much he had been looking forward to the arrival of the book – as it was just the right size to prop up his wobbly table. In another they spoofed the winter cold adverts, suggesting that the book was good fuel to keep the elderly warm. The session finished off with a clip from his appearance many years ago on The Crystal Maze, and several of the organising team appearing in T-shirts especially prepared for the occasion. All in all it was a memorable way to finish off the day, and hopefully a memorable occasion for Barry as he heads across the Atlantic. The one question that remains is whether all the spelling mistakes in the presentation were down to Barry, or whether somebody did get at his presentation before he went on…

All in all it was an excellent day, and although I know there were a couple of sessions that had problems, the ones I attended were all excellent, and well worth the spare time given up. It was great to catch up with friends from the community, previous developer days and previous jobs. Whilst it does appear that the day is very much a victim of it’s own success (even with local developer days around the country people still travel from far and wide to attend this one in addition to their local days) hopefully a way can be found to allow it to keep running in future years, and all credit to the organising team, and the staff at Microsoft for keeping the whole day running smoothly.

Developer Day 4 Geek Dinner

Wine

After the Developer Day, comes the night. With a number of people staying around the area and heading home tomorrow, plus one or two like myself and Dave who live locally, three out of the four Developer Day’s have been followed up by a dinner, this one being organised by Zi Makki.

As with the DDD2 dinner, I headed home to collect Beth, who although she would be bored silly during the day, quite enjoys the conversation at the dinner. In a change to previous dinners, after her starring appearance in a Channel 9 video, Dave’s other half Lou came along too and joined in the fun.

Down the Table

Unfortunately, as quite often happens with these things, there were a lot of no shows. Since the sign-up for the event is via a wiki, and opens pretty early on – indeed ahead of registration for the event, it is very much dependant on people taking themselves off the list if they subsequently are unable to attend. Sadly, failing to do this means that people who otherwise would like to come along, are put off. Looking at the list, we had a booking for forty people, and thirty-seven people listed as coming – however at least ten of those people didn’t show up.

Having said that, we had a great time none-the-less. In fact I barely talked to Beth all evening as she had a pretty wide ranging discussion with the guys further down the table covering everything from teaching to gun control. I had some somewhat more geeky conversations, however in general, although there is a slight geek focus to some of the conversations (and always the inevitable gadget comparison), ultimately the topics for discussion are as broad as any other party situation – there really isn’t an archetypal geek!

Creamed

It was great to see Lou at one of these occasions too, hopefully she enjoyed it enough to join us for one of the bigger London events in the future. I took a load of shots with the camera on the phone, thanks to the lack of light some are a bit grainy, but you can browse through my selection here. There were several other people snapping away during the evening, so hopefully we’ll be able to pull them altogether into a group later on.

Developer Day 4

Today was the fourth Microsoft hosted Developer Day, held at the Microsoft UK HQ at Thames Valley Park in Reading. As previously I’d been signed up to go pretty well since it became available, and as with previous events it did not disappoint.

As with the previous events I’d been through the online agenda in advance, selecting the sessions I thought looked interesting, and as before, the sessions I actually attended turned out to be rather different!

My first session was ‘How to Write Crap Code in C#’ presented by Ben Lamb. The slides for the session are online, together with some of Ben’s previous sessions. In terms of the content, he was somewhat preaching to the converted in my case, as on a couple of occasions I’ve had to sort out performance in bits of code. In the case of this talk Ben took a simple task – to count the occurrences of particular words in the complete works of Shakespeare (oddly enough almost the same task as my current employer got me to do at my interview for the programming test), and demonstrated a multitude of different ways for doing it wrong. Amusingly for one example, despite writing it really badly, on some occasions it didn’t make much difference, however when he got to strings, that was when he really hit the big time in terms of speed, indeed he actually had to partially optimise the example so it completed within the allocated time for the session. The fundamental problem is that .Net is really bad with strings, as they are immutable – complicated string manipulation should be done with a string builder object instead. Unfortunately many programmers who cross over to .Net don’t realise this and carry on using strings as they have done in other languages…

In terms of the delivery, I thought that Ben seemed decidedly nervous – but then I’m sure I would be when faced with 160 people! Unfortunately he also made the classic mistake of not running through your entire presentation before doing it, as he would on the day, which when coupled with his decision not to use his regular (and cluttered) account on his laptop meant that part of his demonstration didn’t work correctly. He also had the other presentation nightmare, running out of material. Having said that, he did seem pretty knowledgeable, so I suspect it may well be a case of the classic not enough time to pull it together issue…

Anyway, for session 2, I popped into the next door room for ‘Ruby on Rails for .Net Developers’, presented by Dave Verwer. I particularly wanted to see this session, as Ruby on Rails is one of the hyped up technologies about in the industry at the moment, and I wanted to see what all the fuss was about. As you may have gathered, Ruby on Rails is the competition for Microsoft, so it was an interesting choice of session. In a double whammy, I spotted as Dave walked into the room, that unlike the other speakers, he wasn’t using the PC/Powerpoint combo either, he had a nice Mac laptop, and was using Keynote for the slides. For the demos he was using my favourite Mac text editor Textmate too. However, in a bit of a poor demonstration, he succeeded in crashing the Mac completely on one occasion, and having it lock up on him on another – quite impressive, but for the wrong reasons. Interestingly he also task swapped using the Mac equivalent of ALT-Tab which I found surprising – I tend to hit F9 and use the slick Expose effect instead.

Putting aside the method of presentation, in terms of content, it was very interesting. I can certainly see where the Ruby on Rails reputation for being magic comes from, but ultimately that comes from working the way the framework expects you to work. Whereas other environments try to be as flexible as possible, Ruby on Rails seems very prescriptive about how it would like you to do things, and I suspect the magic will very soon wear thin if you tried to do things slightly differently. Having said that, I think it’s perfectly possible that somebody could take the same principle and apply it to other languages and environments. It’s very nicely done, and certainly powerful, but most definitely hyped.

Session 3 was a somewhat difficult choice as all four sessions seemed attractive, plus Barry was doing one of the four, and Sarah was doing another. In the end, I went with Dave to hear Sarah talking about blogs and blogging, and Dan, a colleague from work checked out and was impressed by what Barry said. Sarah was another person hit by technical difficulties. At one point she had four different laptops on the desk trying to find one that the Microsoft network would allow to connect to the internet – something that was a key part of the talk. Ironically by the time they managed to get a laptop that could connect, she didn’t use the internet anyway. Impressively through all of that Sarah kept her cool, and delivered a great session, certainly covering the basics of the various collaborative technologies that are around, and more importantly giving real world examples of how her employers are using the technology to get their disparate programming teams on opposite sides of the world to work together.

Following session 3 was lunch, which at an extended ninety minutes, I was worried was going to be pretty boring. Having said that the organisers had arranged a selection of mini talks and discussions to fill the time, ironically none of which I actually listened too! In the end I used the time to mingle a bit, chatting to various people, and in the end finishing up in an interesting discussion with Liam Westley who develops software used by shopping channels like QVC.

For session 4 I’d highlighted two technical sessions to attend, and went to neither, choosing instead Richard Costall and Dave McMahon, shamelessly ripping off Crackerjack, playing Double or Drop with the vast selection of swag that they brought back from TechED in Barcelona. Although they maintained that there was no technical content to the session, that was a slight bit of a fib, as the questions were all based around a series of video interviews they had conducted with key industry figures during TechED. Although it wasn’t the sort of deep technical content that a lot of other sessions contained, it was certainly interesting, and as always with their sessions, great entertainment. Perhaps the only criticism I’d make is that it would have been better if they had made use of the embedding feature in Powerpoint to make the whole presentation a lot more slick by embedding the video interviews into the presentation with the questions. Using the presenter view in Powerpoint they could also have removed the need for the other document they had that listed the prizes, and certainly the need to have a switch box and multiple laptops. Unlike many of the presenters who were swapping back and forth for demonstrations, their presentation was an ideal use for the presenter view, and would have been much the better for it.

Before session number 5, we had a brief talk from the Edward Gibson, Microsoft Security chief and ex-FBI man. I have to say that whilst what he was saying was fairly interesting, and certainly important, the whole ex-FBI routine which involved standing on the top of the arena area outside the building in ray bans (it was decidedly grey and overcast today) and bellowing in our direction probably left most people with a fairly poor impression of the guy and his attitude (which is about as polite as I could phrase it), and ultimately detracted from the message. Certainly for the kind of audience at the day it was pitched in totally the wrong way, and Microsoft really need to do something different for this kind of audience.

By session number 5, my brain had largely switched off. Unfortunately I was in Extensible LINQing presented by Oliver Sturm, which seemed like a very interesting topic – ultimately one I think I’m going to have to check out the notes when they are posted. Sadly this is the second Developer Day on the trot when Oliver has been handed this last slot, and really something like the Costall and McMahon show might have been better at this point.

So was it worthwhile going? Most definitely, and I’ll certainly be keen to get my name down for DDD5. There definitely needs to be a bit of work in making sure things work – one colleague commented that he thinks that Memphis (the conference room at Microsoft rather than the city) was cursed as he’d never seen a session at a Developer day in there that worked! To my mind you’re always going to get some things that don’t work on the day, it’s inevitable with some of the stuff that is being demonstrated, but certainly there are ways to mitigate the risk…

Developer Day 3

Lots of Code on the Screen

I’ve just got back from attending the third Developer Day, held once again at the Microsoft Campus near Reading. Aside from Dave and Sarah, most of the usual suspects were around. Also, after initially being told that there wouldn’t be very many people from SSE coming up, most of my old team from there came along too, alongside a colleague from my current employer. What is interesting is that I had a couple of conversations with people purely on the basis that they’d seen me at previous events, whether that be geek dinners or previous developer days. With regards to the Geek Dinner, Beth and myself decided to drop out of that. We’re currently in the midst of a busy run of weekends, so as numbers were limited for the dinner, and we could do with a Saturday night to ourselves, we took our names off the list.

Anyway, onto the sessions. I went to a bit of a mixed bag, some like Oliver Sturm’s session on ‘Designing a Model Based Application Architecture’ were more useful for current work, whereas others such as Tim Scarfe talking about the Windows Presentation Foundation, or Robert Hogg talking about LINQ were sessions about technologies that are coming in the next few years – which I would say for most established projects won’t get used in anger for a long while, bearing in mind that like many, we have large numbers of customer systems in VB6, products still build in Visual C++ 6, and any .NET is currently in Visual Studio 2003 and framework 1.1.

As usual, there were the usual selection of hiccups with presentations, and problems with equipment. Tim Scarfe especially had a nightmare with the early part of his presentation, with trouble with the screen mirroring functionality on his laptop, followed by a whole series of speed issues with both showing video clips and his actual demonstration. It is interesting to note the variations in how people used their laptops this time, with some trying to run Visual Studio and Powerpoint simultaneously (although I didn’t see anyone using the presenter mode – everybody still just mirrors their laptop screen providing some somewhat stretched layouts on the big screen with the latest widescreen layouts). However Oliver Sturm was using VMWare to keep his presentation separate from his development demonstration, which of course ensures that if the development demo crashes (which it didn’t), it shouldn’t take the slides along too! It was also great to see a number of presenters making use of the code snippet functionality in Visual Studio to show code demonstrations, getting over the frankly tedious moments in previous events where you sit and watch somebody type their code in and debug it live on stage.

Probably the most interesting presentations from my point of view were the future technologies. The language and syntax enhancements brought along as part of LINQ look very interesting and useful, although perhaps the one that made me sit up and be really impressed was the power of the Windows Presentation Foundation. It is worth adding that a number of the ideas that although new on Windows, resonated with ideas in Quartz in MacOS X, however it seems to lift the bar somewhat, and certainly the demo was pretty impressive. Of course I fully expect MacOS X will catch up and overtake again, just as Windows will try and overtake again – such is the computer industry. The other good thing about the demo was that although Tim showed us cool stuff such as flying buttons and pulling pictures off Flickr, equally you could see features that would make a difference to those of us building much more business oriented applications.

All in all it was definitely a worthwhile way to spend a Saturday, and I’m certainly going to be signing up to day number 4 when it is announced.