Slashdot is powered by your submissions, so send in your scoop


Forgot your password?
Check out the new SourceForge HTML5 internet speed test! No Flash necessary and runs on all devices. ×
GNU is Not Unix

Portable .NET Reaches A Quarter Million Lines 303

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 discussion has been archived. No new comments can be posted.

Portable .NET Reaches A Quarter Million Lines

Comments Filter:
  • okay (Score:2, Redundant)

    by ceswiedler ( 165311 )
    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.
    • Re:okay (Score:1, Interesting)

      by nate.sammons ( 22484 )
      Exactly.... I can write 250,000 simicolons pretty fast, too.

      Not to mention that anyone who thinks that writing an open implementation of .NET will damage Microsoft in any way is kidding themselves. And let's face facts here: what's good for Microsoft is bad for Linux. Period.

      Why not spend your time improving the threading implementation on Linux, for one thing? Java on Linux is one thing that has a chance in hell of defeating the Microsoft juggernaut. Ever done thread programming in C or C++? It sucks ass -- try it in Java and you'll see how clean a language *can* be if you think it out. Sure, Java's got some problems -- GUIs for one thing are a tad slow (though not bad on fast machines), but on the server, Java is king.

      Look at what .NET and C# want to be, and you'll see Java staring back at you. And Java's got a 5 year head-start on .NET. It's *real* and has a proven track record. Why devote any time to infectious vaporware from Microsoft...

      Anyway, this whole thing seems like a colossal waste of time to me.

      see ya,

      • Exactly.... I can write 250,000 simicolons pretty fast, too.


        Are those supposed to be binary semicolons, the same way that "mebibytes" are supposed to be binary megabytes?

        (Couldn't resist...)

    • by Otter ( 3800 )
      For one thing it's a quarter million, not a quarter billion

      ...and it's Southern Storm Software [], not Sourther Storm, at least judging by the URL as the site is Slashdotted.

  • 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?
  • 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 ?

    • by Zero__Kelvin ( 151819 ) on Wednesday December 26, 2001 @02:04PM (#2752383) Homepage

      " 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" [].
  • Bah! (Score:3, Informative)

    by Andre060 ( 99353 ) on Wednesday December 26, 2001 @12:41PM (#2752089)
    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!!!


  • Hmmm (Score:3, Interesting)

    by cnkeller ( 181482 ) <cnkeller&gmail,com> on Wednesday December 26, 2001 @12:42PM (#2752092) Homepage
    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 (Score:5, Insightful)

      by medcalf ( 68293 ) on Wednesday December 26, 2001 @12:47PM (#2752112) Homepage
      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.

      • A group can spread the risk and potentially produce a less-buggy first cut, but cannot truly innovate, because any group automatically dumbs down.

        Wow, what an incredibly scathing comment. Have you ever been part of a good team effort? Sounds like you have had some bad experienecs. By the way, I completely disagree. I don't think groups always dumb down, thats a function of group/project management in my opinion. I've been on several projects as a consultant where I went to the team lead and said "Bob and Susan are pretty good developers, but I don't think they're cut out for this type of project. Their code is always late and poorly documented, but it does work." I had them rotated onto another project and got some developers who could keep up with the pace.

      • Re:Hmmm (Score:5, Interesting)

        by JediTrainer ( 314273 ) on Wednesday December 26, 2001 @01:01PM (#2752156)
        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.
        • Primadonnas (Score:2, Insightful)

          by pong ( 18266 )
          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.
          • I never said you have to have ONLY one gifted programmer, nor did I say the 'primadonna' system is good.

            All I'm saying is that it's logical that different people have different abilities, and the gifted ones need to take the lead and make certain that the code has good design.

            Yes, it's stupid to have full dependency on the 'primadonna', as you put it. But, without good leadership, your codebase will become a mess very quickly. Proper design will eliminate redundancy in code and will make debugging much easier. Many programmers do not understand how to begin designing a large system. This isn't work that can be done by one and only one person - a group of 'core' developers is best, and will oversee the work of the whole.

            Once the design is more-or-less defined, everyone can go to work. The gifted programmer is less needed now.

            Having a 'primadonna' is unacceptable for long-term stability of a project. It is the opposite side of my previous argument, where NOT having a gifted programmer take leadership of a project in its initial stages will kill the project in the long term.

            In my work situation, this design work is actually a partnership of TWO people. Neither are 'primadonna', and neither are so indispensible that having them leave would kill the project. But it is recognized that they understand the 'big picture' better than the less talented (or less experienced) programmers do.

            Let's face it - Linux and most large-scale projects evolve under a 'leadership' of the most talented and programmers. They are the ones responsible for designing the layout of the code, and how (more or less) the whole picture will work. At least, more so in the beginning than now. Inevitably, though, you have the people at the top of your 'programmer pyramid' who decide which code to commit or not. Not one person, but not the whole mass either. You can write anything you want to plug into the kernel, but the kernel design was NOT defined by you (you meaning most people).
          • 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.

            Then again, this guy has done 38 man-years of work in one year.
      • Does it not occurr to anyone that it is possible to have BOTH! Amazing concept, eh? A good programmer, who follows software design methods! I better go get a patent on this...
    • 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.
      • > 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.

        This might be in purpose, you know, to save you the time you spend pack & unpacking the variables from the stack
    • Agreed. Also, what about security? How long until someone comes up with a root kit for dotGNU?

      I can deal with poorly written code, but not with big gaping security holes because people were slinging out code as fast as humanely possible.

      On the other hand, I have met a number of people that could write 5000 lines of efficent, secure code in a week. Hopefully, Mr. One Man Army is one of those people.
    • Re:Hmmm (Score:2, Informative)

      by pajama ( 48556 )
      There are a couple of tools to measure code metrics in Java:

      There should exist the same kind of tools for C/C++. Maybe if you measure this code against one of them, you could get a better picture of code's quality.

      LOC (lines of code) alone don't reflect ANYTHING.

    • I mean almost any programmer can crank out 5000 lines of crap a week

      Actually, no, any programmer can't. Seriously. Most programmers simply can't conceive the number of coherent, interrelated thoughts necessary to produce 5000 lines/week of reasonably functional code. Even without knowing anything about the quality of this code, the sheer quantity bespeaks an extraordinary programmer.

      • ever heard of copy and paste?

        Besides, it would be good if some of that code was actually being reused and refitted from older progs. Thus, you could do 1000 lines of code in an afternoon.

        5000 lines of code per week, counting 60 hours (being generous), is 83 lines per hour, or 1.4 lines per minutes. assuming 40 bytes per line (including the spaces (no tabs--of course)) that's 55 bytes per minutes. Assuming 7 bytes per word, that's 8 words per minutes.

        I'm assuming that the aveerage programmer can manage to type that fast.

        The reality is that the programmer needs to be highly skilled, highly motivated, and have a very good understanding of what he/she is trying to achieve.

        But it is possible. Also, the programmer may need to be single and independently wealthy (living at parent's or have exercised interesting stock options in the summer of 2000)
        • I'm assuming that the aveerage programmer can manage to type that fast.

          Typing isn't programming. Just so you know.
          • granted, but you *have* to be able to type to write programs (unless you have a very good typist or are still using punch cards...)
            • Thank you, Captain Obvious. :) But seriously though, for any programmer with full use of his limbs, typing speed is not the bottleneck in prgramming speed, I can assure you.
  • 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?
  • 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?

    • With that type of attitude, the words could be said..

      Do we really need C++ (or ) why not create better Cobol sollutions instead?
      • Slashdot ate my "insert other language here" statement. You bastards...

        Oh and Kenny's dead too.
      • 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.
        • 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.
    • by Dudio ( 529949 )
      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.

      Remember, these are all ECMA standards now; it's not like .GNU is porting the Win32 API or VB.
      • You have a very low opinion of VB programmers. Its not that we don't think we can handle it or are afraid of GNU based systems - its just that we don't care.

        Programming for multiple-platforms, even with the holy-grail Java foundation isn't that easy. Look at major cross-platform projects - they are slow, cumbersome, and often the exact opposite of profitable.

        When I am working on a new project, I say to myself "Is it worth the 25%-50% more time to develop this product cross-platform style?". Usually the answer is no - at the end of all that work I've only expanded my market
        In fact, most VB programmers who end up coding for multiplatforms choose Mac next - its just a matter of profits. Linux software isn't a very profitable margin and its users are very hard to deal with and please :]
  • .NET (Score:4, Funny)

    by cavemanf16 ( 303184 ) on Wednesday December 26, 2001 @12:45PM (#2752107) Homepage Journal
    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! >:)

  • by sfraggle ( 212671 ) on Wednesday December 26, 2001 @12:46PM (#2752108)
    After half a million lines of code in one year, they can now celebrate half a million hits in one minute!
  • 250,000 is a quarter million I believe. I guess quality and functionality are a function the amount of code, eh?
  • by rhost89 ( 522547 ) on Wednesday December 26, 2001 @12:49PM (#2752116)
    This reminds me of the old days and IBM's K-Line projects, More lines = more funding but it normaly went like this...


    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??
    • When I was at IBM, we had KLOC counting macros for the editors which eliminated this problem. For example a C language KLOC macro would count semicolons (with some logic to handle special case like a for statement). It almost never counted newlines to determine source lines of code.
  • Commendations (Score:3, Insightful)

    by Snowbeam ( 96416 ) on Wednesday December 26, 2001 @12:51PM (#2752126) Homepage
    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
    • 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.

      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 .NET. They'd be stupid not to do so.
  • Quarter Billion? (Score:1, Insightful)

    by kryptkpr ( 180196 )
    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

  • 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.
  • by Bowie J. Poag ( 16898 ) on Wednesday December 26, 2001 @01:08PM (#2752179) Homepage

    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.

  • Great (Score:4, Funny)

    by mESSDan ( 302670 ) on Wednesday December 26, 2001 @01:08PM (#2752184) Homepage
    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 []
  • by Fuzuli ( 135489 ) on Wednesday December 26, 2001 @01:11PM (#2752193)
    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 ?
    • I would like to support your stance. The .NET Framework and C# is very elegent, well thought out, and extremely robust (we're running production apps on BETA 2!). J2EE, and especially JSP (when compared to ASP.NET) missed the mark. JSP essentially copied ASP while MS reinvented Web Application Development with ASP.NET in a very good way.

      It also seems like the /. crowd needs to hear this repeated as much as possible: The Hailstorm initiative != .NET Framework. .NET is just the development platform for Hailstorm (Passport.NET, etc.).
  • by Carl ( 12719 ) on Wednesday December 26, 2001 @01:16PM (#2752210) Homepage
    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.
    • by Anonymous Coward on Wednesday December 26, 2001 @02:53PM (#2752544)
      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?
      • DotGNU Portable.NET has a functional VM right now too. I haven't bothered with a JIT yet, because the primary goals are portability, stability, and completeness. I try to do things in order. A JIT would take a few weeks once the rest of the infrastructure is in place. No point doing it until the basics are there.

        DotGNU Portable.NET has a fraction of classes written, but only because we have 1 very busy developer working full time on this, and my time is split across the entire project. Contributions are always welcome.

        DotGNU Portable.NET has garbage collection now, using the Hans-Boehm collector that is used by gcc.

        DotGNU has less public relations only because the media have bought into the Mono hype and haven't bothered to talk to DotGNU to get the other side of the story. Even when we seek them out to correct blatant mistakes in their articles.
  • by p3d0 ( 42270 ) on Wednesday December 26, 2001 @01:25PM (#2752241)
    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 (Score:5, Insightful)

      by jon_c ( 100593 ) on Wednesday December 26, 2001 @02:10PM (#2752408) Homepage
      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.

  • Wait and See (Score:5, Insightful)

    by f00zbll ( 526151 ) on Wednesday December 26, 2001 @01:44PM (#2752312)
    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 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 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.


    • You mean, that MS Passport has an flaw in your opinion. For the 1.8millionth time, PASSPORT != .NET Platform! That's like saying that StarOffice == J2EE because StarOffice is built on J2EE.
      • I don't think I equated .NET to Passport. I was pointing out the statements made in their whitepaper. The white paper did not explicitly state Post as an option. Most browser redirects occur through GET since that is the most expediant method. Sure a person could write to the outputstream manually and send it post. The question is will lazy programmers use Get or Post. If the specification doesn't define clearly the preferred method, any old VB programmer will take the shortest route, simply because ASP projects operate on a "I wanted it last month" basis.
    • What validation of your generous assumptions have you performed?

      When I did a capture of the data stream from my browser, all the sensitive information I saw was contained in POST calls using SSL.
  • by jsse ( 254124 )
    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. :)
  • by FFFish ( 7567 )
    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.
    • True - however it's not the apps themselves that are loathed so much, it's the licensing and the environment under which those originals (Word, Visio, etc) need to be run (though Mac OS is another option for all of those).

      I would be less critical of M$ if they only wrote applications and did not write operating systems. For example, Photoshop dominates the image-editing market, but it doesn't make nearly as many people mad at Adobe (yes, now there is also the GIMP for *nix).

      Nonetheless, .NET-related tools running on other OSes is interesting. Unfortunately, though, this doesn't mean a whole lot to portability of M$ applications - they will likely have win32 hooks in them.
    • Illustrator is made by Adobe, not M$.

      Just saying's all...
    • 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.

      Interesting non-sequitur. Word is the only Microsoft product. Visio was fully developed and owned its market share; Microsoft couldn't compete, so they bought it. Illustrator is not an MS product, unless they've bought Adobe when I wasn't looking.

      I would point out that if you want to take over the desktop market, you've got to make it easy for people, and that seems to entail cloning the market-leading software packages. Never mind the fact that for programming and serving information there's no MS software to emulate, since Unix pretty much rules there...
    • Microsoft once again leads the way for Linux. Amazing, isn't it, how many Linux projects are simply clones of existing Microsoft software.

      Ok, I'll bite.

      Need a word processor? Get a Word clone.

      Microsoft Word is itself a clone of WordPerfect or Multimate or WordStar (depending on who you ask). Linux word processors don't need to clone Word: they can clone an original.

      Need a flowchart tool? Get a Visio clone.

      Except Microsoft didn't write Visio. They bought it as a finished product with an existing userbase. Linux vector drawing programs were cloning Visio well before it joined the Microsoft stable.

      Need a vector illustrator? Get an Illustrator clone.

      Illustrator isn't even a Microsoft product.

      3 strikes. You're out.

  • "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!

  • by dgb2n ( 85206 ) <> on Wednesday December 26, 2001 @02:13PM (#2752417)
    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.
  • by PureFiction ( 10256 ) on Wednesday December 26, 2001 @02:20PM (#2752443)
    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.
    • by PureFiction ( 10256 ) on Wednesday December 26, 2001 @02:38PM (#2752496)
      I should have posted a link to the tool which can be found at: [].

      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.

    • 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

      Hmmmm, one man doing the work of 18, and doing 38 years of work in less than a year... He must be a superman! Either that, or those calculations are very very make-believe.
      • Your confusing the results.
        It would take one average developer 38.37 years to write that much code.

        OR it would take a group of 17.92 average developers 2.4 years to write that much software.

        This is by no means incredible, it makes sense. There is a huge difference in productivity between average programmers and extremely capable programmers. This is a well known phenomenon.

        There is also a lot less than 'average' amount of documentation, testing, and design going on in his work, which makes the SLOC count rise as well.

        Remember, this is all averages and assumptions. Its not 'the law'.
    • The actual count is indeed 250,000+. You forgot treecc and pnetlib, which are part of pnet, but distributed separately. You also forgot the *.tc input files for treecc, and the *.html and *.texi documentation files.

      I was very careful with the count. I did a complete "make distclean" to remove automatically generated files. I removed imported packages like libffi and libgc which I didn't write. And then I counted up all the lines in all three packages.

      I'm an obsessive commentor, but any good programmer should be. Comments help explain the code to yourself six months from now, when you've completely forgotten why you did something a particular way. For a multi-year project like this, obsessive comments are vital.

      250,000 lines is a conservative estimate. I've probably thrown away 50,000+ lines of code in the process of building this. Some experiments just didn't work and had to be redone.
      • You are counting documentation as lines of code. Documentation is not code. While documentations is REQUIRED to write decent code (i.e. decent code requires decent documentation within the code / included with the code), it is not part of the code itself.

        If you want to be accurate, you would have had to say that there are 250,000 lines of code, documentation, and whitespace.

        I recounted including treecc and pnetlib (both of which are very small in comparison) which includes both the *.tc files, as well as the *.cs files and the updated totals are:

        Total Physical Source Lines of Code (SLOC) = 209,300
        Development Effort Estimate, Person-Years = 54.68
        Schedule Estimate, Years = 2.45
        Estimated Average Number of Developers = 22.32
        Total Estimated Cost to Develop = $ 7,386,680

        And that includes 18,000 lines of code in shell scripts (which I usually dont consider either).

        If you wanted a true estimate of all code (excluding shell scripts used in configuration, etc) then you are looking at somewhere around: 191,676 SLOC.

        Anyway, this is all an academic argument.
  • 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:

    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!!!


    • I have in the past managed 25000 lines of code per month, two months running. But this involved 16 hour days, 6 days a week.

      The code proved damn robust, but I could not maintain that level of production much longer. Then again, it really was about 50k lines of code and was done at the end of those two hellish months, so there was no more to do. I suppose if I had a greater vision, and a solid architecture, work could have progressed.

      Oh, it was a mix of C and 80x86 assembler.

      The point is, that, yes, 5000 lines per week is doable, but something I doubt I could maintain for a year.


  • 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.

  • 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.
    • rabtech writes:

      > 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.

      That's nice. I just wish .NET was only an innocent little programming platform that Microsoft was making to empower its developers and customers. Problem is, Microsoft is not a happy bunch of programmers making neat things. Microsoft is a bunch of shrewd and greedy marketers, who won't rest until every device with a chip in it has a Microsoft tax on it, and everone who uses any such device, gets a monthly bill payable to Microsoft. To make matters worse, they have broken the law, have not been punished, and now think they can get away with anything. The very name "Hailstorm" should tell you that their intentions are no where near benign. A hailstorm is when storm clouds pelt you and your belongings with lots of little balls of ice in a way that is painful and can cause extensive (and expensive) damage.

      Wide as the .Net umbrella is, .Net is only part of an overall strategy to control the entire industry. To understand what that strategy is, we have to look at all the pieces. In addition to .Net/Hailstorm/Passport we have the XBox, a cheap home .Net terminal currently masquerading as a game console because that was all Microsoft could persuade its developers to develop for. We have MS's recent Digital Rights Management patent (which calls for a total lock down and license check for every file, with needed licenses purchased quietly without informing the user). This in combination with getting a law passed requiring a DRM OS for every device (one was in the works recently) could spell serious trouble for all other operating systems. Toss in a similar lockdown on applications and drivers, with Microsoft in charge of certification, and even Open Source in general is in trouble.

      Ultimately, if all goes Microsoft's way, this amounts to the average home user having an Xbox (whose EULA is going to ultimately make the CueCat's look positively permissive). If you want to play a game, you pay. If you want to play a song, you pay. If you want to run an application, you pay. Microsoft owns. You pay, and pay, and pay. For businesses: substitute XP PC's for Xboxes and pay far more. For developers: pay lots for the tools, you don't want to know what you pay for the servers, and keep on paying. If you want to run another OS, too bad, there aren't any legal ones. If you want to write your own stuff, it's not going to run on Microsoft's stuff without MS say so, and written with MS tools (and much paying).

      As for the poor smuck and his quarter million lines of code: he better change the name and quick. If he doesn't, the best he can hope for out of a trademark lawsuit is a settlement to change the name and the license if Microsoft wants his quarter million lines of code, or an order to bury it if they don't want it.

      > 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.

      Better yet, support either Sun's Liberty Alliance or Novell's ZENworks Up. They have a much better chance of unseating MS than you do alone.

      Even better yet, think up something new and useful that MS hasn't thought of and spent years working on. Then you can beat them to market and really add something good to OpenSource, instead of just being a copy cat.

      Homage to Rodan, most noble Samarai of the Sky, on the occasion of his 45th birthday today!
    • "Take everything that Windows can do..."

      Er, what's that, then? Everything it can do, or everything that it can do well, or everything that it can do that other OSes can't do? Please, clarify; as-is, your comment seems a little... frightening.
  • 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 */
  • It's ANSI C.

    If it's this long, then it's not a suitable implementation

    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:

"The chain which can be yanked is not the eternal chain." -- G. Fitch