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.
After half a million lines of code in one year, they can now celebrate half a million hits in one minute!
were you expecting to see a sig here? perhaps you'd rather see the inside of an ambulance!
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
-- Two men say they're Jesus. One of them must be wrong. - Dire Straits
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??
I will bend your mind with my spoon
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.
In a press release issued earlier today, the National Institute of Standards and Technology 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,
Bowie J. Poag
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
-- Dan
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.
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.
Patrick Doyle
I mod down every jackass who puts his moderation policy in his sig. Oh, wait a sec....
1. using a browser redirect is inherently limits the level of security
.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.
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
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
" 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'
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" .
Guns don't kill people; Physics kills people! - John Lithgow as Dick Solomon on Third Rock From The Sun
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
this is my sig.
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.
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?