DDD8a - 23rd October 2010
Yesterday I attended a fantastic DeveloperDeveloperDeveloper Modern .NET Day
in Reading, which did mean getting up at 5am to get the train over to Reading. I was at the DDD8 earlier in the year so I was eager to get it booked a few weeks ago when registration opened, which does beg the question why I am writing a blog post to publicise the events making it harder to register next time?
This was smaller than the main event earlier in the year (which is on 29th January next year) running only two tracks but there are so many fantastic speakers in the community that I always end up torn between sessions and yesterday was no different. I can only talk about the sessions that I attended so here goes...
Session 1: WP7, iPhone, Droid - Oh My! - by Chris Hardy (@chrisntr)
There are a number of mobile operating systems out there at the moment and developing for them can be extremely tricky. However, with work that has been done on the development of MonoTouch
and the up-coming MonoDroid
.NET is becoming a single platform that will allow us to develop cross-platform solutions.
Chris talked us through the basics behind each of the different development environments.
Windows Phone 7 is the environment that allows us to develop in the environment that we are generally most familiar with, Visual Studio 2010. This is extremely familiar to the Silverlight developers as developing for Windows Phone 7 is in Silverlight, we can design the interface within the XAML and Silverlight forces us to separate our user interface from the business logic. There are new controls for the phone, the Panorama
control and the Pivot
control that gives the phone its distinctive look and feel.
The next was MonoTouch using .NET to write onto the iPhone, and yes Apple have relented to allow MonoTouch applications to run on their phones. There is a 20MB limit to the size of applications that can be loaded to the AppStore and because libraries cannot be shared between applications each application needs its own copy of the runtime. MonoTouch does not have the full .NET API but has the libraries that people tend to use the most and this tends to be a super-set of the libraries available to Silverlight developers. You have to develop the user interface in Apple's Interface Builder and then hook your own business logic into the interface. Due to the constraints placed by Apple it is only really possible to develop and debug in Mac OS X as it is tied to the interface builder and the simulator.
A single development licence is $399 which gives you a licence to develop on that platform forever, however, you will need to renew each year in order to get continuing updates of the product.
Finally, MonoDroid is the equivalent of the MonoTouch for Google's Android Phone and is currently is in the preview (not alpha or beta) mode. The interface building tools for Android are less developed than for the other operating systems but again the interface is designed in XML. The Android development SDK is available to all operating systems and currently it MonoDroid is available for development within Visual Studio but eventually a MonoDevelop plugin will be developed. When it is released expect MonoDroid to have the same pricing model as MonoTouch.
The basics that I took from Chris was that, there may be some problems with a few libraries (Chris created a non-JIT version of the JSON parsing assembly) but each of three platforms separates out the interface from the business logic therefore make sure that when you are developing your projects it should be possible to maintain one set of business logic and have just different presentations of that logic.
Session 2: Packaging in the .NET World - by Sebastian Lambla (@serialseb)
Over the past few years the .NET community has been catching up with other areas of the software development world and has started producing its own open source software. Traditionally we either relied on Microsoft to develop everything that we needed or that other third parties would provide frameworks that you would buy in with guaranteed support.
With open source software we are building dependencies into our software on the open source frameworks that we use but these frameworks are constantly changing, constantly evolving and often have complicated dependencies. As Seb pointed out people often download a particular version of a framework and then stick to it regardless of whether a newer, better, version is available, why? They are afraid of breaking changes.
Seb took us though the history of the package management solutions that have been available within the open source world for a long time (e.g. apt-get
) through to the latest offerings from himself (Open Wrap
) and Microsoft (NuPack
The most recent history between Microsoft and Seb has been an interesting view from the outside. It was known that Seb was busy building a package manager but Microsoft were busy developing something of their own in secret and only when they had completed it did they announce it to the community.
However, OpenWrap was the primary focus of the talk showing how easy it was for us to create and manage our dependencies. One advantage the NuPack has over OpenWrap at the moment is the integration with the Visual Studio - Seb will argue with me on this point but in order to get through to the standard developer eventually the integration will be required. From the command line I think that we have more power than we would through the Visual Studio interaction and OpenWrap has a distinct advantage over NuPack, it supports the NuPack format.
No longer do you need to download an assembly and do "Add Service Reference" as OpenWrap hooks itself into the build process and automatically references the appropriate packages. It also has a plugin for Resharper that allows Resharper to detect the files even though they are not referenced by the project.
I think that OpenWrap is a very powerful and useful package manager and I am seriously looking forward to working with it.
Session 3: Is NoSQL the Future of Data Storage? - by Gary Short (@garyshort)
Gary was talking about the NoSQL is a movement that has risen over the last few years and is centred around the concept that Relational Databases are not tuned to being easily scalable, or even tuned to the demands of modern scalable systems. Twitter, Facebook and even Google have shunned standard relational databases in favour of other database models that are more tuned to their own needs. Gary started out by explaining that "NoSQL" really did mean "Not Only SQL" as there is never one absolute solution to any problem and relational databases do have their place in the world.
NoSQL databases come in varying shapes and sizes, object databases, graph databases and even document databases.
Gary talked us through why the traditional relational database came into being, normalised data saves space! One of the other concerns was that the data should be in the same place (on the same tape) which means that it could be read efficiently. In the 60s, 70s and 80s the space that was needed to store data was in a premium and therefore having a normalised database means that most data is stored in one place and one place only. However, there is a cost with a normalised database, every query that performs a join has to read data from several tables and combine them into a single results set.
Non-relational databases such as RavenDB work on a completely different model. RavenDB is a document database, which means it stores all the information relating to a document in a single place. This means that we have extremely fast writes (as the transaction is to write to that single place) and also we have extremely fast reads of the data because we have all the data that we require and the server is fairly dumb. For RavenDB we create our indexes in .NET using Linq and effectively create "materialised view" of the required records and can even render different object models using those views, these indexes are "eventually consistent" as when a change is written a background process on the server re-builds the indexes but that could take time. The only problem is the ad-hoc queries you can perform on SQL. The documents are denormalised and you are potentially storing more data but in these days do we care about that? It is so easy to shard the data using RavenDB that if we are stressing a single server whereas in a relational database model sharding the data is not that easy (and yes it is possible).
I think the simple conclusion is that we have to use relational databases for things that need to be consistent, transactional etc but in other cases where we need fast reads/writes, scalable then it is worth checking out the various types of Non-SQL databases out there.
Lunchtime Grok Talks
As always there were some lunchtime Grok talks where people come forward to give a short presentation during lunch to the people attending the conference.
We had Guy Smith-Ferrier (@GuySmithFerrier
) giving a 20/20 talk, which is 20 slides at 20s per slide, on why twitter is so great or rather "Why using twitter will get you more sex" or something like that. It was a very interesting and cool talk but for me there was one reason - so much is now being communicated using twitter.
There was a talk about using F# as a BDD framework with the tickSpec
framework. It is an interesting concept and deserves a further look into.
Finally we had Ross Scott talking about the costs involved with running on the Azure framework. One interesting point that was raised within this talk is that you really need to run two instances of your roles, primarily the web roles, as Microsoft can bring your role down to patch the virtual machine, or move the machine over to another part of the cloud where it is less busy.
Session 4: Modern C#: This is not your grand-daddy's language by Jon Skeet (@jonskeet)
Jon turned up to show us how C# has evolved over the years and to force us to think about what we want from our languages and where we could go in the future. Far more importantly he was joined by his trust companion Tony the Pony
who, according to Jon, isn't a very good developer...
There was a time warp back to the days when C# was new, when C# didn't have generics, or lambda expressions or linq. Back in those days did we think it was a horrible language to work within? Not really, as Jon pointed out C# is a good language and back in the day it was a nice easy language with a massively powerful framework behind it. Development was actually quite easy.
Along came generics... then came Linq and lambda expressions... did they made the language harder? No, they made it easier. It has become much easier to express intent with C# rather than focussing the implementation. Languages are evolving to focus more on what we are trying to do rather than how to do it and that is not a bad thing. Jon described this in terms of driving, the driver doesn't actually care about the mechanism that turns the wheels, they only care about their interaction with the steering wheel.
The things that I will take away from this talk are to learn other languages and understand why they are different and what the advantages and disadvantages of each language is but also to read things that I know that I disagree with and understand why I disagree with it because in doing so I am learning more about my programming language, what I want from my programming languages and myself.
Session 5: WPF in Modern .NET - Ian Griffiths
Ian spent a lot of time focussing on the controversy that has surrounded WPF in recent months. It has been suggested that WPF was dead but there is a massive effort going into WPF at the moment and as Silverlight is a sub-set of WPF (though implemented in a different way) and the new Windows Phone 7 makes use of Silverlight it is likely that WPF is going to be around for a while.
There was a discussion of the Model View ViewModel pattern and how this can benefit Silverlight.
By this point I think that my mind had actually started to fade at this point and I can't remember too much about this talk (sorry Ian).
So at the end of the day we drifted back into central Reading and went to Revolution bar for a few drinks and more chat. There was a good buzz about the people there and they all seemed to have had a good day. We headed off to Pizza express and continued the discussions there including talking about how the DeveloperDeveloperDeveloper organisers are all eager to encourage new speakers and new people. I think that for January I want to actually present a grok talk and maybe the time after that I'll have the confidence to sit up and submit an entire session and I would encourage anyone reading this to think about giving a presentation.
Thanks very much to Phil and the organisers of the event and thanks to the speakers for giving us some very interesting talks.