doomkeeper

12 Responses to “The mighty C# migration misconception”

1. 
   OJ Says:
   February 28th, 2009 at 7:38 pm

   This is your best post to date Jimbo!

   This kind of over-confidence (arrogance?) is rife in our industry. Your post discusses the most common example. Let’s be honest though, it’s exactly the same as those people who know C that claim to know C++. So history is basicaly repeating itself.

   There is one huge difference between that example and the one you discuss, and that is the .NET framework itself. Writing good code in C# isn’t just about knowing the language (which is very different to C and C++ in many ways), it’s about knowing the .NET framework and leveraging (sorry about the buzzword) it where appropriate.

   I’ve lost count of the amount of times I’ve seen and heard of people who read a C# book and write “Expert in C#” on their CV. They then go ahead and write their expert implementations of Path.Combine or File.Exists becuase they don’t even realise that those functions have already been written and are part of the framework.

   Sorry, C++ dudes, delegates are not just function pointers. Generics are not the same as templates. Your current knowledge simply doesn’t cut it. Learn the language. Learn the framework. Learn to write code the right way for that language and framework. Don’t assume that because you know C++ that you can automagically cut mean code in any other environment. That kind of arrogance will not only bite you in the bum, but it’ll piss off every one of your workmates who is making the effort to do things properly.

   As a final point, I have noticed that those people who are starting to stagnate are the worst for this kind of attitude. Unfortunately in games, you have the added “benefit” of people thinking they’re already the best and ahead of the game because they’re using a lower-level language.

   Good going Jimbo. Embrace the new tech in the way it should be embraced. You’ll not regret it

2. 
   Jimmy Says:
   March 2nd, 2009 at 12:54 pm

   @OJ: Glad you approve mate.

   I’m happy you brought up the C to C++ transition as a comparison and you are absolutely right. History repeating itself indeed. I remember being told not to use Constructors in C++ because they were considered an ‘exotic feature of the language’.

   I agree completely about the .NET framework as well. I too have seen countless instances of such ‘experts’ reimplementing System.IO.Path, over and over again. Loads of hard coded path delimiters all over the place. Maybe this is becoming an Anti-Pattern itself?

3. 
   Jon Says:
   March 6th, 2009 at 10:01 am

   Yeah, the basic problem here is that people assume that “learning a language” means knowing enough of the syntax that you can get something to compile or run without too many egregious errors, which is nonsense. Syntax is basically unimportant – it’s a set of simple (*cough*, C++, *cough*) rules which govern how you express what you want to say in that language. You can pick up the basic syntax of most languages in less than a day (less than an hour if it’s Scheme).

   The thing that really matters is getting familiar with the standard libraries, and the design philosophies behind why things are done the way they are. This takes a lot longer, as unlike learning syntax (a small set of generally applicable rules), you basically have to memorize a large number of specific instances – most languages do have sensibly designed standard libraries with a set of conventions to help you make an educated guess at what the parameters are for an unfamiliar function (PHP, quite notably, doesn’t). The key is learning how to navigate the library documentation to find what you’re looking for.

   If you don’t take the time to learn the libraries, you’re pretty much doomed to waste time hand rolling buggy non-standard implementations of functionality which already exists. As a concrete example, I was writing some Ruby last night, and needed to trim the whitespace off some strings, which is fairly trivial – I could probably have spent 5 or 10 minutes knocking up (and testing) some code to do so. But a couple of minutes of perusing the String class documentation shows that it has “strip”, “lstrip” and “rstrip” methods which do exactly what I want, are presumably well-tested, and at no effort on my part.

   I’d also make a second point, specifically about the fashionability of C#, which, as far as I can tell, seems to be slowly reinventing Smalltalk in a rather ad-hoc, back-of-an-envelope manner. Which is kind of annoying, as pretty much everything you can do in C# today, you could have done in Smalltalk in, ooh, let’s say, 1995, but with the benefit of a much more regular syntax, what with Smalltalk having been designed around a very simple language core, pushing as much functionality as possible into the standard library, rather than the lets-take-a-shopping-list-of-buzzword-features-and-hack-them-brutally-into-the-core-language-syntax approach which C# is taking. But then again, Smalltalk was developed in the 70′s, and so will forever be regarded as “slow” (in comparison to assembly language, one assumes), and is now regarded as dead rather than “ahead of its time and Alan Kay is a fricking genius who should be up there with John McCarthy, Guy Steele and Dennis Ritchie as a veritable god amongst men when it comes to language design.” (Yeah, that last sentence didn’t really scan but at this point, I’ve degenerated into a rant so I don’t really care…)

   Then again, very few people actually bother to study the field of programming language design in any depth, as far as I can tell, so I suppose people will put up with shit like Visual Basic, C# and PHP because they simply aren’t aware of the alternatives.

4. 
   Jon Says:
   March 6th, 2009 at 10:05 am

   Damn, I got so excited that I forgot to mention that the concept of MVC was actually developed by the Smalltalk guys too.

5. 
   OJ Says:
   March 7th, 2009 at 1:17 am

   You’re a smart guy Jon, but sometimes you shit me when you go on those tirades You sound like a blind fanboy. Instead of saying “thank god for a mainstream language that is trying to do what Smalltalk did” you say “you’re doing a shit job of copying something that was done ages ago”.

   I grow tired of the “we had it first” / “we’ve had it for ages” arguments which are thrown out when someone (usually MS) implements something for the first time. So what if you’ve had it before, be grateful that it’s there now in a language that lots of people use.

   Who gives a fuck if MVC was developed by the Smalltalk guys? All that matters is that the idea was developed and people are finally starting to use it in the right way. You airy-fairy comments implpying C# is a wannabe Smalltalk which is implemented in a “back-of-an-envelope” manner are total bullshit. The likes of Anders and Erik have been around creating and designing amazing languages since before you were sucking on your mum’s tits. Get off your high horse and stop preaching.

   What I’m about to say is going to sound rather hypocritical after my little rant, but get back on the point of the post instead of abusing an opportunity to have a stab at a language which you were always going to hate because MS came up with it. You sound more and more like a linux/non-MS fanbooy every day!

   Andthangyouvermuchaaaa
   Lots of love.
   OJ

6. 
   Jon Says:
   March 9th, 2009 at 2:07 am

   Oh come on OJ, I’m sorry that I forgot to add Simon Peyton Jones to my list of “veritable gods” (I missed Chuck Moore out as well, as it goes), but you can do better than this…

   > You sound like a blind fanboy.

   Lets leave aside the fact that this literally means “you sound like someone who’s in favour of a particular point of view!” (well, duh…) But I strongly suspect that had I written a post in which I’d made baseless attacks against Smalltalk in favour of C#, I doubt you’d have raised being a “blind fanboy” as an issue (seeing as “fanboys” only ever hold views which oppose our own – those people who agree with us never do so out of blind fanaticism), so I was going to pass over this. But then I thought, hang on – this is exactly the kind of rhetorical device which charlatans and bigots have been using since the dawn of time as a means of trying to stifle opposing viewpoints by trying to cast doubt on the source of the statement, rather than addressing the statement itself. Trying to advance a discussion between opposing viewpoints requires effort from both parties, and it’s insulting to both if one resorts to slander because they can’t be bothered to refute the other’s argument for its own merits.

   > Instead of saying “thank god for a mainstream language that is trying to do what Smalltalk did” you say “you’re doing a shit job of copying something that was done ages ago”.

   This is a false dilemma (another common logical error), as those two positions *aren’t* contradictory, and I can thus hold both (or neither) should I so choose. Let me tell you a story, which I just made up, and takes a number of factual liberties for dramatic effect. Its 450AD in Thrace, and the Roman empire has just fallen, ushering in the beginning of the dark ages, and let’s also say that due to the fall of Rome, all the local wheel makers (who were Romans) have returned to Rome, leaving no local expertise on the construction of chariot wheels (the Romans had been constructing circular wheels out of iron). Faced with the impending shortage of chariots, due to wheels falling into disrepair, Zypyra (as good a Thracian name as any for our purposes) a local merchant sets up in the wheel business, but due to a lack of experience and poor supply of materials, the wheels he starts to make are made of wood, and well, kind of oval. And where do I fit in to all this? Well, instead of saying “thank god that Zypyra is trying to do what the Romans did”, I’m saying “Zypyra is doing a shit job of copying something the Romans got right ages ago”. Now, you might take issue with the tone, but I can still be right – the fact that Zypyra’s wheels are inferior to the Roman ones doesn’t invalidate the fact that he’s trying. Nor does it imply that Zypyra, simply because he’s now the only wheel maker in Thrace, should now be held up as a master in wheel construction.

   > Who gives a fuck if MVC was developed by the Smalltalk guys?

   Historians? Someone compiling a (distressingly lame) pub quiz? I don’t know. And other than for dramatic effect, I’m not really sure why you seem to be implying that not knowing the origins of MVC (or indeed any widely lauded technology or practice) would be in any way a desirable thing. Never take pride in ignorance – it’s a deplorable habit.

   I actually thought it might be a germane piece of information to share in a comment on an article *which itself advances MVC as a good practice*. I thought someone reading my comment might be interested to see if any other good ideas came out of Smalltalk. I realize that learning about Smalltalk is probably not going to do much good when it comes to your next interview for flashy-web-2.0-development-house, or any corporate-cookie-cutter-code emporium, but hell, maybe not everyone wants to work in those kind of environments anyway. Whatever happened to the ideal of the pursuit of knowledge for its own sake?

   > You airy-fairy comments implpying C# is a wannabe Smalltalk which is implemented in a “back-of-an-envelope” manner are total bullshit.

   You’re completely right. I have no business implying that “Anders and Erik” (whoever they may be – see later) used the obverses of postal stationery as a means of implementation. (It is telling, however, that I don’t see you defending C++, PHP or Visual Basic with quite such vigour). This was a lazy attempt on my part to favour rhetoric over logic in advancing a position, and in the interests of fairness, I should hold myself to the same standards I expect of others. I do believe that C# derives a great deal from Smalltalk (whether people are willing to admit it or not), is borrowing more and more with each new version (ie every additional feature which isn’t retarded), and I’m happy to present supporting evidence of my position.

   Java became publicly available in 1995, C# in 2000. For the purposes of charity, I’ll leave unexplored the assertion that Microsoft’s interest in C# was to try to steal some of Sun’s thunder, and to make sure that they had a Java-like language which was under their total control. I will point out that it’s a matter of historical record that Sun took Microsoft to court around 1997 for making changes to their implementation of Java which were incompatible with the standard. It is also no secret (to anyone capable of research) that several Smalltalk programmers were involved in the initial design and implementation of the Java virtual machine. (See http://c2.com/cgi/wiki?JavaHistory for more details – Sun have removed any references to this from the “offical” history of the language. I guess it would be slightly embarrassing for them to admit that they didn’t actually invent the Java VM at this stage. It’s also interesting to note that at some of those same Smalltalk programmers explicitly disavow having anything to do with the design of the Java language.) Java and C# do have a large number of similarities in their core syntax, which I refuse to believe is entirely coincidental, and if I was feeling uncharitable, I might say has something to do with the veritable plethora of new syntactical forms which C# has acquired in it’s later versions.

   Furthermore, as I understand it, C# is already on it’s third major revision to the core language, with version 4.0 under current development. This is impressive for a language which has only been in existence for around 10 years. Lisp, which was originally designed in around 1950, is still pretty much recognizable as the same language – the syntax of the language has remained pretty much unchanged for almost 50 years now (there does seem to have been some design flux in the early years, but seeing as these guys were literally inventing the idea of high-level programming, I’m willing to cut them some slack). I think I am entitled to inquire into the reasons behind this, and draw conclusions about it, and I make no apologies if those conclusions don’t always agree with mainstream opinion. Let’s assume that they’re not just adding every damn kitchen sink feature they can think of in order to keep the Microsoft staff who write C# documentation and tutorials gainfully employed.

   In the interests of having some time left this weekend to do something other than compose this post, I’m going to limit myself to looking at differences between versions 1.0 and 2.0.

   The “partial” keyword doesn’t seem to offer anything useful to the language – I can’t see any reason not to make all classes partial by default. I don’t even see how backward compatibility would be a concern – the only effect I can see that having would be to make previously broken code (that with duplicate class definitions) compile. In matter of fact, why wait until version 2.0 of the language to introduce this anyway? I can only assume that it’s because that’s how class definitions worked in Java at the time. If it was the case that “Anders and Erik” had intended class definitions to be partial, but had to wait until the 2.0 release, then surely, that’s an indictment of corporate language development in general – allowing short-term business concerns to compromise the language design. If “Anders and Erik” hadn’t intended to allow partial classes, then I would suggest that they hadn’t thought about the matter hard enough.

   Anonymous delegates (which Lisp and Smalltalk both have), should have been in the language from the very start. The fact that they’re in the 2.0 release is an admission of that. I’m not sure what they were smoking when the decision to omit them from 1.0 was made, but I’d sure like to get my hands on some – it sounds like some quality stuff! And why were generics not considered suitable for 1.0 either? Is it a complete stretch of the imagination to consider that C# 1.0 didn’t have generics because Java didn’t, and 2.0 did, because Java did. As it goes, C# may have a better implementation of generics than Java, as Java generics appear to be a completely runtime construct. I guess at this point, they’d stopped copying Java word-for-word, and felt free to come up with their own solutions.

   Nullable types (which introduce a new variable declaration syntax along with the rather aptly named ?? operator) appeared on first glance to be a workaround the kinds of problems you’ll eventually run into trying to design an object orientated runtime with a static type system. But, apparently they were added for “improved interaction with SQL databases” if Wikipedia is to be believed (stop laughing at the back!) But hang on – why do they need their own special syntax? Didn’t we just introduce generics into the language in this very release? Is there anything offered by T? that couldn’t be offered by a hypothetical Nullable in the library? Seeing as pretty much every C# programmer I’ve talked to says that they’re using some kind of extension such as Visual Assist to help them handle the burdensome verbosity of the language, I don’t really buy a sudden desire for terseness at this point. (And again, if terseness is a desirable language feature, why wait until version 2 of the language before attempting to address it?) So now, we’re changing the core syntax of the language to suit a particular kind of database? I’ve studied a lot of languages, and this is a new one on me (did I at any point mention there might be tensions between business interests and language design?)

   Now that I’m done with 2.0, lets look at a few deficiencies of C# in general which haven’t been addressed in any version. And probably never will be, because they can’t be fixed without breaking existing code – which is one of the most compelling reasons for making *damn sure* you’re happy with your language design before inflicting it on an unsuspecting public – even adding new keywords runs the risk of breaking existing code – look at the lengths the C99 standard goes to in introducing “bool” as a native type.

   The “abstract” keyword is just unnecessary, I assume it was borrowed from Java by mistake. I had a problem with “virtual” when it was in C++ (C++ is chock full of similar examples of shifting complexity away from the compiler implementor onto the poor guy who actually has to develop in the language.) It’s been proven (by the Self programming language, amongst others) that you can get a compiler to replace a virtual dispatch by a direct call to the correct function in appropriate cases, implying no performance overhead. This knowledge was available in papers which date from around 1995, which possibly excuses Java, but the C# developers had a good 5 years in which to learn about this. Self is an object oriented language and the fastest compiler emits code which runs approximately half the speed of equivalent code written in C and uses all manner of interesting tricks to get that performance. So – did they not read the papers? I would have assumed anyone with an interest in language design would find this kind of thing fascinating (I certainly do). And if they did read the papers, did they simply not value users of the language enough to go the extra mile in the compiler design? Were they forced to cut it due to release dates?

   Classes versus structs. Again – figuring out whether a type fits best on the stack or in the heap is the *compiler’s* job, not the programmer’s. For crying out loud – you have a JIT compiler – profile the damn code while it’s running, and use whichever variant turns out to be fastest. That particular insight took me literally minutes to think up, but seems to have escaped the entire C# development team. I’m starting to think that “Anders and Erik”‘s expertise may lie in implementation of existing languages.

   I was going to bring up the absence of symbols as a primitive type, but this has apparently been addressed in the 3.0 release. It probably won’t surprise anyone that symbols one of the fundamental data types in Lisp, and are used extensively in Smalltalk (for passing the name of a method to another method so that it can be applied to an object within the method, as one example, which is a nice mechanism for allowing you to data-drive code and has the added bonus of *not having to use XML*). It would seem that prior versions of C# were using strings for this purpose, an implementation technique which C# shares with Perl. (Much as Perl has its uses, mainly as a way of intimidating people trying to learn Perl, I’m going to go out on a limb and suggest that if Perl implements *anything* in a particular way, there’s a strong argument for looking for a better alternative.) And again, why wait until version 3.0? Did the requirements of the language really change that much that symbols didn’t make sense in the initial release, but they do in version 3? An unsympathetic interpretation might be that they just found out about Ruby, so they felt compelled to make sure that there was one less box left unticked in a comparison between the two languages. Those language comparison charts go down well with the Pointy-Haired Bosses at consultations, so I’m told.

   > The likes of Anders and Erik have been around creating and designing amazing languages since before you were sucking on your mum’s tits. Get off your high horse and stop preaching.

   As delightful as this sounds for “Anders and Erik”, it’s very difficult to take this claim seriously without anything being offered to verify their supposed achievements in the field of language design. In fact, seeing as you didn’t even bother to post their surnames, it puts the burden on me to establish who, in fact “Anders and Erik” actually are. (After 5 minutes of consultation with Google, I would have to assume we mean Anders Hejlsberg and EriC Lippert). And if we *are* talking about Anders Hejlsberg, then unless any of his “amazing” contributions to language design occurred before he was 18 then it is highly unlikely that I was still being suckled at the time. (It does sound like he’s no slouch when it comes to implementing compilers, but compiler implementation *is not* language design. That’s why they have different names.) Please don’t be offended if I discard this assertion as unsupported by evidence – it also sounds suspiciously like an appeal to authority to me: “Who’s this Einstein guy anyway? Some patent clerk? And he’s saying that Isaac didn’t understand gravitation?” People holding attitudes like this were largely responsible for Galileo being held under house arrest for the last 10 years of his life.

   When I’m saying that one programming language is more powerful than another, I am generally talking in what might appear to be quite a narrow sense: the more powerful the language, the more core functionality is provided in the libraries, rather than requiring dedicated syntax in the language itself. For just one example of why – here’s an article seemingly plucked at random from the ether: http://www.scs.stanford.edu/~dm/home/papers/c++-new.html (The author argues that C++’s new and delete operators suffer from a number of limitations which don’t apply to C’s malloc() and free() library functions, and can therefore be seen as a step *backwards* – seeing as I just made the point about moving functionality out of language syntax and into libraries, I’ll refrain from making it again.)

   Maybe C# actually *is* better that Smalltalk or Scheme given the corporate environments which is was presumably designed to be employed in. The user-extensibility of languages Smalltalk, Lisp and Forth makes it very easy for people to redefine key language features – such as the “if” statement, for example. (Yes, I know, who would ever want to do that? All I’m going to say is that I’ve been *amazed* at the things I’ve wanted to redefine when it’s 2 in the morning, and I’m trying to track down some rare bug.) If you have a large team of, let’s say, moderately talented programmers who are being payed to turn up 9-5 and “write code”, who can (and often do) walk away from the project should something more attractive come along, maybe it’s best if they *don’t* have the power to build their own domain-specific mini-languages to solve whatever problem it is they’re trying to solve – maintenance of corporate codebases is a time-consuming and difficult business as it is, without making it harder. More crudely, maybe these writing-code-for-the-money schmucks can do enough damage already, without replacing their hand grenades with nuclear weapons.

   > get back on the point of the post instead of abusing an opportunity to have a stab at a language which you were always going to hate because MS came up with it.

   Again with the ad hominem – if you can’t actually refute the argument by presenting opposing data, or pointing out flaws in the logic, let’s just impugn the motives of those who would disagree with us. If you actually want to have a discussion about the technical merits of C# against other languages, or even the wider points about why some languages succeed in situations where others fail (here’s a hint – the technical superiority of any particular language often has very little to do with its popularity in a corporate setting), then do some research and present some evidence. So, less of the conversational terrorism (http://www.vandruff.com/art_converse.html). I think I’ve been more than patient in response, and if you can’t be bothered to frame this discussion in something approximating an exploration of dissenting points of view, I don’t see why I should bother either.

   > You sound more and more like a linux/non-MS fanbooy every day!

   I didn’t actually mention Linux anywhere in my post, but I guess this sentence needed *something* to distract from the fact that you’ve run out of things to say, and begun to recycle points which you’ve already made.

   Am I to suppose that the argument you’ve laid out here is the very pinnacle of unbiased objective reflection? On the strength of your post, it is clear that you have meditated on these matters in great depth and expunged every last vestige of “fanbooyism” from your argument, which demonstrates such meticulous research, and is presented in such a calm and well mannered way. You had an opportunity here to present a defence of C# based on its own merits, but instead you chose to waste that opportunity by presenting a flawed, negative and downright lazy analysis in an attempt to stifle further discussion. Ask yourself this: is your comment likely to make me change my mind about C#? Does it offer anything which might persuade *anyone* to take a further interest in C#? If anything, all you’ve really done is cast doubt on whether your gushing approval for Jimmy’s article was for the quality of the writing and the arguments it proposed, or whether you’re so fond of it because it happens to support your prejudices. If the only way I can earn your respect is to agree with you, then please excuse me if I decide that your respect isn’t worth earning.

   And I suppose, given my rabid, slathering and fanatical hatred of Microsoft, I do die a little inside when I turn on either the Xbox or Xbox 360 in my lounge. Yes, when I’m at work, I do find it frustrating when I have to wait for minutes on end for Outlook to complete some seemly innocuous task such as redrawing a window so that I can access my mail (which, seeing as mail is basically text anyway, could be stored in some kind of publicly available text format so I can grep it for the email I’m trying to find while I wait for Outlook to come back to life…), but I get frustrated by lots of small things. The real frustration arises from not being able to do anything about it, due to stupid political reasons, rather than any inherent technical limitation of my own. Outlook 2007 is noticeably slower than the previous version too, but hey, at least it has a shiny new GUI (which looks suspiciously like OSX), so it must be better, right? Because new stuff is *always* better than old stuff. One of the problems Microsoft face when trying to persuade people to upgrade to (ie “buy”) a new version of a program like Outlook or Word is that after 15 years of development, they’ve pretty much already added every feature that anyone could conceivably want to use (and a few, such as the infamous “help” paperclip, which people actually hated), and now the only game they’ve got left is giving the damn things a facelift (which, fortunately for them, works because the people who have the final say about IT policy in most companies rarely have much if any technical experience anyway, and are probably impressed by shiny new GUI’s). I should point out I’ve never said there’s anything particularly wrong with some Microsoft technologies which I’ve used over the years. I have no real problems with most of the Win32 API, or the bits of DirectX or the XDK that I’ve had experience with. MFC, on the other hand, is a fucking embarrassment.

   I know that the idea of evaluating technologies on their own (measurable and verifiable) merits rather than because of who created it, or because it’s new, is starting to sound old-fashioned. And I know that putting people into ideological boxes, and then persecuting them for being in that box has been a pastime of bullies since, ooh, the dawn of recorded history, but do I *really* have to choose to be either pro-Microsoft or anti-Microsoft? (http://en.wikipedia.org/wiki/You%27re_either_with_us,_or_against_us) Try taking your statement, and replacing “fanbooy” with “homosexual” or “Jew” – the sentiment remains the same.

   Maybe it’s not even a Microsoft thing – if you’re trying to make me make a choice between supporting the open source movement, or throwing my lot in with whichever big software company happens to suit my short-term interests right now, I think I’d have to choose open source. I think open source is *far* more beneficial to the human race as a whole than proprietary software and all the attendant secrecy (and other political bullshit) which goes with it. The software which runs in our schools and hospitals – to say nothing of the software which counts votes in elections, or that controls the firing of nuclear weapons – *should* be open source. Any interested member of the public should be able to take a look at the code – to check for bugs if nothing else. Yes, you’d be an idiot to think that Microsoft (or any publicly owned company, for that matter) is inherently evil, and every action they take is to the detriment of humanity at large (while, presumably, Steve Ballmer laughs maniacally and strokes a white cat as the popular depiction of supervillains dictates that he should (although based on http://www.youtube.com/watch?v=wvsboPUjrGc, maybe that’s not so far-fetched)), but the polar opposite viewpoint – that anything undertaken by a corporation is intrinsically for the benefit of the species – is equally flimsy and naïve. Any degree of scrutiny and casual reflection on the matter should reveal that despite the fact that public companies basically exist to maximize short-term return on their shareholder’s investment (by increasing their share price by whatever means necessary), no logical contradiction arises if said company then carries out acts which *are* beneficial to the public good. And while I’m on the subject, it should be noted that Bill Gates managed to acquire a vast amount of personal wealth – equivalent to the entire GDP of a small African nation, before he started to take a public interest in the welfare of others – it’s not such a huge leap to imagine that the company he founded should share his ideals.

   Seeing as you’re determined to make this into some kind of dreary my-OS-is-better-that-your-OS slanging match, here’s a little home project for you: try and come up with estimates of truck numbers for Linux versus Windows (or even Ubuntu vs Vista, as a slightly more concrete comparison, if you’re willing to ignore *every single other Linux distribution currently under active development*). If you don’t know what a truck number is, have a look at http://everything2.com/index.pl?node_id=1543370. This is exactly what virus writers want – it’s *much* easier to exploit bugs in closed, proprietary systems than open ones, and to far greater effect. If an open system is affected by a virus, anyone with sufficient motivation can download the source and start suggesting and implementing solutions – with a closed source system, that individual is pretty much to waiting resigned for the company which “owns” the source code to publicly admit that the problem actually exists, and then, if that actually happens, waiting some more for a release of the fix (and *then*, possibly waiting for fix which actually works). And the same thing is also true for features. If you don’t like how something’s done in Linux, there’s nothing to stop you from switching distributions, or even starting your own fork of an existing one. Prefer Windows XP over Vista (in common with most of the general public) – well, aren’t you shit out of luck when XP stops being supported?

   Damn, now I’ve spent several hours responding to a diatribe which looks like it spent minutes to compose. It’s a shame that trying to genuinely engage with other people’s differences in opinion is so much harder than this kind of lazy kneejerk response which seems to constitute 90% of what passes for “argument” on the internet nowadays. There’s something sadly ironic about it – for the first time in the history of the human race, any human being with access to a computer can record their thoughts for eternity, and the best we can come up with is: “You suck!” “No – you suck more!” Stupid warlike species – if we do end up wiping ourselves out in some entirely preventable nuclear conflict, we’ll have only ourselves to blame (except that we’ll all be dead, and thus unable to blame anyone for anything).

7. 
   OJ Says:
   March 9th, 2009 at 1:02 pm

   Wow Poke a nerve and you do get a response.

   Jimbo’s blog, which covers a totally different topic to the rant that you’ve kicked off, isn’t the place for this discussion. You’ll find my response in your inbox! … hrm… Or on my blog. I’ll let you know.

   Jim, sorry for turning the comment thread into a geek bitching session. It wasn’t my intention.

8. 
   Jon Says:
   March 13th, 2009 at 10:42 pm

   I’m sure it’s all good – the underlying point of my epic rant was that I wanted to make clear that my opinions aren’t capricious and arbitrary, but there is some degree of thought behind them. I’ll also concede that if I were in a position where I had to choose between writing C# and going hungry, I will code for food.

9. 
   OJ Says:
   March 15th, 2009 at 1:46 am

   It’s good to see you passionate about something mate Now please, send me your email addy, I do have a few things to say about what you said above, but we’ll take ‘em offline.

   Cheers!

10. 
    Keef Says:
    March 26th, 2009 at 10:00 am

    Jon, love the comments.

    It’s not just programming languages that suffer from (possibly) misguided fashions in the geek world. We have hardware companies like NVidia and ATI pushing MSAA as the best solution to reducing aliasing artefacts, despite all of the other problems it causes – fill rate is multiplied by a factor of 2, 4, 8 or more, you need hacks like alpha-to-coverage to get proper alpha tested edges on things, deferred rendering and shadowing is made more difficult to get right, etc). The Xbox 360 adds additional complexity to this with its predicated tiling and limited EDRAM.

    (Incidentally, my preference is for a good post process filter).

    As for C#, I guess I’d call myself someone who can get by, but I certainly do not know the language nor the .NET framework inside out. WPF to me seems to be just an overengineered way to get Aero glass transparency effect in your windows (apart from the title bar which Vista/7 seem to handle automagically) – though I’m sure it has merits I’m unaware of, though these probably fall in the “flashy GUI” box.

    The point I’m making is that there are far too many of these “new” technologies for anyone to really keep up with and learn properly. I’ve been coding in C++ now for the last 10+ years and I’m still learning new things about it. Graphics and 3D rendering (the core of my work) are are far from a solved problem. Still, I’d like to learn some new languages if I find the time for it – who knows, there may be some useful ideas I can take back to C++ land.

11. 
    James Says:
    March 31st, 2009 at 12:26 pm

    @Keef welcome to my blog old pal. How are things?

    WPF is more than just flashy GUIs. It’s a very belated replacement of the rather dusty GDI. M$ have really done quite a cool job with if I must say so. A managed presentation layer over several deeper systems such as DirectX, so no more writing interop code to talk to them. Its well worth a look if you haven’t already. I fully recommend the book WPF Unleashed.

12. 
    Keef Says:
    April 3rd, 2009 at 3:07 am

    I thought WPF sat on top of GDI, but if it’s a decent replacement then YAY!

Leave a Reply