Curiouser and Curiouser! on programming

On the psychology of .NET programming

Tue, 01 Nov 2005 12:05:42 +0000

Here's as good a reason for avoiding .NET (if you can) as I've ever heard:

API Proliferation Twenty years ago, in November 1985, Windows 1.0 debuted with approximately 400 documented function calls.5 Ten years later, Windows 95 had well over a thousand.6 Today we are ready for the official release of the .NET Framework 2.0. Tabulating only MSCORLIB.DLL and those assemblies that begin with word System, we have over 5,000 public classes that include over 45,000 public methods and 15,000 public properties, not counting those methods and properties that are inherited and not overridden. A book that simply listed the names, return values, and arguments of these methods and properties, one per line, would be about a thousand pages long. If you wrote each of those 60,000 properties and methods on a 3-by-5 index card with a little description of what it did, youd have a stack that totaled 40 feet.7 These 60,000 cards, laid out end to end the five inch end, not the three inch end can encircle Central Park (almost), and I hear this will actually be a public art project next summer. Can any one programmer master 60,000 methods and properties? I think not. One solution, of course, is specialization. I myself have specialized. This evening I hope no one will ask me questions about web forms or ASP .NET or SQL Server because those arent my specialty. I do Windows Forms, and my language is C#. [ Charles Petzold - Does Visual Studio.NET rot the mind? ]

And this is only counting the core!! Is .NET 112 times better than Windows 1.0? Well, maybe it is, but I'm not sure it's 45 times better than Windows 95!

Petzolds ruminations on the way Microsoft tools shape the developers philosophy are interesting. As someone who programmed for dos and then Windows 1.0 upwards (i even wrote a few Windows applications in assembly language, now there was a trip!) I can honestly say I preferred the old days. I remember around the time MFC took off realising that the beast had grown too big. The beast never looked back.

These days I program in Ruby (and am learning some Haskell) and I've never been a happier coder. Rails is still pretty grokkable and the core team are doing their best to keep the core, core. Over time everything gets crufty and rots inside out, you just have to hope you can deliver a lot of useful stuff before that happens. It might be too late for .NET already.

Cocoa before bed doesn't always induce sleep

Mon, 23 Jan 2006 09:11:00 +0000

I'm not sure why but, last night before bed, I decided to go through the Cocoa application tutorial with Objective-C. The tutorial is necessarily a little verbose but after about 25 minutes I had a complete working currency converter application. The InterfaceBuilder/XCode combo feels a little bit retro compared to the Visual Studio behemoth but I was left with a feeling that this was no bad thing -- I never really took to Visual Studio.

At some point in the exercise I realised that much of what makes Cocoa code look so alien to me is Objective-C's [receiver aMessage:arg] message passing (method calling) convention and some compiler-neutral sugar for InterfaceBuilders benefit. I quickly got a feel for both and my discomfort began to subside. In the end I was left feeling that writing Cocoa applications might not be so bad and if I had a really good idea I could turn my hand to it.

I've had some initial thoughts about embedding the Ruby interpreter in a Cocoa application to implement an interface to the Ruby debugger. I have a feeling this is some considerable way beyond my current abilities with either Cocoa or Ruby. Andy has also been hassling me about the idea of embedding Squib in a WebKit based front-end. There are a couple of less well formed ideas sloshing around as well.

None of which did my chances of getting to sleep any good.

Brushes with reality

Thu, 30 Mar 2006 22:08:23 +0100

You know I think of myself as a good coder. Not a great coder by any means, but a good coder. So it always comes as such a huge surprise to me how many bugs there are in my code.

But that's not even the worst part. The worst part is when I figure out there is a bug in my code right after I've just said "There's no bug in this code."

The structure and interpretation of computer lessons

Sat, 15 Apr 2006 19:08:03 +0100

I've had Abelson and Sussmans Structure and Interpretation of Computer Programs video course in my bookmarks quite a while and even watched a couple of the lectures. It's always been my intention to go back and watch the whole thing properly.

In conversation with Steve today he was talking about doing a Java course at a local community college in the hope of learning some good programming fundamentals. Without wishing to be disparaging about the state of programming education I suggested that, unless he was especially looking for the classroom experience (which is a valid thing to look for), he might be better off with the online SICP course.

It occurred to me that it might be kind of fun if did the course together. Watcingh the videos and then getting together, online, to chat about it and work through any problems. I think both Steve and I need that collaborative aspect to learning to get the best out of it. Maybe there are other people out there who might enjoy this too?

Our current plan is go through the lectures 'book club' style. We'll watch one of the videos each week. Blog our thoughts and, if we can arrange it, meet online to discuss. We'll looslely co-ordinate through our blogs. Leave a comment either here (or with Steve) if you want to join in.