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.
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.
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 ?
At the core of Microsoft's
This is simply not true! Hailstorm is only a service that happens to use the
Andre060
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.
there are no stupid questions, but there are a lot of inquisitive idiots
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?
Conformity is the jailer of freedom and enemy of growth. -JFK
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!
With that type of attitude, the words could be said..
Do we really need C++ (or ) why not create better Cobol sollutions instead?
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
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!
That was my first reaction when I read the headline. I've seen many examples of developers not properly abstracting their code, and instead of making general-purpose functions which can be used over and over again, the code may be littered with a dozen variations of the same function. Or perhaps having similar code in one routine executing over and over again rather than being in a function where it belongs in the first place.
If this code is produced in a rush and hasn't been thought out properly (and if you're alone working at this kind of pace this probably is the case), then I'm afraid to see what this code looks like.
I'm willing to bet that this is the case to some degree, because with only one person working on it there is no peer review to catch this sort of thing, and the emphasis will always be to get the program to 'just work', not to keep the code clean.
I know when I'm the only person working on something it takes a *lot* of discipline to keep the code clean and maintainable. In the back of your mind you figure that since you'll be maintaining it, it doesn't matter how it looks. Well... looking at your code in 6 months, you'll have no idea why you did things that way and why it works. Hopefully the code is at least commented to give him a clue.
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
Well, actually, the world might be a better place if more programs were still being written in Cobol. :) It's not nearly as powerful a general-purpose language as C++, but it was (and is, considering how many Cobol programs are still in use) very very good at what it did for specific applications.
But. This is a completely different situation from C vs. Cobol, or C++ vs. C, or Java vs. C++, or whatever. This is about people buying into a closed, proprietary application framework put out by a viciously monopolistic company with a history of creating terrible software, when those same people have talents which could be put to work making open-source software which is already quite good even better. Imagine what a dreary place the world would be today if Linus (or maybe a better comparison is the original BSD team) had decided to drop this whole free-Unix-clone idea in favor of making clones of MS-DOS.
The correlation between ignorance of statistics and using "correlation is not causation" as an argument is close to 1.
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
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. .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 ?
Ok, so did you take a look at the
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.
...is the Portable.NET project really measuring their progress in SLOC? I doubt it. So, if you're not measuring your progress that way, then you're in little danger of creating code just to augment the SLOC, which is the primary drawback of using SLOC to measure progress. I see little harm in pointing out the SLOC just to make the project a bit more visible. The visibility ought to be good for their egos, and by extension, the project.
.NET CLR coverage they're going to provide.
I agree that function points could be a good measure of progress, but I would like to see a graphical chart of API progress instead. I'm more curious about how much full
Please mod this post only if you think others should/n't read this. I have enough ego^H^H^Hkarma. Thanks!
Well, yeah ... make it truly POSIX-compliant (not the pseudo POSIX-compliance M$ put into Windows NT to meet gov't requirements, but something more on the level of what the BeOS had) and "OpenAmiga" would have been a hit, the Linux of its time. But that's kind of my point. An open-source MS-DOS clone (and of course there were some pretty good competing DOS's) would have been interesting, but not all that useful, and ultimately wouldn't have hurt M$ one bit. And I see open-source .NET clones as the modern-day equivalent of that sort of effort. I'd rather see talented Linux developers putting their time into Linux-y things that might help dislodge Windows' desktop dominance, not playing catch-up with Microsoft products that are pretty much guaranteed to be crap anyway.
The correlation between ignorance of statistics and using "correlation is not causation" as an argument is close to 1.
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.
Why is this a different situation? Like you said Cobol is very, very good at what it does for specific applications, why can't something else be very, very good for another application. Instead of trying to force everything in to Java/C/Cobol/Snobol/Pascal/etc if it works really good than use it, especially so if people have written opensource tools for it.
And not to rain on the parade too much but all your closed, proprietary, statements could also be stated by the Java holders Sun.
Imagine what a pain it would be if the Samba developers had decided to not make clones of windows file sharing utility, and everyone had to run PC-NFS.
And not because OS again copies a big industry player. It's good because it will help keep Microsoft honest about the open-ness of .NET.
.NET. They'd be stupid not to do so.
It will make the ever so elegant C# language portable, which I'm really looking forward to as I never fell in love with Java as a language.
Furthermore, at least in the Microsoft IT world, C# is it. If you're not learning C#, you're so much refuse in the new paradigm. Giving the burgeoning C# pool of programmers portability options will definitely help keep Microsoft in their place.
Oh, and keep your eye on the likes of IBM and Sun: Odds are good that they'll support an independent implementation of
Please mod this post only if you think others should/n't read this. I have enough ego^H^H^Hkarma. Thanks!
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
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.
Exactly.... I can write 250,000 simicolons pretty fast, too.
Simicolons?
Are those supposed to be binary semicolons, the same way that "mebibytes" are supposed to be binary megabytes?
(Couldn't resist...)
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.
--
Don't like it? Respond with words, not karma.
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
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!
324006
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.
#!/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 :).
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
for x in range (1, 1000000):
print "h.write...
Comment removed based on user account deletion
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.
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.
.NET means to me.
.NET
.NET runtime and have it integrate with VS.NET as smoothly as C# does. The Perl.NET download from ActiveState is quite tastey.
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
Passport.NET/Hailstorm/etc are just services available to programmers and users that are written with
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
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.
Natural != (nontoxic || beneficial)
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?
1 Metric Billion (or US Trillion):
- 10^12 - a million million
1 American Billion:
- 10^9 or a thousand million in English.
1 Metric Trillion: - 10^18 - a million billion
God this is confusing...
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 */
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.
Do you mind taking a pick on Linux source and tell me exactly where you are counting those 0.5 million LOC vs. 35 millions of Win2K?
I can assure you that Win2K kernel is much smaller than Linux's kernel.
For a start, it's Linux who uses the monolithic design, while Win2K uses a modified micro-kernel design.
When MS talks about Win2K being 35MLOC, they are talking about the whole thing. And this contain so many things beside a kernel that I can't begin to count.
But please tell me, what is the sum in KLOC of the following products?
Linux kernel
KDE
KDE-Parts (equilent to Windows' COM, does it support language and location trasperancy? If no, add CORBA, which does)
Mozilla
Apache
perl & python
J2EE implementation
Basic applications (text editor, word processor, image editor, etc)
Networking stack
Printing services
And the list goes on...
--
Two witches watched two watches.
Which witch watched which watch?
First of all, C# *is* (IMO anyway) elegant. I like it. Elegance is a matter of opinion anyway. I don't like LISP, I never did, and yes, I have used it. Is its syntax more elegant than Java or C#? Yes; sort of. But do I care about LISP? Not really. I may take an interest in it one day, but not today.
Now that aside... you used one language feature as an example to promote Java's superiority. ONE feature! Look at http://www.25hoursaday.com/CsharpVsJava.html for a more complete comparison. There's about 20 features in C# that Java doesn't have, so is C# immediately superior because of that? Maybe so, maybe not but I won't be making that decision based on ONE language feature.
Now all *that* aside: Use the right tool for the job. I assert that C# and Java will be used for essentially different types of jobs for the immediate future. Sun/IBM did indeed get a jump on Microsoft with Java, but that won't mean much over the long haul.
Last point: Have the proverbial balls to post as something other than AC when you decide to flame. If you'd thought your opinion was worth sh*t, you might have taken the effort to express yourself more effectively; as it was you did it half-assed, and it shows.
Please mod this post only if you think others should/n't read this. I have enough ego^H^H^Hkarma. Thanks!
Why don't you learn about patterns and figure out how to implement "Microsoft delegates" using standard object-oriented techniques (hint: because Microsoft language designers apparently didn't know their OOP basics, "MS delegates" are different from what is commonly called a "delegate", but there are other patterns corresponding to it.)
Please continue wrapping and unwrapping your Java builtin types by hand and write hundreds of lines of mind-numbingly tedious and error-prone code and all the time remind yourself what a noble pursuit it is - because your code is 100% Java(tm).
I don't have such a problem. The JVM supports more than 100 language frontends already. Some of those box/unbox automatically, others don't. They all work together very nicely in a way that is still just vaporware for CLR.
Deflect the point that Sun (a commercial entity) is the sole OWNER of Java and may choose to charge for its now supposedly "free" Java runtime
Who cares? There are open source Java compilers and runtimes that are a lot further along at implementing all of Java than Mono is at implementing C#/CLI/.NET. The fact that Sun makes available a good implementation is an added bonus.
Suckers like you will be left with your mouths gaping wide open asking "Why did Sun lie to us again?".
I have been using UNIX since 1980 and I have never had a problem with Sun's policies. They have contributed more to open source than most other companies. The "suckers" seem to me to be the ones who, after a decade of hardball Microsoft tactics and low-quality Microsoft software, still believe that Microsoft is up to any good.
Do yourself a favor and support an LGPLed standards-based Open Source effort like Mono to ensure software will be free both now and in the future.
If Mono ever gets up to the level of quality of Java, sure, I will consider it. The way it looks right now, that will be many, many years off, and any contributions to it seem like a waste of time. And if the history of the Gnome project is any guide, the people working on Mono will abandon it before it matures anyway.
Microsoft submitted a tiny fraction of the C# libraries for standardization.
.NET framework, yes, only parts (The CLI and CLR?) got submitted to the ECMA. Of course, what good would GDI wrappers be for *nix users anyway?
Actually, C# doesn't have any libraries. It is a language and it was submitted in its entirety. As far as the
There is no longer anything that can be done with computers that is nontrivial and clearly legal. -- Paul Phillips
We do not add C# to GCC. we're writing a whole compiler (cscc) , compiler-compiler (treecc) and a portable VM (It runs on Cygwin !).
Adding C# to GCC is more work than writing a whole compiler (scanner/parser/optimizer).
Also Mono will have a lot of problems as their compiler is *not* self hosting. Ours are .
Quidquid latine dictum sit, altum videtur
It's ANSI C.
If it's this long, then it's not a suitable implementation
language.
He should have used a more capable language (read C++)
and avoid rewriting and copy/pasting the whole world
including data structures.
To understand how big code is written: www.kde.org
--exa--
So, Mister Anonymous Coward, are you then an actual member of the Mono development effort? Is everybody on the Mono project as uninformed as you, or are you special?
Calm down, I also read the error-filled Sun/AlJazeera co-sponsored whitepaper on the evils of Microsoft delegates.
Gee, I haven't. In fact, the only stuff from Sun I ever look at is their API and JVM documentation, just like the only stuff from Microsoft I have looked at is their technical documentation on C# and the CLR. Do you spend all your time looking at white papers? No wonder you are so excited about C#/CLR: Microsoft has a lot of marketing experience.
How can you argue with that simplicity and efficiency?
I didn't say "MS delegates" were bad, I merely pointed out that Microsoft misnamed them. And if people writing a Java-based Mono project felt that they were important, they could have added them. As it turns out, in real life, Sun's alternative is just as good. But how would you know?
I would wager that you are reading this post this from a Windows-based browser (don't worry - your secret is safe with me).
Mozilla on Linux, actually. My job from time to time requires me to port to, and use, Windows. So, unfortunately, I have first-hand experience with the platform and its libraries.
But my point isn't that C# is superior to Java or vice versa. To make that point, I would need to argue that point more effectively. My main point in that posting was that I would not be selecting Java over C# or vice versa based on one language feature. In fact, I think that the language features between the two are going to be largely irrelevant going forward. I do think that corporate culture will be VERY relevant going forward though. If your company is a "Microsoft shop" then C# or another .NET language will be the ticket. If your company is an "IBM shop" or "Java shop" or "multivendor", you'll probably use Java for those big projects. I may preach to use the "right tool for the job", but the reality is that decision is usually not made on technical grounds.
.NET is a good thing and I stick by that.
As far as my real opinion on Java vs. C#: I don't even care. I'll let other people obsess over that; and I'll eat their lunch while they're doing it.
Anyway, none of this really matters. My original and most important point was that having a non-MS implementation of
Please mod this post only if you think others should/n't read this. I have enough ego^H^H^Hkarma. Thanks!