Frans Bouma's blog : Community News

(Dutch) Devnology podcast nr. 3, interview met mij nu online.

FransBouma — Sun, 29 Nov 2009 17:42:36 GMT

Devnology, de Nederlandse developer community die niet gelieerd is aan 1 specifiek platform, heeft z'n 3e podcast nu online gezet, welke volledig bestaat uit een interview met ondergetekende! De podcast duurt ong. een uur.

inc(me.MVP)

FransBouma — Thu, 02 Apr 2009 08:03:03 GMT

Yesterday I received the MVP award for C# again, thanks Microsoft!

[Dutch] Devnology Code Fest

FransBouma — Tue, 17 Mar 2009 12:47:54 GMT

(Sorry English speaking visitor, this post is in Dutch, as it's about a Dutch user group meeting)

In Nederland hebben we een aantal gebruikersgroepen die op gezette tijden meetings organiseren voor developers. Aan dit aantal is een nieuwe toegevoegd, Devnology (http://www.devnology.nl). Devnology is niet zozeer gericht op het houden van meetings waarbij 1 persoon een praatje houdt en de rest poogt niet in slaap te sukkelen, het is meer gericht op discussie en interactie tussen developers, samen bezig zijn met code, software engineering en andere aan ons vak gerelateerde zaken. Ook is Devnology niet gelimiteerd tot .NET alleen maar zijn andere talen en platforms even welkom. Het gaat tenslotte om software engineering en niet om de laatste truuks voor een random MS product.

Op 1 april houdt Devnology haar eerste meeting, een Code Fest: je krijgt vooraf een opdracht en wie de beste implementatie maakt wint. De opdracht deze keer is: programmeer de Game of Life, een bekend concept, en de keuze van platform en taal is vrij. Deze opzet komt me bekend voor van vroeger uit de demoscene, waar op demo-parties ook dit soort compo's gehouden werden. Het leuke aan dit soort dingen is dat enerzijds de competitie je toch dwingt je best te doen en anderzijds de discussies met mede-developers ter plaatse altijd wel wat nieuwe kennis en info opleveren waar je wat aan hebt.

De opdracht van Game of Life is op het eerste gezicht wellicht wat een dood spoor maar je kunt op zoveel manieren dit probleem aanpakken dat het nadenken daarover, het uitpuzzelen welke benadering juist die originele oplossing oplevert, juist je tot ideeen kan brengen waar je als software engineer baat bij hebt, in je vak en dus in je dagelijks werk.

Devnology gaat in juni ook een Open Spaces meeting houden en daar kijk ik nu al naar uit.

Ik ben van de partij op 1 april. Zie jullie daar!

Happy 2009!

FransBouma — Thu, 01 Jan 2009 14:27:20 GMT

To all my readers, and everyone else: I hope you all have a great, productive, healthy, awesome 2009!

For me personally, 2009 will be a big year with the release of LLBLGen Pro v3, which I think will be a serious milestone in my vision about how people should approach the generic problem of Data Access in software. It will be a while before I can show anything, but I'm sure it will be worth the wait.

Small interview with me about blogging

FransBouma — Wed, 03 Dec 2008 13:54:56 GMT

Andreas Håkansson did a couple of interviews with various people from the .NET blog community about... blogging . The interview with me is now available here.

from el in world.ExtensionMethodsLibraries group el by el.Method into g select g;

FransBouma — Wed, 22 Oct 2008 10:27:48 GMT

Everyone who's doing .NET 3.5 development these days will likely run into the same problem I ran into this morning: your set of extension methods grows beyond the level of a single file and you need to group them into separate sets of files or worse: you discover you have several distinct projects which all have extension methods and it's better to group them into a single library.

So I started VS.NET 2008 and began with a new solution and a new class library project. Right at the spot when I was thinking how to name the darn thing (you must know I'm very good at cooking up catchy names ), I realized it might perhaps be possible that someone else has had that same idea and already started such a library. It would be useless to have two extension method libraries for the BCL, so I went to CodePlex and searched for Extension Methods

The query returned 56 projects ! Not all of them BCL extension methods, but all of them more or less libraries with extension methods. That's simply too much, people. The fragmentation shows: most of them are hardly used, downloaded perhaps 50-100 times. This is a bit sad, because some contain valuable extension methods, though to find these is a bit of a struggle: they're often buried in piles of useless filler methods or rewrites of existing extension methods. Besides that, it's still not that convenient to have to reference a group of libraries to have them all at your disposal.

For our own code, it's best if we have all BCL related extension methods into a single library so we have to reference just a single class library and I think that's true for most of you out there. Still, some of my extension methods aren't in any of the libs out there, though I'm undecided to which library to give them to and use that one: I don't want to base our code on a library which is perhaps already dead, and I definitely don't want to use a library which has a lot of code which is really redundant (e.g. it's already in the BCL) or silly or very project (but not my project) specific.

It's tempting to just dump the code on codeplex and be done with it, though in general that's not going to bring the .NET community forward: more fragmentation is not going to lead to more usage of the libraries already out there. However, not doing anything isn't good either: I'm sure a lot of developers out there have written the same RaiseEvent extension methods as I have done and have perhaps a few handy helpers which could be a valuable tool in everyone's toolbox, like the better DataRow.Field<T>(name) I wrote this morning so I don't get cast exceptions anymore. Having these methods grouped into a single library which is open source and free (i.e. uses a flexible license so no GPL-ed stuff) is what the community needs, if we all don't want to drown in extension method libraries.

Anyone out there who has thought about this already and has a solution for this? If so, please post in the comments below. In the meantime I'll group my extension methods in a separate lib so if nothing comes out of this, it will be project 57 .

See you at DevDays 2008!

FransBouma — Wed, 21 May 2008 09:08:13 GMT

Tomorrow, May 22nd, and Friday, I'm present at the Microsoft DevDays 2008 in Amsterdam. I'm told we get special t-shirts, so it shouldn't be hard to find me . I'll be at the Microsoft Community Booth or in some sessions. If you want to say hi, please stop by! See you tomorrow!

this.AddAward(MVPAwardFactory.Create());

FransBouma — Tue, 01 Apr 2008 14:08:28 GMT

Microsoft has awarded me again this year with an MVP award for C#! I won't be at the MVP summit this year though (held in 2 weeks).

Anti-agile hatemail

FransBouma — Fri, 14 Mar 2008 09:35:23 GMT

Today I received through the contact form on this blog a hate-mail from a guy who called himself 'Ryan'. Ryan used a fake, non-existing email address so the only way to respond to him is via my blog, hence this post. Let's look at the email first:

From: ryan@notanoob.org
Subject: (Frans Bouma's blog) : anti-agile

Your post on Jeffrey Palmero's blog is laughable. He is a smart and successful person and is involved in practices that you do not understand. Your post makes you look like a moron. You obviously have a lot to learn about agile development.

The ONLY thing that works on large .net projects is the platform independent knowledge that the java / C++ / small talk community has learned over the past 20 years. I know because I work on a 3 million LOC, 200+assembly .net product every day. MS built the best development platform, but what MS teaches is crap. In the end, the culture of the development shop is what makes or breaks it. Agile practices focus on that culture. Tools and processes are secondary.

One day when you work on a real app that is more than 100K lines of code maybe you'll understand. You should not venture outside of the realm of your fan base, which is newbie developers that have a background in ASP.

I would love to see your product choke on several of our 100+GB databases.

Thanks.

My post about stored procedures back in 2003 generated the fair share of hate-mail in which angry DBAs and other stored procedure supporters wished me all kind of bad things and told me I had no clue whatsoever. I think it's related to speaking up in public and some people apparently can't deal with another person's opinion very well.

This particular email illustrates something I can't understand: why does someone get so angry about a random reply I've written to someone's weblog that that person goes to this particular blog, and types in the text above? What's the goal? To tell me how the world really works? It's never a pleasure receiving this kind of email, and it surprises me every time why a person thinks 10 minutes of his/her precious time is better spend on writing a hate mail than writing a mail which could open up a mature discussion so ideas/thoughts/arguments can be exchanged and both parties participating in the discussion can learn from eachother.

Let's address the various topics which are mentioned in the email. To start, I have no idea who this 'Ryan' person is, and I definitely don't know which post on Jeffrey's blog he's referring to. I don't doubt Jeffrey is smart and succesful, and I have no problem whatsoever with Jeffrey at all. Too bad Ryan didn't include a link so I could have elaborated what I wrote.

Ryan then goes into show-off mode and claims he works on a 200+ assembly, 3 million lines of code project every day. I'm sure he wrote that all by himself, but let's not focus on his work. The gem is in the line 'MS built the best development platform'. I'm sorry to bring it to you, Ryan, but VS.NET and the .NET framework are build with hard-core waterfall practises: cleanroom-design, hard-core specs are written out to the letter with every tiny detail explained, then the development of code is done, and after that the long process of testing and weeding out bugs starts, and after that: shipping.

Not to propagate waterfall, as for the gazillionth time: I don't like waterfall, but it's simply true. Because Microsoft uses this practise (and most other big corporates do who ship large products), it's very hard to get things changed once the hard-core spec phase is over. Most MVP's who have ever tried to give feedback to a product team, even more than a year before shipment know this the hard way: feedback is never accepted once the specs are finalized.

What Ryan apparently doesn't understand, is that I'm not anti Agile, why would I be 'anti'?. The 'Agile' movement, which first was meant to be called 'Adaptive', is actually simply a movement which propagates 'being adaptive to change'. As a software engineer I can't understand how someone can be against that: being adaptive to change is what's it all about. However, if I state that I think (thus which is a personal opinion) something is an oversight, e.g. that with just a bunch of unittests you create a false sense of correctness, does that make me anti-agile? If so, I would be anti-'adaptive to change', which isn't the case.

If I look at how I wrote LLBLGen Pro, which spans more than 350,000 lines of C# code btw, I always tried to focus on that: be adaptive to change: make it modular, make it flexible. We're a small company. I didn't have time to write out the full design document. So I didn't: everything is build with vertical slices, designed per feature, not BDUF. You have to, if you have to design an entity object model to store mapping data, entity definition data, database design data, the full designer to manipulate all that, for every database a driver to obtain meta data, an engine to merge changes into object graphs, the task-based engine who can execute tasks for you to generate code, create folders etc., the DSL to write the templates in, the LL(1) parser for the DSL, the code generator engines (there are more than 1), the runtime libraries and of course the templates. Ryan, do you really think I designed that all up-front to the fine details and then started coding? Think again.

Ryan then explains that once I'll work on a large 100K+ project, I'll understand. Sure, I did that many years ago already and till today, I'm glad I did so. So I'm not entirely sure Ryan really means 'Agile', I think he meant 'TDD' and that one (in this case: me) shouldn't speak about the fact that having solely unittests is not always a good idea if you want to have correct code.

He then goes on to bash the readers of this blog and the fans of our work, and with that, I again wonder...: why? What's the point, do you, Ryan, really think the world gets better with writing these below-the-belt-flames to someone? Aren't we all software engineers working on software, doing the best we can? If so, then why the hatred?

The last thing I want to address is why he apparently would, like to see LLBLGen Pro choke on databases with a lot of data? It's not hard to make any system choke on large volumes of data, as fetching large volumes of data takes time. Fortunately some large companies use our work on very large databases (1000-2500+ tables) and it does fine. Would that be because it's written with 'being adaptive to change' in mind? Not sure. But as you, Ryan, seem to think I have a lot to learn about software engineering, it must be luck, right?

Come on, Ryan, whoever you are. Why not have a good discussion with arguments instead of flames? The world knows already enough hate and anger, we don't need to create more. . The 'agile' movement sometimes get negative press of being full of hate. I don't think Agile, the agile movement, TDD are about hate nor do I think the persons participating in that movement are full of hate. I think they're passionate about the movement they're in, like other people are also passionate about the movement they're in. So, Ryan, do yourself and the movement you're passionate about a favor: next time, please start the discussion like an adult: with proper arguments so we can have a proper debate between two professionals, OK?

To the new weblogs.asp.net bloggers

FransBouma — Tue, 29 Jan 2008 09:13:23 GMT

First of all: welcome. Now, as you all might know, this blog site, http://weblogs.asp.net, has a grouped RSS feed (a couple actually), which is called the 'main feed'. If you place your post in a category which is in the default list of this site, your post will automatically end up on the main feed. This is a nice feature, but as it is used now it kills the site.

At the moment, the feed is flooded with completely useless posts: posts which link to articles from 2 years ago, copied texts from manuals, very poor code copied from other websites etc. etc. More and more people are giving up on this main feed because of this. While what you post on your blog is your business, you have to realize that by placing the post on the main feed, you also affect others on this site. For example, I don't want people to unsubscribe from the main feed and I bet a lot of others here think the same.

So, dear new blogger at weblogs.asp.net, do yourself and us a big favor: write new content. We all know about a couple of search engines, and we all know how to lookup things in MSDN. We don't need random posts without any red line to point us to these articles. Instead, what we don't know (yet) is what your opinion is about topics related to .NET programming, what your experiences are with .NET programming, what your ideas are about how things could get better. Those articles are interesting to read and will attract new readers and existing subscribers to come back.

History learns that this flood of useless posts is temporary, but what's sad is that often people who unsubscribe to a feed don't come back.

The waterfall which makes Agile pundits go blind

FransBouma — Fri, 11 Jan 2008 16:13:12 GMT

DISCLAIMER: this is a bitter post. If you get offended by this post, I'm sorry, though I had to write this. If you want to leave a comment, please do so, but as it's my blog, I'll remove comments which I think are inappropriate

The last month or so I've been on the 'alt.net' mailinglist which later became 'lists' as the original one, altnetconf, was renamed to cli_dev (for whatever reason) and some group started a new one, altdotnet. I can't say I had a good time. In fact it was more or less a pain in a lot of occasions. I don't mind a sharp debate, and we all can agree on everything, but from the start I've never felt to be accepted as a person who has a valuable opinion. At least not by some more hardcore Agile/XP/TDD people.

As you probably have understood, I left both of the lists and won't come back. Earlier this week I decided to leave the cli_dev list, after a painful thread about the usefullness of comments in code. It's an old debate, so from the start everyone participating would know that it would likely last forever and the basic dumb arguments would be placed on the table. What made it so painful was that it never became a discussion between professionals. There wasn't any serious debate which could all bring us forward. Instead it ended with bickering why some of the posted examples (one of them was mine) were bad, and more importantly: they were used to bash the code and with that the programmer. I've spend almost two decades in newsgroups and mailinglists now so these kind of debates aren't new to me, but as I'm not a teenager anymore (far from that ), I started to wonder why on earth was this even happening.

The point of such a mailinglist falls apart if debates aren't used to get things forward, to express ideas and learn from other people's arguments why they've chosen their point of view. A lot of the discussions weren't about debating arguments, but hammering down opponents, as if there were achievements to gain from doing so. The cli_dev list particulary was a big pain because of the endless debates about what 'Alt.net' meant, why or why not there should be a manifesto, who had the right to call the shots of what would be included in such a manifesto etc. etc. I think the comment debate was the last push I needed to call it a day on that list.

The other list, altdotnet, was OK for a while, however it turned out that the group of people participating in the discussions actually started to look like the same group who did the debates on cli_dev. The end result was that the discussions became more and more painful. The reason was that you had to be very careful with your formulation to avoid awaking the TDD/Agile people who simply want to b*tch about anything that's not TDD/Agile.

This morning I made a mistake: I used the W word in a post. What's the W word? The W word is Waterfall. The W word makes Agile pundits go blind, at least for a couple of minutes. It will make them go blind for any words you might have written after using the W word. What did I do? I used the W word in a short silly overexxagerated-to-get-it-across-example:

Every movement/pressure to go into a given direction in general causes a reaction among people who disagree: they will try to go into a different direction. Waterfall, while being great for systems which must not fail like your MRI scanner or wafersteppermachine or your satellite robot, it sucks when you have to deal with clients who change their minds 10 times a day and who sold their tiny brain at e-bay last year.

A silly example, but I made an error: I stated that Waterfall was great for a situation. I meant it as an example of how one movement can cause the creation of a counter-movement. This is sociology 101. All of a sudden, I was back in the seat meant for the Waterfall lovers and I found myself defending Waterfall, something I don't want to do, because I don't like the methodology that much (read: I in general don't see a lot of cases where it can be successful)

I don't know why some people keep on pushing the 'Bouma likes Waterfall' message, while it's not true. Perhaps it serves their agenda. This latest 'debate' this morning made me realize: "What on earth am I doing here? Why am I writing posts on a mailinglists which has people who like to offend me?" and decided to leave the altdotnet mailinglist as well. It was a sad ending for me, as I had great expectations when I joined the lists a month ago.

I did learn something though. What surprised me to no end was the total lack of any reference/debate about computer science research, papers etc. except perhaps pre/post conditions but only in the form of spec#, not in the form of CS research. Almost all the debates focused on tools and their direct techniques, not the computer science behind them. In general asking 'Why' wasn't answered with: "research has shown that..." but with replies which were pointing at techniques, tools and patterns, not the reasoning behind these tools, techniques and patterns. Answering Why with pointing to techniques, tools and patterns is creating a cyclic debate: the Why question is asked to understand the reasoning why some tools/techniques/patterns/practises are used. Pointing back at tools/techniques/patterns/practises isn't going to make you any wiser, as you then only learn tricks, because you can't put any argument on the table why you use pattern X, use technique Y and practise Z.

There's nothing wrong with applying tool T or pattern P to solve a problem you're facing. However if someone asks you why T or P are used, you should be able to answer that question with solid arguments, and not with "T was shiny, open source and l33t and P is used by everyone else in the group".

For example: if you say "You should use the principle of Separation of Concerns (SoC)", what exactly do you mean? It's not as obvious as it sounds. Please read the paper N Degrees of Separation: Multi-Dimensional Separation of Concerns by Tarr, Ossher, Harrison. It's an example how some 'technique' isn't as general usable as you might think: one has to think it through.

That kind of debates weren't on the alt.net mailinglists, they stalled on the level of 'thou shall use SoC", but what it meant exactly wasn't really worked out, as it was apparently assumed that everyone would know what it means. Referring to the paper didn't help, no-one picked it up. This is just an example of what I noticed.

I do think that it's important. I'm not totally finished with how I would call it, but the process looks like some years ago a separate software engineering world has been created (not only on .net, it's much wider) which isn't connected with the computer science world, but instead is focused inwards, looking for answers in the own world instead of in the computer science world: ideas aren't driven by science and research, ideas are driven by what you can do with a tool, with a technique, a pattern. The consequence is that the result of working on that idea has its root in the tool, technique or pattern, not in fundamental research in computer science. This result causes other ideas, which causes other results etc. etc.

Is this bad? I don't know, but if these two worlds drift apart, and the more I think about it, the more this is going on already, the consequences could be severe: the world in which research is taking place isn't feeding the world which applies techniques/tools/patterns with fundamentals, that world of techniques/tools/patterns is feeding themselves with 'fundamentals', which is actually cyclic reasoning: the fundamentals aren't fundamentals, they were the results of applying fundamentals, which doesn't make them fundamental per se.

With this insight, I also understood all of a sudden why there is even an 'alt.net': it's simply a movement which wants to use a different set of techniques/patterns/tools/practises than Microsoft prescribes to its customers via its product catalog. Leaving the lists behind with that in the back of my head wasn't such a loss after all: it's the science which counts, not the technique/tool/pattern/practise. Always keep asking Why, and search for fundamental answers. Only then you'll gain wisdom, instead of just knowledge.

Visual Studio Team System 2008 Team Suite RTM now available on MSDN subscribers

FransBouma — Mon, 19 Nov 2007 09:12:38 GMT

Visual Studio Team System 2008 Team Suite (x86 and x64 WoW) - DVD (English). Date/Time Posted: 2007-11-19 06:46:35 (UTC).

Have fun hammering the MSDN download servers

Alternative Rock

FransBouma — Mon, 08 Oct 2007 09:31:24 GMT

Ever heard the term 'Alternative rock' ? It's a term for rock music which isn't mainstream. Or something. Anyway, read the wikipedia page for the fine print. I'm a metal fan (despite the pile of trance house music I've created in a dark past ) and once in a while I listen to alternative rock to ease the eardrums a little. Every time I do so, I get the same thought: Why is it called alternative?. I mean: isn't it just rock music like all that other rock music?

The reason is that 'alternative' suggests something like 'different from mainstream'. Duh... Beyonce's mainstream pop music is different from Foo Fighters'. So, and now we're arriving at why this is about software and not about music, a movement with the name 'Alt.NET', does that suggest the movement is about 'different from mainstream' too? And if so, what is that mainstream?

In the past months several people, which accidently all happen to be blogging on Codebetter.com, have tried to explain what they personally found the moniker 'Alt.net' stood for. I, as an outsider who wanted to learn what Alt.net stood for and what it would mean to fellow software engineers like me and the .NET community as a whole, did receive different messages from these people: some said it stood for ABC, others said it stood for DEF, and again others said it was XYZ.

The message became blurred, it became unclear what it stood for. Well, one message became clear: if you critisized the people who called themselves 'Alt.NET' about this unclear message, you were in for a lot of flak. I find that a little strange. If you want to change something, you have to have a clear message so everyone out there has a clear understanding what you stand for so potential followers (and that includes myself) could say "yeah, I think they have a point" and join your movement. If you, as a movement, get a response that your message might be a bit unclear, you then should do one thing only: get a clear message. There's no other thing possibly more important. That is, if you want your movement to succeed.

Why?, you wonder? Well, what's the point of having a movement with a mission if no-one really gets the mission statement? Selling an idea is similar to selling a product, mind you: if the potential 'buyer' doesn't get the advantage of what you're selling, why would the potential buyer buy it?

I said a couple of times in the past few months, in blog comments, that I didn't get the Alt.NET movement's mission statement, because, as explained above, it was unclear to me. I got as replies a couple of times that I didn't get it because I pretended that I didn't get it because it would hurt my company. How would that be, if all I ask for is a clear mission statement for the movement so I can decide to jump in or not? Or did I miss something vital about Alt.NET, like they are planning to come up with a free O/R mapper system which could do everything LLBLGen Pro could do? I didn't understand that from the communication put out by the Alt.NET fellows. I also got as replies that of course I didn't get it because I hated Agile and TDD. Err... what? So Alt.NET is about the Agile manifesto and Alt.NET is a church, preaching TDD? All I understood was that Agile and TDD was a common theme among followers of Alt.NET.

In short: I didn't get a good feeling about this movement. Not because of what Alt.NET's mission statement said it stood for, but because of what people around the movement thought it stood for and their friendlyness towards people who apparently weren't in 'the movement'. Apparently, if you didn't find Alt.NET a great thing (I really wished I could say that, but I don't know what it stands for and one shouldn't support something one doesn't understand what it stands for, do you?), you are a person who decided it's wrong, odd, stupid or other negative remark and therefore you should be critisized. Be it through indirect namecalling, low-level insults or other lameness.

I perfectly understand that the people who started Alt.NET, at least a couple, aren't that way and are always open for debates and exchange of thoughts, ideas, simply because debating with arguments gives better ideas and insights, no matter what the other's opinion is. I just find it a bit sad that around the Alt.NET movement, a couple of people find it necessary to behave like a fanatic who sympathizes with a given idea or product. You know, the guys with the "You're either With us or Against us" attitude.

Sam Gentile found it something not worth to be associated with anymore, and I can't blame him, reading his post and adding my own experiences. His post has started a good debate around the blogs and I'd like to link to a couple of them, simply because they discuss some things I mentioned above much better than I do.

First, Jdn's blog entry: Bad Analogy Time: Alt.NET Ex-drinkers.

And as second, Colin Ramsay's blog entry: Abandon ALT.NET. I'd like to quote the 'nail-on-the-head' remark from Colin below:

If they really wanted to change things then they should be writing about their techniques in detail, coming up with introductory guides to DDD, TDD, mocking, creating screencasts, or giving talks at mainstream conferences, or producing tools to make the level of entry to these technologies lower than it is.

Simply brilliantly worded and IMHO a great starting point for the Alt.NET guys (gals?) for their mission statement, at least if they're interested in reaching millions of people of course. Oh, you thought that by having a blog, a place where you can put your personal ramblings, has any relevance in the .NET community? Sorry, but that's not true. There are millions and millions of .NET developers out there. Look around at local user groups and ask who uses unit-testing, who uses an o/r mapper, who uses a code generator, who even understands what inheritance is and what polymorphism can get you? You'll likely stare into blank faces who ask you in return what the heck you're talking about. That is the state of our union, fellow blog readers. If you want to change that, you have to bring a clear, easy to grasp message and it will likely take years before you have any real significant result.

Too many discussions in the blog-o-sphere are never reaching the subjects of these discussions: the average developer who doesn't read blogs and just knows what MS tells them. I think it's a good idea to educate these people of other ideas, and let's start with just ideas. However you only achieve that by having a clear message. Not a cheer of joy that you're 'Alt.NET'. Woohoo...

More on the .NET sourcecode and its 'Reference License'

FransBouma — Fri, 05 Oct 2007 09:13:53 GMT

Today I read an interesting post by Arne Vajhøj in the C# newsgroup. He brought up the point that in the Java research license, which was the license the Java sourcecode was released under before it was released under the GPL, a clause was added to prevent that the reader of the code was 'brandmarked' or 'tainted':

Before Java went GPL there was a Java Research License which allows it.
http://java.net/jrl.csp

Quote:
***
B. Residual Rights. If You examine the Technology after accepting this License and remember anything about it later, You are not "tainted" in a way that would prevent You from creating or contributing to an independent implementation, but this License grants You no rights to Sun's copyrights or patents for use in such an implementation.
***

And FAQ answer from same link:

***
18. Does the JRL prevent me from being able to create an independent open source implementation of the licensed technology?

The JRL is not a tainting license and includes an express 'residual knowledge' clause which says you're not contaminated by things you happen to remember after examining the licensed technology. The JRL allows you to use the source code for the purpose of JRL-related activities but does not prohibit you from working on an independent implementation of the technology afterwards. Obviously, if your intention is to create an ÒindependentÓ implementation of the technology then it is inappropriate to actively study JRL source while working on such an implementation. It is appropriate, however, to allow some decent interval of time (e.g. two weeks) to elapse between working on a project that involves looking at some JRL source code and working on a project that involves creating an independent implementation of the same technology.
***

MS could do something similar.

IMHO, an excellent idea.

Addition: I just remembered something. Microsoft has the policy that a developer of Microsoft (unless excluded from this policy) isn't allowed to look at GPL-ed software. Now, isn't the reason for that policy exactly the same as what I mentioned yesterday in my 'Don't look at the source' post? So, if I have no clue about IP, apparently neither does Microsoft.

Don't look at the sourcecode of .NET licensed under the 'Reference license'

FransBouma — Thu, 04 Oct 2007 09:18:01 GMT

Update: If you think I should be shouting 'awesome' and similar words like most of the .NET community members, please take a walk down the path of 'licenses', something you all should be familiar with in every cell in your body, but by the look of all the different posts about this source release I can only conclude: hardly anyone has any clue whatsoever what licensing, copyright, software patents and related material really mean to a software developer. You didn't really think that by copying a class from the internet you owned the code, did you?

If you do framework development, take my advice and don't look at the .NET 3.5 BCL sourcecode. Using reflector isn't the same, you're then looking at IL being reversed engineered. Looking at sourcecode is different: it has comments, it has other layout, it has real variable names etc. etc. Also, use reflector only when you really have to. Using it is technically breaking the EULA.

Why you shouldn't look at that sourcecode
The reason is simple: software patents. People in the EU, where software patents are, fortunately, still not valid, should still realize that in other countries they do exist, and if you're writing software which could be sold in the US, don't make the mistake your code is liable to this. The jurisprudence on 'reverse engineering' is based on the fact that the people who are allowed to reverse engineer code have never layed eyes on the real code. As soon as they do, they can't reverse engineer the code anymore to their own benefit (whatever that may be, even rewriting code because it's internal in the BCL) because their case would fall outside the jurisprudence: it can be assumed they might have just copied the code instead of reverse engineered it.

Do realize that you're not allowed to rebuild that code, you're not allowed to modify it, copy it etc. You're only allowed to look at it, but also because you're not allowed to copy it, you have to forget what you saw, because if you don't forget it, and borrow the ideas in that code, you likely will step on some patent.

Take for example the new ReaderWriterLockSlim class introduced in .NET 3.5. It's in the System.Threading namespace which will be released in the pack of sourcecode-you-can-look-at. This class is a replacement for the flawed ReaderWriterLock in the current versions of .NET. This new lock is based on a patent, which (I'm told) is developed by Jeffrey Richter and sold to MS. This new class has its weaknesses as well (nothing is perfect). If you want to bend this class to meet your particular locking needs by writing a new one based on the ideas in that class' sourcecode, you're liable for a lawsuit as your code is a derivative work based on a patented class which is available in sourcecode form.

Software patents are evil and the release of this sourcecode doesn't help one bit, on the contrary. If you take your profession seriously, if you are interested in learning ideas about software engineering, instead of looking at that code, read scientific papers and learn from these. Dull crap which is out of touch with reality? Yeah right (just a few examples to get your appetite fired up ).

It's a red herring
Yes, I'm negative about this move. The main reason is that doesn't solve real problems at all. Take for example the case where you detect a bug in the BCL. You plow through the source-you-can't-touch and you'll discover the place where the bug originates and see how to fix it. You can't do a thing about it. You can't fix it yourself because you can't rebuild it. You can only report it back to MS and wait for a fix. Well, dear reader, good luck with that: even if Microsoft is willing to honor your request and patch it in a short time interval (read: month or so), you'll be handed a hotfix you can't distribute to your customers. They individually have to call PSS to get the fix, or you have to hope MS will release it publically which they've done with some fixes but hardly all of them.

Sure, be happy with your shiny sourcecode-you-can't-touch, but it's not something you would want: if Microsoft would have done this for the users of the code, namely the developers, they would have made the license less restrictive, at least that you could re-compile the code to include your own bugfixes till Microsoft would release them themselves.