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.
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
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
I am Lord Snowbeam. Heed my call!
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
DJ kRYPT's Free MP3s!
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....
What you describe is the common configuration, where one developer becomes a code primadonna. He (or she) will be the only one who really understands the system and everyone else just try to work around the primadonna and avoid getting in his or hers way. This is very bad because
1. You become *way* to dependent on the primadonna.
2. You don't get near full benefit of the rest of the team.
3. You will get a high staff turn-over because noone can tolerate a primadonna in the long run.
If you have a small to medium sized team (\10 developers) processes like XP will keep your developers producing quality code fast and happy at the same time.
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
If the open source community implements the .Net CLR/IL and C#, it opens the doors for currently MS-exclusive developers to cross over much more easily than they currently can. Think of a VB developer considering Unix/Apache/Perl/Java - pretty damn intimidating, no? Now think of that same VB developer looking at Unix/Apache/C#/.GNU - still intimidating, but now he can leverage his current knowledge to ease the transition.
.GNU is porting the Win32 API or VB.
Remember, these are all ECMA standards now; it's not like
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.
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
Beer is proof that God loves us and wants us to be happy. -- Benjamin Franklin
Sun's decision had nothing to do with open source. Sun apparently felt that it was necessary to standardize the entire Java platform in order to be useful, and they felt they couldn't do that under ISO's or ECMA's conditions yet.
Microsoft got EMCA approval for C# and its libraries
Microsoft submitted a tiny fraction of the C# libraries for standardization. That isn't comparable to what Sun was doing. What Microsoft did cost them nothing in terms of control or intellectual property, but it was a great publicity stunt.
Sun where you only have a voice if you are a large computer firm that pays $250,000 per year to be heard/ignored in the poorly named "Java Community Process".
Who cares? You don't have to hack Sun's Java. You can hack an open source Java compiler and an open source Java runtime. To go off and start from scratch doing a partial clone of an incompletely specified Microsoft platform instead is throwing out the baby with the bathwater. Mono could be producing a fully backwards compatible, open source system based on Java with any enhancements they like, instead of whining about the JCP.
The CLR VM is also far more advanced than the Java VM from a technical point of view
You have fallen prey to Microsoft propaganda. I have seen no substantial technical enhancements in the CLR over the JVM (although there are a bunch of nice convenience features). And while Microsoft's CLR implementation also has some good parts, it is not as good as Sun's JVM.
and can more efficiently host non garbage collecting languages.
You can only efficiently support manual storage management if you are willing to sacrifice runtime safety. This has been beaten to death in the literature and in practical experiments, and the tradeoff isn't worth it. Just look at the recent experience with garbage collection in gcc to see that manual storage management is both less efficient and more error prone. (Incidentally, C and C++ semantics permit garbage collection, they just don't require it.)
CLR supports delegates which the Java VM has no equivalent.
That's a red herring. You can implement delegates efficiently without changes to the JVM. In fact, Sun considered doing this, but decided to go with nested classes instead. (As an aside, Microsoft's "delegates" have nothing to do with what is commonly understood by "delegates" in the OO literature.)
C# is simply more elegant than Java in a number of ways (such as automatically boxing builtin types for collections,
Automatic boxing/unboxing is an engineering tradeoff, not a question of elegance. Providing it makes it much easier to create performance bottlenecks accidentally. Neither Sun's nor Microsoft's choice is obviously better--it's more a question of psychology than technology.
The most important point is that Microsoft knows how to develop a polished piece of software.
Even if that were true (and I find the claim pretty ridiculous), what possible relevance does it have for Mono, since Mono isn't being developed by Microsoft?
Microsoft has not released a free CLR implementaion for other platforms, and what they have promised (if it ever arrives) is going to be a low-end implementation. Sun has released a high-performance implementation for Windows, Solaris, and Linux, with other platforms based on Sun's code.
Remember until the Sun/Microsoft Java lawsuit that it was Microsoft that had the fastest Java Virtual Machine - not Sun.
That's a myth. The Microsoft Java VM cut lots of corners, sacrificing compliance and safety, and a prerelease version was at some point faster than a delayed update of the JDK. Microsoft lost that temporary lead independent of the Sun lawsuit.
First to market does not necessarily win the race. Sorry, Sun, better luck next time.
Java has already has won the race; it's not going away (and Java wasn't first to market either--both Java and C#/CLR are based on about two decades of experience with other languages). The question is why Mono is getting in bed with Microsoft and picking the runner-up. Sun's support for open source may not be perfect but it has been quite good. Microsoft, however, has declared its fundamental hostility and opposition to open source efforts, and Microsoft, so far, has provided essentially nothing to anybody.
"We are software developers. We don't read documentation. We don't write documentation."
:)
(Scott Meyers)
Do not take this to seriously!