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.

okay

For one thing it's a quarter million, not a quarter billion, and for another I'm never going to be impressed by a number of lines of code, but by how well it works.

Who to count lines of code?

Who can we measure lines of code? You count, in C, the main(), the includes, the var declaration.

And to extend the code you don't reuse it?

How can we measure codes lines written?

But how many are comments?

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 ?

Re:But how many are comments?

" 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" [amazon.com].

Bah!

I stopped reading when, in the first screen of the dotGNU page, i read:

At the core of Microsoft's .NET is Hailstorm (recently renamed ".NET My Services")

This is simply not true! Hailstorm is only a service that happens to use the .NET framework to do it's stuff. It is a different thing entirely from .NET itself!!!

Andre060

Hmmm

Which amounts to about 5000 lines per week which is phenomenal for any programmer. He is dotGNU's one-man army.

I didn't read the article, so maybe there are more specifics. But um, so what? Are these quality lines of code? Comments? Have they been peer reviewed? Regression tested (you did write test cases before hand, right)? I mean almost any programmer can crank out 5000 lines of crap a week, big deal. If he's producing quality, reasonably bug free code, in this amount, good for him. Otherwise, I'm not so sure I'd be touting this is a big achievement. With one person writing the code, you're only getting one persons views, etc. They're aren't any sanity checks during design decisions or even better, another way of looking at the problem. That's a bad thing in my opinion.

Re:Hmmm

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

Re:Hmmm

This is a question that I face at work all the time.

The reality is that you CAN make use of mediocre programmers too, but you need to be careful.

The gifted programmer can take the lead of any coding that goes on and write the core components. That gifted programmer should also design the layout of the code and properly set up the abstraction of appropriate components. The mediocre programmers can then be assigned some of the easier programming tasks, while the gifted programmer resumes efforts on the more difficult ones.

You'll never get away from having programmers of different skill levels working together. But - every project should have at least one gifted programmer to lead the way. The rest of the programmers can still be useful, and can catch each other's mistakes. They might even catch a mistake in the gifted programmer's code the odd time. When you're coding in a rush, mistakes happen.

The same person looking at the same code over and over again will get used to seeing that code and sometimes silly mistakes might take a while to uncover, because after time it starts to 'look right'. No matter how gifted a programmer is, mistakes happen. It's how efficiently you can find and correct them that counts.

How buggy is it?

Microsoft spends millions of dollars on dozens of programmers to create their .NET runtime and still produces buggy heaps of shit.

How bad could one man's code be?

How maintainable?

Why bother .NET?

I say think crative instead of jumping on the M$ .NET bandwagon. Do we really need .NET or C# on Linux when we got Java and C++? As I see it, both .NET and C# was created by M$ to earn some more bucks for Bill's wallet.

Why not use resources to create better Java sollutions or C++ sollutions instead?

.NET

While .NET and this project are good explorations in new computer coding and interoperability, I still won't use either one. Hell, it's easy enough to get your own computer broken into, but it's only one computer with one set of a person's info in most cases. Why should I entrust info to one giant database of a whole bunch of users, be it free or not? That's about the most inviting target for anyone to crack into. Not only is it supposed to be difficult to get into, but once in, their is ALL KINDS of info to grab!

.NET and all alternatives to it is like putting a naked supermodel alone in a gym full of 16-18 year old boys and telling them not to touch! >:)

half a million lines of code...

After half a million lines of code in one year, they can now celebrate half a million hits in one minute!

quarter billion eh?

250,000 is a quarter million I believe. I guess quality and functionality are a function the amount of code, eh?

Depends on point of view

This reminds me of the old days and IBM's K-Line projects, More lines = more funding but it normaly went like this...

int
main
(
argv
,
*
argc
[
]
)
{
printf
(
"
test
"
)
;
return
(
0
)
}

what you get there is 3 lines of code, but you get paid or in this case credited for 23. Now if you got paid (or for that mater recieved recognition) by the line, which would you right??

Commendations

Though I comment the feat, there are times where I just get tired of seeing the same things over and over again. When did open source become about copying what MS ( an do not I am saying MS not any other organizations) creates. I agree that a lot of technologies out there are things that MS re-packaged and called innovations, but over the last few years, we are increasingly seeing products by MS that are being copied by open source advocates. Examples are .NET (dotGNU) and MS Passport (SUN has a new initiative with AOL and various other companies to counter it). These are just to name a few. I have no issue with this tactic of repackaging MS's work, but I would love to go back to the days and stories of "Hey here is a cool new software/technology that could change things as we know it". Open source should return to leading and not following. It's one of the things that makes Open source great.

- Snowbeam

Quarter Billion?

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

Now the last time I checked, 250,000 was a quarter million, not a quarter billion

How long until Microsoft hires him

Remember the guy who ported Sun's Java code to Linux?
He was hired by Microsoft and was never heard from again.

Hopefully this won't happen again.

Figures?

Well, since he only wrote a quarter million lines of code, I'm guessing the other part of the quarter billion lines must be comments. You know, there is a such thing as too much commenting...

Quantity is job one!

So join him in celebrating his quarter billion lines of his code.

Reminds me of what was presumably Ford's old motto - Quantity is job one!

NIST to rename "millions" unit to "mebibillions"

In a press release issued earlier today, the National Institute of Standards and Technology [nist.gov] has announced that they will be renaming the term "million" to "mebibillions". When asked what prompted the move, an NIST spokesman said, "Initially, it was due to the problem of accurately naming the number of lines of sourcecode some guy wrote for the benefit of RMS' ego. Its just plain silly how much this guy wrote." , later adding, "So, we came to a consensus within the organization that a revision to the basic units of measurement should be made, so it looks like we're busy so we don't lose our funding. In addition, we feel that marketing people should always determine standards, not the engineers and scientists who actually know what they're doing. Its just good sense." Beginning January 1st, the new "mebibillions" unit will take affect.

Mebibillions of people are expected to shake their heads in disbelief at the NIST's continuined stupidity.

:)
Cheers,

Great

While he has indeed been writing large amounts of code, and fine code it is, his little joke is that all of his comments are written in Engrish [engrish.com]

Ok, maybe you won't like this but..

This is no way a defence for MS, and even if it was, i do not think that that would make me an evil developer.
Ok, so did you take a look at the .NET framework ? When compared to Win32 API it'a very big step forward for the developers who make money from Windows programming. I'd really like to hear comments of some programmers who has worked with J2EE and Java. Implementing something like MS passport may be a security problem, and i agree about it.But why most of the guys like to flame about what MS is doing with .NET technology, and totally ignore the technical framework these ideas are built on ? .NET framework, and C# are clearly superior to former MS software, and apart from being created by a monopoly they seem pretty good to me. If someone with o strong technical background and experience, would comment on why C# and/or .NET framework is evil, i'd read it with, and learn from it. Having C# and .NET Framework on Linux would be fine. Please try to explain why you don't need a good programming language and a proggramming api on linux ? or why it is bad. Do you think that MS is after money and Sun and Oracle are after something else ?

Difference/Cooperatio between DotGNU/PNet and Mono

Does anybody know how the two projects compare/cooperate? Both projects seem fairly active and doing very good work. I had assumed that Mono would be that part of DotGNU that provided the C# Compiler, Runtime and standard Libraries. But it seems that DotGNU also makes these parts with their portable net (PNet) together with their "Hailsorm" replacement.

The Mono project seems to be only interested in the C# language/compiler and runtime environment.

It is also interesting that the DotGNU project seems to have put a little more thought into the licensing issue. And in particular what it means to be a derived work (check their FAQ) in the new dynamic code environment that .NET brings us.

Even though they are a GNU project they do not not use the ordinary GPL or the LGPL for their work but a GPL plus exception as also is used with GCC. This makes it possible to create derived works (in embedded devices for example where everything is linked together because you don't have a shared library loader) that with "normal" LGPL would be considered derived works.

Which is strange if you think about it. Ximian which sponsors Mono makes use of a more agressive copyleft then the 'regular' GNU project. Which means that if Mono "wins" then we will have more (forced/copylefted) free software then when the GNU project "wins". Never thought that a commercial company would be more agressive about copyleft then the GNU project.

Does anybody have more information about the why/how of the two (competing?) projects?
The DotGNU website and the Mono website don't seem to talk about the other project even though it is obvious that they are doing the same sort of thing.

Here are the main differences

Mono is more full-featured than DotGNU in a number of important ways:

- Mono has a nearly fully functional VM with Jit.
- DotGNU has no VM at all
- Mono nearly has a c# compiler written in c#.
- DotGNU intends to use gcc and a C compiled C# compiler.
- Mono has more than 60% of the class libraries written
- DotGNU has only a fraction of classes written.
- Mono is much better coordinated and has better public relations thanks to Miguel
- Mono has regression analysis scripts
- As far as I can tell Mono has better i18n support

Problems with Mono:

- no garbage collection
- initially hosted via Microsoft's .NET system until it is able to be self-hosted

Mono unknowns:

- will it depend on Gtk/GNOME?

Ximian?

So how does Ximian's Mono [go-mono.com] project fit into this?

254,423 ????

I find that hard to believe, but if so I just have one question:

How much did he document? I seriously doubt it's well documented, especially considering a) it's open source and b) it's one guy doing it.

There is nothing worse than undocumented source.

Benefit of the doubt?

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.

code looks good

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

Congrats

Congratulations on the code. Hope that you continue on your quest. I know that there's many comments already posted about how the it's not much of an achievement.
Nevertheless, a quarter million lines is more code than the trollers above have ever written.
Hopefully the software will provide for a better base for us.
Thank you

Wait and See

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

oops

in NEWS: * Fix the code section determination logic in "_ILImageGetSection" because Microsoft has re-ordered the IL sections in such a way that it broke my previous code.

MS: Welcome to Microsoft!

in libgc/doc/README.win32: It is likely that some of these have been broken in the meantime. Patches are appreciated.

MS: No problem!

Sorry j/k, no offense. :)

A quarter million and counting

Cool! now the project is a quarter million lines on lenght. On the quest of perfection, I truly hope that they reach the 200k lines milestone on time. The project could be declared done when it consists of 100,000 lines.

Component name

Portable .NET sounds like a lawsuit waiting to happen.

Ah, the portable .NET

Ooooh, let's give those lamer moderators a big ol' present this Boxing Day: I got points to burn, guys.

Microsoft once again leads the way for Linux. Amazing, isn't it, how many Linux projects are simply clones of existing Microsoft software.

Need a word processor? Get a Word clone. Need a flowchart tool? Get a Visio clone. Need a vector illustrator? Get an Illustrator clone. Can't find a clone? Run WINE and use the original!

For a community that loathes Microsoft, there certainly seems to be a lot of effort to re-create Windows and Windows apps.

Damn, that's a lot of platforms!

"The project true to its name runs on a variety of platform including Linux,Hurd and Cygwin GNU systems."

Wow! Linux, Hurd *and* GNU systems? Does it work on Tru64 with the GNU tools? How about AIX with GNU tools? Solaris with GNU?

Contrast that with Microsoft. MS Office, for example, only runs on two platforms: Windows 95/98/XP/ME/NT/2k and MacOS.

Rock on, dotDudes!

copy/paste

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.

It's amazing what a man can do with copy & paste...

Give him the benefit of the doubt

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.

slow news day?

um...isn't there anything else going on in the world?!

One guy writes 5k lines of code a week...and this is newsworthy because....

The actual count: 149,367

Which is still a fuckload of code. I used sloccount, which is not perfect, but is a pretty informative tool none the less.

./sloccount /tmp/pnet/pnet-0.2.6

Totals grouped by language (dominant language first)
ansic: 121564 (81.39%)
sh: 17160 (11.49%)
yacc: 5634 (3.77%)
lex: 2091 (1.40%)
asm: 1937 (1.30%)
cpp: 961 (0.64%)
exp: 20 (0.01%)

Total Physical Source Lines of Code (SLOC) = 149,367
Development Effort Estimate, Person-Years = 38.37
Schedule Estimate, Years = 2.14
Estimated Average Number of Developers = 17.92
Total Estimated Cost to Develop = $ 5,183,332

It appears that the damn lameness filter is preventing me from posting this, so i have trimmed the output a bit.

Re:The actual count: 149,367

I should have posted a link to the tool which can be found at: http://www.dwheeler.com/sloccount/ [dwheeler.com].

This tool basically counts phsysical lines of code (non comments or whitespace) and produces cost and schedule estimates on this count using the standard COCOMO model.

Hold on there sparky, get your numbers right

"So join him in celebrating his quarter billion lines of his code."

Don't you mean quarter million? If he programed at this rate for 1000 years he'd be at a quarter billion. Now *THAT* would be something! :) Just kidding, kudos to Rhys.

Writing that much code by hand is a waste of time

You can easily crank out as many lines of code as you want using automatic code generation. That will leave more time to spend with your family and friends. Here's how to generate 1 million lines of code in just a few seconds:

#!/usr/bin/python
print "#!/usr/bin/python"
print "h = open('/dev/null', 'w')"
print "for x in range(1, 1000000):"
print " h.write('All work and no play makes Jack a dull boy.\\n')"

I'll leave it to others to debate the utility of my program vs. recreating the .NET framework :).

5000 lines per week - - IMPRESSIVE!!!

As the poster indicates, the rate at which Weatherly writes code is nothing less that phenomenal.

To provide further perspective on this impressively rapid rate of coding, I have done some rather rudimentary calculations. All of the figures below proceed with the assumption of a 5-day, 40-hour workweek (which we all know is unrealistic in the world of programming, but for the sake of simple stats it seemed appropriate):

Lines/Month = 21,201.9
Lines/Week = 4,988.6
Lines/Day = 997.7
Lines/Hour = 124.7
Lines/Minute = 2.0

How impressive is that...WOW!!! To think that this man averaged two lines of code per minute throughout the period of an entire year is nothing less than astonishing!!! Of course, these figures are a bit skewed by the means through which I calculated them, but nonetheless, this is quite an accomplishment...

My sincere congratulations and compliments!!!

-n2q

I just don't get it

I just don't understand the dislike of the people involved in the Mono project of anything Java. The people involved in the Mono project already know that they won't be able to produce a fully compliant version of .NET because Microsoft won't release complete specs or a test suite. Functionally, C# and .NET offer no huge improvements over Java and the Java platform.

Now, what about Java? We have open source compilers (e.g., the KOPI kjc compiler), several runtimes (including the ORP runtime, which is quite good), and an open source batch compiler that allows exceptionally easy integration of C++ and Java (GNU gcj). We have lots of open source libraries in Java, more than 100 other language frontends, JNI interface generators (swig), XML libraries, web servers, and lots of tools. Unlike .NET, the Java platform is specified in great detail, with conformance test suites available (in comparison, Microsoft's ECMA submission is a publicity stunt with little real value). The few nice convenience features that C# and .NET have compared to Java could have been added as extensions to Java and its runtime as part of a GNU Java desktop project if people really felt they were necessary. GCC already has a frontend for Java that integrates very nicely with C++, giving developers a migration path from existing C++ code and allowing them to create stand-alone UNIX-style executables. And, unlike C#, Java is very widely taught in schools and at universities and very widely used in industry. And all that Java stuff was available in open source form a couple of years ago already.

Mono just strikes me as a serious case of NIH and people going off wanting to have fun with various new software toys. Well, that's OK, I suppose, it just isn't very utilitarian. OTOH, if this is the route by which Linux programmers finally move to languages and environments that are safe and support component-based software construction, I suppose it's better late than never.

But while .NET won't go away entirely, I believe Java still has the much brighter future, both in industry and in the open source community. You have a handful of open source programmers working impressively and very hard on Mono, but that still pales in comparison to probably thousands of active open source Java developers.

Wow.

So join him in celebrating his quarter billion lines of his code.

If any one person wrote a quarter billion lines of code, I'd be thorougly impressed. I doubt anyone writes that much in their entire lifetime. What was Windows 98? Something like 40,000,000? So a quarter billion would be like writing Windows 98 five times, from scratch. That would be something else.

What he did write was a quarter million lines of code. Still impressive, very much so, but not quite the legend that 0.25 billion would be.

Anyway. I say Congratulations! to him, because that's a lot of hard work, and it takes a lot of dedication to do what he did, especially for such an extended period of time.

Let's lay down the terms here

We must be careful not to lump all of the things under the Microsoft .NET umbrella together. For a moment, replace ".NET" with "Win32" and re-examine what you are saying, and what Microsoft is going on about.

For you see, ".NET" is really just a programming platform. Take everything that Windows can do, then wrap it in an object-oriented system, then subtract all the things that suck about Java. That is what .NET means to me.

Passport.NET/Hailstorm/etc are just services available to programmers and users that are written with .NET

I can surely write my own Passport-esque system and expose my web services just as passport does. Then you can use my system instead of Microsoft's.

All of this is on top of the fact that VisualStudio.NET is an entirely different beast from the platform/runtime and the services. There again, I can write my own language that compiles to the .NET runtime and have it integrate with VS.NET as smoothly as C# does. The Perl.NET download from ActiveState is quite tastey.

Bottom line -- Make it clear to what you are referring:

Platform: Common Language Runtime. Includes Microsoft-IL and set of standard System objects.

Services: Passport/Hailstorm and other webservices. Can be provided by Microsoft or anyone with a webserver running the CLR (or you can write it all up by hand, but it is much easier with the CLR because it was built with that in mind.)

IDE: Integrated Development Environment, VisualStudio.NET; has facilities for 3rd party systems to plug in and be treated as 1st class languages just like VB.NET/C#. Compiles apps for the CLR, and has additional publishing features and tools for developers.

wow!

I hope 4000 lines of that is comments (per week). Otherwise I'm petrified.

why are we bickering about how many lines of code?

my questions are:
does it work?
is it buggy?
how reliable is it?
in my opinion well commented code is just as important as the code itself.
what good is code that noone knows anything about except the author?
//comments are a good thing
/* lets not criticize them */

A quarter million lines?

All discusion on quality versus quantity aside, anyone who appriciates what he's trying to do should donate some money towards an ergonomic workstation for this poor guy...

Interesting

People bitch about Win2k reaching 40 million lines of code. But when it's an open-source project, all of a sudden bloated software is something to take pride in...

kLOCs... (1000 Lines Of Code)...

A wiseman once