Monthly Archives: October 2006

Third Top Australian Consumer Technology Blogger

I picked up this post by Paul Montgomery which lists me as the third top Australian consumer technology blogger (who aren’t journalists). Cool – although I think you can be the top five if only you start getting selective with the search criteria. I’m probably the number one Australian consumer technology blogger with the word “not” and “gartner” in the URL.

P.S. Paul – I tried to use Tinfinger – I reckon you could improve usability by providing a few samples of search terms.

Update: Corrected spelling of Tinfinger (was: Tin Finger).

Movember

Philip Beadle sent around an e-mail internally about Movember which is basically an awareness campaign for mens health. The idea is that us guys spend all of November growing a Mo (Movember – duh!). Part of the process is raising funds to support initiatives that improve mens health. If you want to donate, head on over to the Movember site, enter our teams registration number (6328) along with your credit card details.

Unfortunately I won’t be able to make one of the Gala’s at the end of the month – but I’ll enjoy pretending that I can grow a Mo :)

The Framework Apologist

Paul Stovell reacted to a presentation by Scott Hanselman and Keith Pleas and then Scott Hanselman followed up with his views – or rather an explaination of his position. It is interesting to stand on the sidelines and follow this conversation – especially since there was a lot of traffic on the internal Readify Tech mailing list about it prior to Paul making his original post.

As someone who has had to both design frameworks and consume frameworks developed by other people, I can kind of see both points of view. One of the things that I don’t think has really been brought to the table is the difference between building a framework for every single .NET developer on the planet, and building a framework for just your team (and there is a grey area in the middle there when talking about enterprise frameworks).

Building a framework for every single .NET developer on the planet is hard, you are bound to have someone who disagrees with your approach and you _could_ just mark everything as public virtual (so that you can not only call it, but change it). Some languages work this way.

The drawback of that approach is that you may expose something that is ill thought-out, and then someone comes along and relies on that particular internal implementation detail. You then have two choices – you either break them, or you fork the code. Forking code to support specific customers is really not an option for Microsoft – yet breaking a production system as the result of a patch is not going to make them popular.

The end result is that you need to hide some implementation detail to play it safe and not piss people off, but you need to be as open as possible to allow developers to do what they need to do. I hate to say it, but this is a classic design problem. If we look at the sheer volume of frameworks that Microsoft produce (WPF, WCF, WF, .NET Base Class Library, Visual Studio, Windows Forms, ADO.NET, ASP.NET) – is it any real surprise that they get it wrong some of the time.

I think it is dangerous to assume that we can apply small team framework building philosophies to commercial and foundational programming frameworks. If the ASP.NET team had opened up the session state management API in .NET 1.0 I suspect that they wouldn’t have been able to do as good a job as they did in .NET 2.0. In the end it comes down to a balance between not shipping a perfect open API that isn’t going to bite you back, or shipping a perfect slightly less open API which isn’t going to bite you back.

One thing is for sure, when code bites back, it bites hard.

The Digital Native Platform

I think that this is a post that I have been wanting to write for a long time. It is a post that starts to capture some of the cloud of concepts that I have bouncing around in my head and start to get them down into a form that I can have a meaningful conversation about them (its much easier to explain a concept to someone when it is more than just hand waving).

Two things seemed to have happened over the last couple of months that have enabled me to start bashing this post out. The first is that, through a large number of private discussions, some of the concepts that I am going to present in this post have started to crystalise, but perhaps just as importantly I’ve finally got a name to logically group these concepts under – the Digital Native Platform.

During Tech.Ed 2006 (Australia) I heard of a presentation done by Anne Kirah who is an anthropologist working for Microsoft looking at how their real customers use their technology and then use that knowledge to drive innovation in their future products. One of the observations that Anne makes is that there are two kinds of constituents in the personal computer user community today – they are “digital natives” and “digital immigrants”.

Digital immigrants are those people that did not grow up with pervasive computing technology and who, in many cases are struggling to adapt to the information age (I’m possibly grossly misrepresenting Anne’s work here).

The second group are the digital natives, they are the people who were emersed in technology at a very young age, probably before they could talk, and perhaps even walk. These people thrive on technology, and I only have to look at my beautiful daughter to realise how true this is – I can give her my Tablet PC and she instinctively knows how to drive certain programs – especially the ones with specialised user interfaces which are optimised for the Tablet PC.

According to Anne Kirah, when Bella grows up she is going to demand more from her computing platform that any other computer user ever did, and that in turn will challenge IT departments, hardware manufacturers and software houses. The devices and platforms that she uses will be natural extensions of her self and removing them will be akin to chopping off a hand.

I now believe that some of the ideas that I have had banging around in my head are actually starting to converge into what might be a personal computing platform which is more adapted for digital natives. That is a big call, and there is no way I could spell out my vision for the Digital Native Platform in just one blog post – but lets start the conversation and see where it leads.

Paper and Parts

Years ago the industry was kicking around this concept of the paperless office, this place which would be free of dead tree material and where users would collaborate over documents electronically. It never happened – I’ve always said that if they wanted to get rid of paper all they needed to do was get rid of printers – but no one listened.

Still – there is probably something in the fact that we haven’t been so quick to throw away a rich history of paper production and use. One of the reasons (I believe) is that working with paper and ink is an incredibly empowering experience. From that simple position you can add content, invalidate it with a single stroke and get creative. While I can now type much faster than I can write, one of the drivers for me getting a Tablet PC was that I didn’t want to use paper anymore, but I still wanted that connection.

I’m not sure if your average digital native is going to feel the same connection with paper as I do, but if the pencil drawings that my daughter now gives me is any indication, I think they will.

Because of this, the shell if my Digital Native Platform looks like a stack of sheets of paper, and in the illustration below I have coloured them to highlight this.

Let’s imagine that I’ve started a new “sheet” and I want to use it to demonstrate a few concepts around the Digital Native Platform. Being a bit of a Tablet PC fan I would simply annotate the top of the page with a bit of text which would subsequently be recognised.

 

In this scenario I’ve decided that I want to do some calculations around how much a personal loan would cost me so I head off to my local bank’s web-site. In this case I’ve simply drawn a rectangle on the page and put in some kind of textual identifier for what I want to be displayed in that area. This could be a URL if it was simply enough, but it could also be search results from a search engine – it is essentially an embedded web-browser.

Once the web-site is loaded I navigate to the page that shows me what the current interest rate for a personal loan.

 

The interest rate represents the starting point for performing a calculation around a personal loan, but I need to perform additional computation so I draw up another rectangle and this time use the “calculator” keyword to embed a calculator part.

The calculator doesn’t look very special at the moment, and I guess it could have a default user interface for tapping away at a numeric keyboard, but what if we had the power of Excel embedded into the shell? What if I told it that I wanted to use the PMT(…) function to calculate how much interest I would pay?

As you can see the user interface has now been populated with a number fields that I can input data into. I go ahead and input the principal amount that I am interested in borrowing and specify the number of repayments. For the rate I do something special.

 

In the sequence above I identified some data in the embedded web-browser and drew a line between it and the field in the calculator. Under the covers the shell created a link between the two parts. Obviously I’ve glossed over a lot of technical detail here, but the idea is that web-sites in their meta information would expose a list of data exchange elements. This information is propogated up to the shell to support data binding.

I can repeat this process to “show working” for in any calculations I do. In the picture below I’ve taken the calculated amount of interest and added to the principal and used that result along with the specified number of repayments to determine the size of repayments.

What I have essentially done here is write a simple little program for calculating various aspects of a personal loan. But wouldn’t it be nice to see a graph of the loan being paid off over time? In order to do this I need to made some room for the graph so I select all the parts that are on the screen at the moment and shrink them down and put them in a corner of the page.

I then simply draw my grapher part onto the screen and great links between the relevant elements of the calculators and the graph.

If I wanted to drill down into the calculations again I would need to hover over the bordered area and it would zoom back in. Perhaps a better way to go however would be to promote some of the key data inputs to the same zoome level as the graph – in this case, the principal amount and the total number of repayments. The idea here is that I now have a sheet of “paper” which performs personal loan calculations taking into account the current interest rate being offered by the local bank.

Once we have finished looking at the interest rate calculations we can then look at some of the other bits of paper in our current “folder“. In the next diagram I’ve brough some simple navigation elements into view.

As those buttons are clicked the pieces of paper that are in the current folder are shuffled into view. In the picture below you can see that I have a bit of a TODO list.

If you happen to have a folder with a lot of pieces of paper in it then you need a fast way to navigate so you would be able to spread out the paper and zoom out, then pick the sheet that you were interested in.

 

Back home now. That is a bit of a whistle stop tour of what the shell could look like for a Digital Native Platform. In truth, it probably raises more questions than it answers, but this is a conversation not a specification. Some of the things that I think that I need to cover next is:

  • Tagging and categorisation of sheets of paper.
  • Higher level organisation capabilities (folders of folders).
  • Collaboration and connectivity.
  • Part re-use and software licensing.
  • Backup and replication.
  • Notifications and software agents (or, extending the meat brain).
  • Identity, authentication and authorisation (related to connectivity).

Thoughts?

Connectivity Challenged

I’m connectivity challenged at the moment. We have just moved house and we don’t even have a phone line connected yet, so we definately don’t have ADSL. At the moment I’m blogging from my Windows Vista machine which has a Bluetooth connection to my JasJar which is then uplinked to “the cloud” using GPRS. I can only get 3G on this hill if I hold my tongue in the right direction.

This presents a little bit of a problem since I am supposed to be the guest editor over at TechTalkBlogs and I proposed a little game which is bandwidth hungry.

When you are used to getting around the web at no less than 1.5Mbps its a bit of a step backwards to a GPRS connection. I’m also finding that my ability to work is actually related to the speed with which things come down the line.

At the moment it looks like its going to be close to five to ten working days before we get ADSL connected. Part of the problem is that the phone line is completely dead in this place – no dial tone at all, which means a little Telstra man has to head off to the exchange to connect a wire ($69), then, once that is done we call the ISP back and they tell another little Telstra man to waddle off back to the exchange again and connect that same wire into an available (we hope) ADSL port ($99).

Grrrrr.

I’m doing TechTalkBlogs!

Here is some exciting news, Frank is letting me be the guest editor for TechTalkBlogs. This is so cool, I’ve watched so many people that I respect take up the challenge, actually its going to be a real challenge to do something innovative.

The theme for my editorship will be the Ready Summit. I was actually planning on post a bit of content for the Ready Summit over the course of the next two weeks anyway so I might do some where and some over on TechTalkBlogs depending on what makes most sense at the time.

What if we had Trove for Team Foundation Server?

One of the hard limits that people have identified in Team Foundation Server is one on the number of Team Projects that can be created. This is really a fundamental architectural issue which I hope that Microsoft addresses in a future release. If I was looking at this challenge I would be wondering how I could remove this limitation whilst still adding great new functionality.

An idea that I had was around providing some of categorisation facility so that rather than the project list containing a complete list of projects, it just gave you a search form. I could see this kind of facility becoming a valuable asset within a development organisation because the categorisation (like everything in Team Foundation Server) could be made extensible.

I can imagine a time when your corporate TFS installation has something akin to a software map – ala SourceForge and Trove.

On of my favorite Vista platform features is the Restart Manager.

My last trip to Redmond (a kind of Mecca for Microsoft geeks) saw me at the MVP Summit. One of the benefits of the MVP Summits is that you get to sit and listen to folks like Jim Allchin. Jim was giving a demonstration of a recent build (at the time) of Windows Vista and showing off all the new platform features.

One of the cool features that I didn’t know about back then was the Restart Manager which Daniel Moth does a great job of explaining.

The Restart Manager is a feature that allows Windows to notify you application that a restart needs to occur and that if it can (by listening for a particular message), it should persist user data and close down. The idea is that once the machine is rebooted your application can start back up, re-hydrate its state and pick up from where it left off.