Archives / 2003
  • / .Text screensaver!

    Ok, it's finished! :) Yesterday I blogged about my Christmas coding session resulting in an OpenGL 3D effect I named 'Bands' and today I've transfered it into a screensaver, complete with .Text / textures, to say 'Thank you' to Scott and the other people who keep this blogging site running, in a more 'geeky' fashion.

  • 3 hour coding result: OpenGL bands

    On a day like today, 1st Christmas Day (we here in Holland have 2 Christmas days), and a day with no work (some people call it a 'day off' ;) ), the geek inside you gets a chance to eat away some hours with an obviously useless, but fun coding session.

  • Happy holidays!

    To all the people who celebrate the holidays: happy holidays! :) To all the people who don't celebrate anything in this period of the year: also to you: happy holidays :)

  • Signing your assembly, newbie guide

    Follow these easy steps. The first 4 steps you only have to do ONCE in your life. Step 5-7 you only have to do ONCE per project.

    1. Open a command prompt
    2. Type vsvars32.bat (enter) or navigate to the .NET bin dir
    3. Type: sn -k mykey.key (enter)
    4. Move mykey.key to a folder where it gets backupped daily, for example: c:\myfiles\keys\
    5. Open your code's solution in Visual Studio.NET
    6. Open the AssemblyInfo class in the editor
    7. For the attribute AssemblyKeyFile(), specify instead of the default "", the full path of your key, in our example this is "c:\myfiles\keys\mykey.key", so the attribute in full will be:
      C#: [assembly: AssemblyKeyFile("c:\\myfiles\\keys\\mykey.key")]
      VB.NET: <Assembly: AssemblyKeyFile("c:\myfiles\keys\mykey.key")>
    8. Compile your solution. After compilation, your assembly is signed with your strong key.
    9. To congratulate yourself with this big achievement, walk to the fridge and pop open a fresh Heineken.

  • Children...

    It seems some people think they're funny by posting comments under my name in other blogs, or flooding my blogs with crapcomments.

  • Summary of reactions on my blog yesterday

    I blogged yesterday about my concerns related to, Microsoft, its employees moving to this site and my blog on that same site. A lot of reactions were posted and some good arguments were given. I have to agree that when you have something to say about company X and its products, the best place to do that is where company X communicates to the world, and this site is one of those places. I have decided to stay for now, however Fabrice had some very good points: the image of this site is wrong; which was proven by a reaction of Andrew in the same thread. Brilliant :).

  • Is it still allowed to have criticism on Microsoft here?

    With the invasion of MS employees and with the amount of solely pro-Microsoft blogs very recently, I more and more feel less at home here, since I have the feeling it is not that appropriate to say something less pro-Microsoft, with all the Microsoft employees now moving to I'm considering moving my blog elsewhere because of this.

  • Stored procedures are bad, m'kay?

    Let me start with a blunt statement: stored procedures are bad, they are a bad way to formulate data-access logic. I can't state that enough. Today I stumbled into a blog by Rob Howard, which tries to convince the reader that whatever you do, use stored procedures! With tears in my eyes I've read the arguments he brings to the table. Some are silly and one is even based on completely wrong information and assumptions and so far away from the truth it hurts. I've blogged about stored procedures before (here, here and here) and I used them a lot for 8 years, but I'm now almost stored procedure 'free' for 8 months now, and I love the feeling. The reason is obvious: the stress of maintaining a lot of stored procedures, to write another stored procedure for each thing you want to do, is gone. Dynamic SQL is the future. (Dynamic SQL is generated on the fly by a generic piece of code which gets various data as input and generates a parametrized query from it. Which can be cached on the client and will be cached on the server. Dynamic SQL generated based on objects written in C# or VB.NET).

  • (Dutch) Tot over een uur op de DotNed meeting!

    Voor de mensen die vandaag naar de DotNed meeting gaan in Delft, ik ben er ook, dus wellicht tot zo! :) Het zal bijzonder worden, Dino Esposito zal een presentatie houden over de internals van ASP.NET, alleen dat is al de moeite waard :) Ik zal proberen morgen een klein verslagje te tikken, mocht tijd dat toelaten.

  • VB.NET developers, continued

    The article I posted yesterday received the expected replies and I hope in the future it will show people how to look at software, the users of that software and on the various 'holy wars' that are still going on (and probably will be). Today

  • VB Developers should learn to take criticism

    A couple of days now I stumble across blogs which are written by VB.NET developers who feel offended by some remark of some MS employee I will not mention here or feel offended because someone criticizes VB.NET. I feel sorry for those VB.NET developers who feel offended: they do not understand that it isn't something personal, it's just criticism on a language and, sorry, every soul has the right to have that criticism. Sometimes it's criticism on the developers using VB.NET and then again, sorry, this is sometimes true, albeit it is based on generalization which is something that should be noted as well.

  • Short list of non-obvious things determined from the C# 2.0 draft

    A short list of things I could determine from the C# 2.0 draft which was released yesterday which are not a topic of much discussions but are good to know. I've added page numbers to the items, so you can go back to the C# 2.0 draft yourself and look them up (page numbers are the actual page numbers on the page). I've skipped the features: Generics, Anonymous methods, Iterators and Partial types, because these are the obvious items discussed in the draft :)

  • Oracle 9i is already generations ahead and shows a .NET flaw.

    I'm a database purist. This means that I like, no, adore database theory and the technology behind databases. Databases are one of the most high-tech software systems we all work with today, although not a lot of people will recognize them as such. As a developer using Microsoft software for years, I used SqlServer, starting with v6.5 till today with SqlServer 2000. Lately, I had to work with Oracle 9i to write the Oracle driver for LLBLGen Pro. This required me to learn more about Oracle than the usual SELECT * FROM Foo material. What I discovered was something I didn't expect: Oracle 9i is amazing.

  • I don't understand the longhorn-hype

    There will be a new operating system among us in a couple of years: the OS currently code-named 'Longhorn'. The date today is September 29th, 2003. Longhorn is expected in late 2005. That's almost 2 years from now. In these two years, we have to live with Windows XP, that's the current top desktop OS Microsoft has to offer.

  • Useless programming language constructs

    Ok, I'm back! :) After a long period of extensive programming (AKA 'Crunch mode'), the pressure is finally gone. Everybody who has released a big software product knows that releasing it is one, but the period after the initial release is as important as the release itself: early adopters who find odd bugs in weird circumstances no beta-tester has thought about testing nor did yourself thought it would be possible etc. But that's for another story to tell later :)

  • LLBLGen Pro release date set

    To answer a lot of questions directly in one go: the beta program of LLBLGen Pro is going well, we are looking at an estimated release date of the successor of LLBLGen somewhere next week (September 1-5)! Keep those fingers crossed, people :)

    Ok, back into crunch-mode.

  • 'nGen' is NOT related to LLBLGen or me

    Just a quick remark: this morning I saw the adds for the beta for the tool nGen, v2.0 by nAlliance. People who download that beta might get the idea nGen 2.0 is related to LLBLGen or me. This is NOT, I repeat, NOT the case, even when you look at the connection screen which is almost identical to LLBLGen's and it's working is also similar. nGen is not LLBLGen v2.0 or a successor to it.

  • Stop ranting about the blaster worm

    Sorry to say it, but I find the recent rants about the MS Blaster worm from system admins a little silly. MS issued a patch on July 16th. That's how many days ago? Right. Now, when are the systems vulnerable? When port 135 is open to the outside, that's right. Now, how many days do you need to test every scenario? A week? At most. That's July 23rd, and you can start patching. That's how many days ago? Oh, you need to patch 1000 systems? Perhaps you should enroll some software MS developed ages ago to push installs onto client machines.

  • Sorry for the lack of updates...

    For the people eagerly awaiting new blogs from me, I'm sorry, but I'm in 'crunch-mode' at the moment, which means every minute of my time is spent to finish LLBLGen Pro before the end of August. It should go beta this week (as it is 99% feature complete, the last big hurdle was taken today, *pfew* :)). There are so many interesting topics I wanted to blog about last week and this week, but I simply don't have the time (to name a few: where to put my Business Logic code? Why a blog reader that can post blogs is a weird idea. VS.NET wish list part 3... etc.). When I find some minutes to blog some info, I'll try to do that in the coming week(s), however I'm more of a 'lecturer' blogger than a 'this passed my braincells just a few seconds ago and of course I found the need to share it with you'-blogger, so I hope to find some short blog-ideas that still can be very useful to you, my dear reader :)

  • More on the badness of E&C and how to debug software.

    Several people, mostly VB.NET developers, have disagreed (and still do) with my opinion about Edit and Continue (E&C) in a debugger. It's a free world (well, for most people). However let me elaborate some more about why I think Edit and Continue isn't a feature you really should be using and if you do, especially often, you are not using a good debugging style.

  • So Microsoft, when is VS.NET 2002's service pack released?

    When VS.NET 2003 was announced, Microsoft made it clear that it wasn't a service pack for VS.NET 2002 you had to pay for, it was a new release and that they'd release a service pack for VS.NET 2002 'shortly' after the release of VS.NET 2003. Well... it's been 3 months now today, since VS.NET 2003 is on the market and no sign of any service pack for VS.NET 2002.

  • The Blob!

    Microsoft Research is busy using inkblobs to construct strong passwords that are easy to remember. Very interesting read. Go to the article by clicking [here].

  • Get rid of the 'file' concept for sourcecode!

    After the recent sourcecode control debate I started thinking: why on earth are we still using the 'file' as the base unit to store sourcecode in? The whole 'file' concept is pretty bad and limiting when it comes to sourcecode control, code reuse and overall code management. Much better would it be if we could work with a code repository as the container for our sourcecode which would work with sourcecode elements like we know, e.g.: namespaces, classes, assemblies, resource objects etc. etc.

  • It's not Visual SourceSafe's v^Hfault

    Lately, some people started blogging about a new source control system, Vault. I haven't used it, nor am I intending to do so. The reason is not that I don't like Vault or Eric Sink, but because I don't have problems with what I currently use, Visual SourceSafe (VSS). I personally believe Eric Sink knows what he's talking about big time, as his blogs are one of the few which truly show some vision on the total scope of software development, and therefore I think Vault must be a product that can live up the hype that is being build up around Eric's new source control system.

  • LLBLGen v1.21 has been released! (Mostly bugfixes)

    A new LLBLGen v1.x has been released today! Version 1.21.2003.712 to be exact, is a QFE (Quick Fix Engineering) release, which means only minor new features are added and for the rest just bugfixes. This is the final release, no more updates will be released after this release, since the next version of LLBLGen, LLBLGen Pro, is in development and will be released later this summer. The sourcecode comes in a project that is compatible with VS.NET 2003 but not with VS.NET 2002. You need a converter to load it into VS.NET 2002.

  • Re: Am I the stereotypical VB Programmer?

    Roy writes some text about him wondering why someone "accused" him of being a stereotypical VB programmer. Now, why is accused between quotes? If you wonder why or think being called a 'stereotypical VB programmer' is a bad thing, I feel sorry for you. Being "accused" of being some stereotypical [insert a 3GL language here]-programmer by a random person X is nothing to worry about.

  • XBOX's 4th of july

    Some German geeks discovered a hole in the XBOX's dashboard loader code and because Microsoft didn't respond to their claims, they now have released their proof of concept to the public, with exploit code. I find it a little farfetched to call it a 'security hole' which should be stamped 'critical', because after all it just lets you do what you want with hardware you own yourself. The exploit is a nifty trick with an integer underflow in the buffer allocation logic in the font loader. Two doctored font files, called ernie.xft and bert.xft do the work for you. Sorry to say it but I find it clever that you can find such a hole in the first place and a sign of a good sense of humour to call the files to pull the trick 'ernie' and 'bert' :)

  • About code generators / generating code

    James Avery blogs about an article written by a person who calls himself 'Angry Coder' (I thought people called me that ;)) and that article ventilates the opinion that code generators are not useful, to say it in a politically correct way. I agree with James Avery that the article misses the advantages of code generation and how it can benefit you in your daily life. I'd say: the article is totally wrong. Here's why.

  • My wish-list for the next Visual Studio.NET / .NET api release, part II

    I've blogged before about wishes I had for the IDE I use on a daily basis: Visual Studio.NET (currently v2003). Since that blog I've made a new list of new wishes not mentioned in the previous wish-list. I've also included wishes for .NET and the .NET API. The list is very long so I decided to post it as a story. You can find the story by clicking here. Below is the list of items I discuss.

  • Create #region macro for C#

    Yesterday I was playing around with VS.NET and discovered that I didn't use any macro's at all. So I opened up the macro IDE and looked at the examples. It's pretty easy stuff. So I wrote my first macro. It is a set of macro's actually which create #region ... #endregion sections. Two pre-defined ones for members and properties and a generic one which pops up an input box for the region name. Bind them to a hotkey and you're set. I'm pretty sure the code can be more efficient, it's my first attempt to write a macro that manipulates an active document in the IDE, so if I'm doing things in an inefficient way, that's the reason ;)

  • Harry Potter reloaded

    I have a copy now of Harry's new book, 'The Order Of The Phoenix'. It's even thicker than its predecessor :). Thankfully my wife volunteered to read it first, so I can continue reading Hillary's Bo^H^H^H^H^H^H^H^H John T. Lescroart's latest ;)

  • Move away from stored procedures or not?

    Jimmy Nilsson asks on his weblog if I've dropped stored procedures for everything, according to my dynamic query blog. Well, no, I haven't. The reason for this is simple: you should use the technology that fits the job best. If a couple of actions are simple in SQL and hard in C# or other 3GL (which is highly likely, since SQL is set-based, C# is imperative), why not write that code in SQL?

  • About computers and marriage

    Scoble (among others) writes about a situation which is a given in any marriage where one person is gifted with 'geek-genes' and the other lacks every single one of them. Here in the Netherlands we even had a term for those wives which feel neglected because their husband is spending more time behind the keyboard than with her: "Computer weduwe" or in English: "Computer Widow".

  • Sometimes, the human mind acts in mysterious ways

    What follows is quite embarrassing actually. Yesterday, I was reviewing my own code and optimizing it a bit, looking for ways to make it even more generic, adding more constructors for ease of use, you know the whole 9 yards. In the O/R mapping layer which is targeted by the generated code of LLBLGen Pro, the application I've been working on for the last 5 months, I use a dynamic query engine (DQE). This DQE is specific for each database vendor so you have a special DQE for SqlServer, one for Access etc. The DQE constructs query objects which contain a command object, the parameters and all other necessary objects and data to get the query executed. All methods are static.

  • Feeding the trolls

    Today I've seen some people hammering stacks of MSDN cd's onto the heads of some other people who obviously talk about what their employer wants to hear, f.e. Matt Puccini and others.

  • if(objectHasPropertiesOfAnInterfaceType) { DoNotUseXmlSerializer(saidObject); }

    A short remark which can save you tremendous trouble and hours of hairpulling: if you want to test if your objects can be serialized, do not, I repeat, do not, use the XmlSerializer class when your object has properties which return / accept an interface. The Soap serializer will work with these properties just fine, but the XmlSerializer will barf it can't handle interfaces. I just spend an hour rewriting some interfaces, crawling through google groups and finally discovered the XmlSerializer class isn't about serializing at all.

  • Optimization the right way: optimize your algorithms

    Sam Gentile, among others, pointed us to two articles at Microsoft about the speed of managed code, how to optimize your code, tools that can help you and low level insight of what's going on in the CLR when it comes to the storage of data and GC. There are two articles: Know what things cost, and a primer about how to write fast managed code. I first read the 'know what things cost' article. It is a well written article and some good info if you are interested in that info. However it's not that useful for optimizing your managed code, if you ask me. I'll explain that in a second. The other article appeared to me as very useful, because it describes problems and gives hints to think about.

  • When Mono is completed, Linux is the option for the desktop.

    Randy Holloway wrote about his vision on Linux and then especially about Linux on the desktop. I disagree with his vision, I think Linux is definitely an option for the desktop at the moment and thus also in the foreseably future. It will become the option for the desktop when Mono is completed. The reason for this is simple: a lot of Windows programs will be written using .NET. If you can run these programs on Linux too, using Mono, what's keeping you on Windows? Perhaps the games. But definitely not the business applications, since the Linux version for spreadsheets, browsers, wordprocessors, emailprograms and other every-day software are solid today, even when compared to Microsoft Office XP.

  • Microsoft, developer editions should be free.

    Paschal L posted this snippet from the introduction speech by Paul Flessner (SVP) at Teched: "...A couple other things on SQL Server: Our developer edition used to sell at $499. We're lowering the price to $49, announcing basically today, and that will be embedded -- (applause) -- thank you -- that will be embedded and picked up, we think, by other tools vendors. Borland has already announced that they'll be picking it up and shipping it with their C# development environment...."

  • About sharing Intellectual Property, USP's and Patents

    Robert McLaws wrote : Now that I've reduced my codebase for GenX.NET 3.0, I just figured out how to reduce the size of the output file by 50%-90% in some cases. Here's the part where I'm at a loss... Do I talk about how I do it? Or do I make you buy the source code to find out? The problem is, I've seen how my competitors output their files, and they don't use this method. This gives me a competitive advantage, and another reason why my customers would want to buy my product. So do I talk about it?

  • Entity: why do some people who write IT books re-invent definitions?

    Paul Gielens blogged about a possible misunderstanding about the term 'Entity'. Reading his text it appears as if the general term 'Entity' has changed recently. The reason: Eric Evans created a different definition. Let me be blunt here: if a definition of a general group of knowledge is known for years by a given term, do not use that term to extend that definition so it will cause misinterpretations between people thinking they are talking about the same definition. The term here is 'Entity', and it is defined for a long time, firstly by Peter Chen if I'm correctly informed, in his article 'The Entity-Relationship Model', ACM Transactions on Database Systems vol.1 nr.1 (March 1976), and his book 'The Entity-Relationship Approach to Logical Database Design' - Wellesley, Mass.: Q.E.D. Information Sciences, 1977.

    Chen's work is about a model to design databases, the Entity-Relationship model, in short the E/R model. As you can see, this model is rather old, more than 25 years, and is replaced later by the work of prof. G.M. Nijssen and prof. T.A. Halpin (Conceptional Schema and Relational Database Design, 1989) by their work on the NIAM modelling methodology, later renamed to ORM and extended by prof. T.A. Halpin. (read more about ORM here)

  • A quick update on LLBLGen Pro

    You might have heared about the DAL generator I released last year, LLBLGen, which as a surprise to me, became a worldwide success (over 25,000 downloads). I'm currently busy developing its big brother LLBLGen Pro, which should be released later this summer. As a quick update on what this successor is capable of, some lines of example code which uses some generated code (entities, collections) that is produced with an alpha version of LLBLGen Pro.

    It loads a collection of entity objects (that's right, normal entity classes) of the type OrderDetail, from the Northwind database, which contain references to the product with ID '24', binds it using databinding to a datagrid in a form, which allows full editing of the OrderDetail objects, and after that, all changed objects are saved using an embedded transaction to the persistent storage using a single line of code. I think it's pretty neat :) Of course this is one of the many ways to retrieve / construct entity objects using the O/R mapper code generated by LLBLGen Pro. More updates later on.

  • My wish-list for the next Visual Studio.NET release

    I'm now working for a week or so with VS.NET 2003 and it has some neat features that version 2002 didn't have which are, well, neat to have, but also started me thinking why they are implemented the way they are and why there is so much ground left untouched. Below I've formulated some wishes for the next version of Visual Studio.NET (2004?), and as with every wish-list, I hope the wishes come true, or better: what's wished for is a bad example of a short sighted vision of how reality should be and the next version of VS.NET (2004?) will prove that :)

  • Firebird .NET data provider v1.0 released

    Yesterday, the Firebird team released their .NET provider for the Open Source database Firebird (based on the Interbase code). The provider is also open source and of course free. I haven't played with the Firebird database recently but according to the features Interbase had and looking at what the Firebird team added / updated in the source code, it is a massive alternative for those developers who need a true RDBMS with ACID compliance throughout the system and full stored procedure and trigger support but can't afford SqlServer (or alternatives which cost even more money).

  • Quick note from the HN-rehab center

    A quick note on the Hungarian Notation/Coding blog I wrote this morning and which was food for some good replies from Patrick and Chad. I now am a full day clean, that is, no Hungarian Notated member variable or parameter left my fingertips. The arguments I had this morning, about the naming problems of some parameters I had and the prefixing of private member variables, were not that hard to overcome.

  • Farewell, beloved Hungarian Coding.

    Today, is a memorable day for me. This morning I had to bite the bullet: get rid of my Hungarian Coding style in C#. Not because I hate Hungarian Coding, on the contrary: I love it, but because I have to. The reason for this is that when you want to sell a library which targets .NET, you simply can't feed your customers a library with interfaces which use input parameters like cmdCommandToExecute or efEntityField. I did convince myself when I started this project, it was my code and I should decide how the interfaces looked like. But this is just plain stubbornness. A customer doesn't give a you-know-what about the zillion + 1 reasons you can bring to the table why you had to make the interfaces of the classes inconsistent with the rest of the classes used in the application (f.e. the .NET classes).

  • Concurrency Control Methods. Is there a silver bullet?

    Which concurrency control method do you use most of the time? "First Save Wins" ? (optimistic locking in ADO.NET) "Last Save Wins" ? (Overwrite the row, no matter what). Ever wondered what the difference between the two is when it comes to efficiency? Most people haven't and think "Last Save Wins" is BadTM and "First Save Wins" is GoodTM. But both make at least one person loose his work to preserve the work of another person. I read a thread today in the microsoft.public.dotnet.framework.adonet newsgroup where one person asked how he could make the SQL generator in Visual Studio.NET to use the Last Save Wins method and another person stepped in and bashed him for using a not very smart concurrency control method like Last Save Wins. But does it matter which one you pick when both are as inefficient as you can possibly make them to be (i.e. someone looses work) ?

  • Microsoft gets Database Performance crown back!

    On May 20, HP regained the TPC-C performance crown for non-clustered (you know, "Big Iron") , using Microsoft Windows server 2003 Datacenter Edition and SqlServer 2000 Enterprise Edition 64-bit. It almost also nailed the clustered (you know, "Little Iron") record, also HP/Windows/SqlServer, result which was submitted September 2001. A stunning 707,102 transactions per minute were clocked on this beast with 64 Itanium 2 processors.

  • "Framework-Hell"-solution is here: ISV's can upgrade to VS.NET 2003 without pain.

    Yesterday I blogged about a problem ISV's can run into when they are selling .NET class libraries compiled with Visual Studio.NET 2003 to customers using Visual Studio.NET 2002. Today I've found a solution, which seems to be used by other ISV's already, and which solves the problem which caused me to post my rant yesterday. Below I'll first describe in a few words the exact definition of the problem and then the solution which works without any problem for your customers. After that I'll enlighten a bit the things you have to keep an eye on when implementing this technique.

  • "Framework-Hell"-solution is here: ISV's can upgrade to VS.NET 2003 without pain.

    Yesterday I blogged about a problem ISV's can run into when they are selling .NET class libraries compiled with Visual Studio.NET 2003 to customers using Visual Studio.NET 2002. Today I've found a solution, which seems to be used by other ISV's already, and which solves the problem which caused me to post my rant yesterday. Below I'll first describe in a few words the exact definition of the problem and then the solution which works without any problem for your customers. After that I'll enlighten a bit the things you have to keep an eye on when implementing this technique.

  • Beware of the UnUnloadable IL!

    Today an interesting thread was started on the DOT-NET CLR mailing list. The topic: a possible memory leak can occur when you are not careful with XSL transformations or compiled regular expressions. The reason for these memory leaks is that the CLR is generating IL behind the scenes and generated IL cannot be unloaded from an AppDomain unless the complete AppDomain is unloaded. Garbage Collection (GC) is not fixing this. The XSL transformations which will cause trouble are the ones which have to deal with XSL stylesheets with JScript embedded. The JScript is compiled into IL and as said, this will never be unloaded.

  • VS.NET 2003 isn't all that bad (sort of)

    A few days ago, I blogged about a serious flaw in the ASP.NET editor in Visual Studio.NET 2003. Now, don't get me wrong, I really find it stunning this Bad BoyTM is still around, and according to the follow ups to Mike Moore's posting in the usenet thread about this issue, more people are seriously offended by this lack of customer support, but... Visual Studio.NET 2003 isn't all bad. In fact, some great enhancements are finally available.

  • Serious ASP.NET Editor flaw lives on in VS.NET 2003

    Several (ok, a lot) of people have been bitten by the "I-format-your-HTML-code-as-I-please"-bug in the ASP.NET HTML editor in Visual Studio.NET v2002. To recap what the bug does to you: you are working in HTML view on a page. You have to do this because f.e. you are working on a repeater template. Because you are a good developer, you create a readable layout of your code, so also for this HTML. When you come to the point where you have to add a control to your ASP.NET page, you have to switch over to design view, drag it from the toolbox onto the page, switch back to HTML view to add f.e. templates or additional properties or even position it correctly. When you switch back from design view to HTML view, your code sometimes (not allways) gets reformatted randomly, even if you switch off any auto-formatting feature in Visual Studio.NET. Hitting control-z undo's this formatting, but it gets annoying over time.

  • The 'benchmark' code

    I've decided to post the code I used to test what's faster: dynamic queries or stored procedures with optional parameters. The code can be found here. Let me add a disclaimer here, that I'm not pretending to have done scientific research or other scientific benchmarking. All I've done is wrote a couple of routines which represent for me a real life situation using either one of the techniques. Of course the routines can be sped up and recoded in other forms, and perhaps I've made a mistake in the code which results in the slow speed of either one of the used techniques. Feel free to comment :)

  • Relationships

    No, this is not a piece of text about a broken/just started relationship between two people :). 'Relationships' should be read in a geeky context: relationships between attributes and entities in databases / object hierarchies, you know, the kind of relationships a computer-savvy person feels comfy with.

    On April 18, Edgar (Ted) Codd died. This man is probably not the man you remember as the 'hero' you adored and who convinced you computers were your future, but it is the man who invented the concept of 'relationships' in our world, the software developers world, which resulted in the concept of Relational Databases. Now, as we say in The Netherlands, "Over de doden niets dan goeds", which means something like "Say only good things about the people who died", I shouldn't be saying this but in the last couple of days I'm seriously starting to doubt the quality of the form Codd defined the concept of a relational database as we know today. I think it is seriously flawed, and when I say seriously, I mean: really seriously, as much that we should start using other models today, instead of keeping this flawed model around any longer.

  • Borland's prices are too high?

    S.B Chatterjee wrote: "Borland has announced their C#/.NET Builder tools along with the prices. $69 for a personal edition and $999 for a professional version. That's fourteen times as much! jeez... I don't see developers flocking for that one. I'll stick with my VS.NET (under MSDN Universal, of course)."

  • Hotmail: 48 spammails per day, per mailbox

    According to, Microsoft blocks per day 2.4 billion (that's 2,400,000,000) email messages targeting Hotmail subscriber in-boxes. If you take into account that Hotmail has roughly 50,000,000 active users, that means that per mailbox, 48 (2,400,000,000 / 50,000,000) spam-messages were on their way to enlighten the eagerly awaiting mailbox-owner that those days of a whimpy penis and denty tits can be over for good.

  • It's not all bizznizz apps

    Every day I check the image of the day over at, which is the place for Joe Geek and Family to show off their sunday-afternoon graphics software. It's amazing what people come up with from time to time, and today, a programmer from Belgium send in his 3D-terrain renderer/generator using OpenGL and C#. It's a great way showing off what you can do with C# and .NET besides the always charming n-tier / remoting / webserices / webapplication-oriented software. It utilizes the great work of the csgl guys who, as you all know, wrote a library for C# to work with OpenGL. As a former OpenGL junkie myself, I always get a "those were the days" feeling, while reading about graphics software. ;)

  • Speaking of patterns...

    A lot of patterns do share a 'trick' that can be hard to grasp for new OO-developers. It's the trick which is made possible by polymorphism: you define a virtual method in a base class B, override it in a derived class D, and suddenly code in class B will call code in class D. To me this sounded confusing at first (hey, I'm raised with Kernighan-Ritchie C, the non-ANSI version, bite me :P). However it's a very neat way to 'plug in' code later (in a derived class) while defining the flow of the code now (in the abstract / base class).

  • A pattern in patterned confusion.

    Chad Osgood talked this morning about a semi-rant from Bruce Eckel about patterns and the Gang of Four (GoF) book in particular. Reading the snippet from Bruce, I do not see why he (Bruce) critisizes the GoF book that much. As an example he shows the diagrams of the strategy pattern and the state pattern. They look familiar indeed, but they are semantically different, and that's why they form different patterns. When swapping algorithms you use the strategy pattern. When swapping state objects you use the state pattern. A different world altogether. The UML-ish diagrams may look familiar, but they're not.

  • I'm alive!

    These days, it's hard to claim you're truely a geek when you don't have your own blog. And, if I might add, the blog has to be placed on a blogspace which holds some value. I'm very happy that I can conquer those suits at upcoming birthday parties again, when they start ventilating their coolness because they 'blog': I now too have my blog, and on one of the major blogspaces!