Portable .NET Reaches A Quarter Million Lines

Pnet Guy writes: "Portable .NET is a component of the dotGNU meta project to provide a CLI (ECMA standard) platform for free software. The project true to its name runs on a variety of platform including Linux,Hurd and Cygwin GNU systems. To avoid any legal problems Pnet has decided to go the hard way and bootstrap our compiler off gcc. Unlike Mono which uses microsoft's runtime to run their compiler. Our premier developer Rhys Weatherly has contributed 254,423 lines written since Jan 1, 2001. Which amounts to about 5000 lines per week which is phenomenal for any programmer. He is dotGNU's one-man army. So join him in celebrating his quarter billion lines of his code." Update: 12/27 02:41 GMT by T : Note that as many readers have pointed out, that's just like the headline says -- a quarter million lines, rather than billion. Some related links to check out include the dotGNU home page, the Southern Storm Software (Rhys Weatherley's shop, with Portable .NET information), Mono's page and Pnet's CVS repository.

Comments

Re:Hmmm

[medcalf]

I am not convinced that a lot of mediocre programmers acting with software engineering tools and methods are any better than one gifted programmer acting alone. In fact, in my experience, the reverse is true. One person can bring a visionary piece of code forward, which can be refined over time. A group can spread the risk and potentially produce a less-buggy first cut, but cannot truly innovate, because any group automatically dumbs down. Unless everyone in the group is fantastic - a long shot bet if I've ever seen one - the result will be mediocre code.

-jeff

Benefit of the doubt?

[p3d0]

Of course, everyone and their dog had the typical knee-jerk "lines of code mean nothing" reaction. Well, duh, that goes without saying. I can't believe how many mod points have been wasted on that sentiment.

How about we give this guy the benefit of the doubt and assume he knows what he's doing. Then what we have is a tremendous contribution to the free software community. I, for one, say thanks and keep up the good work.

And, if it gets released and is full of bugs, then let's beat the old lines-mean-nothing horse to death.

Wait and See

[f00zbll]

I've been following the development of .NET a little and the only thing I don't like about .NET is the architecture is flawed. According to the official .NET passport white paper http://www.microsoft.com/myservices/passport/Secur ity.doc, the E-commerce server redirects the user's browser to Microsoft's .NET server. Now that may seem fine on the surface, there are several flaws to this way of thinking.

1. using a browser redirect is inherently limits the level of security
2. any transfer of sensitive information between companies should rely on encryption stronger than 128 SSL
3. using browser redirects means using GET, instead of POST
4. storing user information in plain text as others have mentioned is simply wrong
5. the trust relationship should be two way, not one as stated in microsoft's whitepaper.

Anyone can make RPC fast by limiting security and encryption, which is exactly what .NET does in the current form. Any business foolish enough to implement .NET as microsoft prescribes can say good bye to my business. .NET could really be useful and ground breaking, but it is far from enterprise level in terms of reliability, scalability and security. Microsoft's white paper is devoid of specific details about how .NET servers should be clustered for fail-over, state replication/management, load-balancing, using server-to-server authentication and profile retrieval, and security monitoring.

All these little details are needed for real enterprise applications. Without it, it is just begging for trouble. It's great that dotGNU has made so much progress, but perhaps they should have gone a step further than they have http://www.dotgnu.org/web-services.html. dotGNU makes some great points about weaknesses/flaws in .NET, but they still don't go further to really provide a complete solution. The solutions proposed by the dotGNU web services page still fails to address alot of important issues.

IMNHO

Re:But how many are comments?

[Zero__Kelvin]

" Well commented code can end up with quite a high percentage of the code base as commments.

I once wrote a 'small' 150k line util. Before I left the company, I was asked to comment it, after decent amounts (ie, more than '// perform the calculation') of comments, the line count was around 230k.

So how many of the quarter million are comments then ?"

You seem to be implying that in order to determine if the code is good, and represents a lot of work, you need to know the comment to statement ratio, which is true. However, you also seem to be implying that if there are lots of comments then there is less 'actual code'... and that it therefore represents less 'actual work' ... which is very far off base, as your former employer seems to have recognized, though perhaps almost too late. (apologies if I inferred incorrectly.)

If there is a high degree of commenting this is both good, and represents lots of work on the part of the programmer, assuming of course that the comments are good, accurate, and add value to the product in terms of maintainability.

One of the main reason why the Linux kernel is robust code, but remains an example of extremely bad Software Engineering is that it is poorly commented, when at all.

Remember this fundamental maxim of good Software Engineering practice:

Good source code is compileable documentation" - Zero__Kelvin

It can compile, run robustly, and be very 'un-buggy', but that doesn't make it good source code. Until programmers really grasp this they will never become competant Software Engineers! Those who question this wisdom may want to start educating themselves with a thorough and open-minded reading of Fredrick Brooks' "The Mythical Man Month" .

code looks good

[jon_c]

The second i read about the x lines of code i also wondered if the code way any good, so instead of mouthing off about how x lines of code doesn't matter, it's the quality, I decided to download some of it and check it out for myself.

While I did not go through it extremely carefully, I did read through a few functions, and got an idea of how the programmer thought about things. It seems that the code is pretty tight. It's defiantly not compressed, but it is well modularized and well commented and that's more then I can say about a lot of code that I've seen.

My guess is that this man is a seasoned coder who is very driven, and I applauded his work.

-Jon

Give him the benefit of the doubt

[dgb2n]

Assuming an 8 hour workday, 5 days a week (yes, I know he works more than that), that translates to:

125 lines of code per hour
more than 2 lines of code per minute

That's not including coffee breaks, restroom time, foosball, or anything else I need to remain coherent to write code.

5000 lines of code per week over an extended period is a stunning achievement. Give the guy a break.