Apolon's Software Torq

I was listening to IT Conversations again but this time it was the Gilmor Gang. One of the guests was Mary Jo Foley who discussed a story on Microsoft cutting back on what's going into the Longhorn release of Windows. The discussion reminded me a lot of the typical two party political process and the job of the politicians who aren't in power. The political party representatives that aren't in power basically criticize anything the party in power says - regardless of whether it's a good move or not. Because of this, you tend to discount anything the opposition party says. It just seems that criticizing and bringing into question Microsoft's moves is SOP (Standard Operational Procedure) and everything that Google does is the shining light for the future. It's probably a lot to do with a past behaviour being a good indication of future behavior, but we need to remember things can change.

For myself as developer, the announcement is great news. As mentioned in another post, technical information on Longhorn held little meaning for me since it was so far in the future. This was because of a combination of a tentative 2006 release date and the fact it was an all or nothing upgrade scenario. Since people would have to upgrade from Windows XP to get the functionality, it meant developers had to effectively add another 2 years to the actual release date to get an indication of when they would expect any significant demand for Longhorn development services. Now that both Indigo and Avalon functionality is planned to be made available on Windows XP, it means that developers can practically plan to start leveraging the functionality in a 2006 time frame.

The Gilmor Gang discussions appeared to discount Smart Clients as a technology option for the Internet. My opinion is that the Smart Client direction that a lot of the industry is working towards has huge potential. I'd love to see Google make available smart clients for their services e.g. a .NET smart client for GMail. The phrase "one runtime shall rule them all" (or variations of that intent) has been used ridicule both the Java and .NET VM efforts in the past. The software industry does benefit from having one runtime in the Internet age because everything is so global and interconnected. Currently that one run time is the HTML/jscript/NativePlugin based environment of a (predominantly IE) browser. The smart client murmurings from the software industry as a whole is a reaction to the weaknesses of such a html/jscript browser based environment.

Posted by Apolon at 10:28 AM | Permalink | Comments | links to this post

Check out the IT Conversations Memory Lane interview with Dan Bricklin. I love the mention of Dan's mother saying to him:

Dan, did you know that a spreadsheet can add and subtract?

This is an absolute classic anecdote. Dan Bricklin is one of the co-creators of the original spreadsheet Visicalc!

Posted by Apolon at 1:53 PM | Permalink | Comments | links to this post

I hate software that's intrusive or attempts to make decisions for me or "guide" me to a decision favouring the software vendor. Check out this installation screen:

How about:

• No and never bother me with this again!

I actually like the EasyShare software - this screen just peeved me off. I also hate software that installs all sorts of background services and Windows toolbar buttons without asking permission to. To this day, anything from Real Networks is software that's given a wide berth. I heard on an episode of "The Gilmore Gang" that Real have supposed to have toned down their "in your face" software attitude. Still don't believe it. Software vendors need to take into account the long term memory of users before deciding to treat their users without some basic level of respect. Microsoft are still living with the pain left in their customer's memory from years of problems - even when they're doing lots of things "right" in recent years (in my opinion anyway).

Posted by Apolon at 5:06 PM | Permalink | Comments | links to this post

The great benefit of Microsoft's new development direction transparency is that it reduces the probability of real lemons (i.e. products that no one wants) since there is very early feedback. The problem with the long term transparency is that's its really difficult to get excited about the new technology after the initial rush. Take the Still Crazy After All These Bindings article by Chris Sells. Normally I would be really interested in .NET articles on data binding. My background is with process control and SCADA software development (visual representation of the physical world such as a mine or factory on the computer screen). In those technology sectors, data binding concepts have been an implicit aspect of such systems since time immemorial (well at least since the late 80s when I was first exposed to them).

The article relates to data binding in Longhorn. When first seeing it on my blog feeds, I clicked through to check it out. The problem was that it just didn't seem worth the effort to read the details. Longhorn is not going to be released until at least 2006. Even then its going to be 2 or more years before the momentum of a new major Windows release carries through to the general software development marketplace. Hey, it was three years after .NET was released before there was any movement in the software jobs marketplace for .NET developers. Whidbey isn't released yet and there's a whole bunch of functionality that I'm itching to use on real development work. Waiting for the data binding enhancements in Whidbey is frustrating enough, let alone waiting for Longhorn related functionality.

Still... there are people with much more spare time than me and hopefully they'll supply the feedback loop to Microsoft. All in all, the new Microsoft Software development transparency approach is way better than what they used to do. I keep telling my 17 year son that lots of things in life are a feedback loop (picture a father sounding like a broken record ;). For example: controlling the shower temperature, driving a car, doing Year 12 assignments and exams. If you're not getting the results you want, then obtain some feedback information and adjust to suit! The same applies to software development companies.

Posted by Apolon at 8:40 AM | Permalink | Comments | links to this post

There's a whiteboard session with Anders Hejlsberg on the MSDN site entitled "Whiteboard with Anders Hejlsberg". The very first question that Anders addresses relates to AOP and his reaction was interesting. I get the impression that the Microsoft C# heavy-weights get asked about an AOP direction for .NET regularly - well regularly enough that "wait and see" is the canned response. This is just an impression from reading Microsoft blogs and the aforementioned whiteboard session i.e. it may not be related to the reality.

One of Anders responses to the AOP question was that a lot of what AOP does can be achieved by a hosting environment e.g. attributes affecting how code is hosted in an ASP.NET environment. My reaction to this is that it's another deployment dependancy in addition to the .NET runtime itself. I was following Java progress in the late nineties and was a bit disappointed with the direction that Enterprise Java went in. A lot of this was related to my disappointment with the EJB abstractions they chose to go with, but some of it was that high-end vendors got into the picture with EJB containers which resulted in correspondingly high prices for the vendor products. So, though I accept that a hosting environment can be used to solve many of the types of problems AOP assists with, it would be a shame to become beholden to those hosting environments.

This started another train of thought related to an interview with Marc Fleury from JBoss on IT Conversations. During the interview he mentioned the JBoss work with AOP. More information can be found here and also in an article from Linux Magazine. Java annotations (equivalent to .NET attributes) are used to mark which parts of a program an aspect applies to. See this previous post for something similar I'd like to see for .NET.

The approach of using annotations/attributes to mark what aspects to apply to a class/method/property addresses many of the concerns that people have with AOP. It's clearly defined at the local code location, which aspects will be applied. I'd like to see the .NET runtime itself be aware of aspects and to provide a defined mechanism for application code or higher level hosting environments to define the code that gets injected for that aspect.

Posted by Apolon at 3:34 PM | Permalink | Comments | links to this post