Slashdot Mirror
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.
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.
You can accomplish anything you set your mind to. The impossible just takes a little longer.
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.
.NET brings us.
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
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.
Which is still a fuckload of code. I used sloccount, which is not perfect, but is a pretty informative tool none the less.
/tmp/pnet/pnet-0.2.6
./sloccount
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.
Mono is more full-featured than DotGNU in a number of important ways:
.NET system until it is able to be self-hosted
- 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
Mono unknowns:
- will it depend on Gtk/GNOME?