Slashdot Mirror
Opensource Code More Refined Than Closed?
zonker writes "In this poorly titled cnet story (as opposed to an earlier story stating a similar theme), a company named Reasoning says that at first open source code has marginally worse quality than closed source code of the same maturity, but it tends to become better refined through the open-natured development process than closed source. They mention Apache and Linux as examples, however they don't mention the 'competitors' they tested against by name. ."
Who really knows? I mean...of course we know some closed-source applications just plain out have horrible code, but being closed-source, we really can't look at it can we? With open-source, I think because it is open, it is critiqued more.
-Rob
Of course code that is peer reviewed by a large group of coders will become better over time.
Most proprietary code is only reviewed until the developers have ironed all the bugs necessary to get it to run reliably. Then it's shelved until the support lifecycle requires a fix.
Conversly, Open Source projects have a huge interested user base who can continue to review, submit bugs and improve the code over time.
You're new here, aren't you?
There's a Mercedes gap too. I want one and can't afford one, but it's not government's job to do anything about it.
The interesting thing is that ATT is a client of Reasoning.
Makes you wonder if they may have tested OSs like Plan9 or Inferno... They probably haven't tested the original UNIX code, though.
The right to offend is far more important than the right not to be offended. (Rowan Atkinson)
So your version 0.1 written by some dude in his spare time is laughable compared to the closed source commercial products. By the time you get to 1.0, 2.0 or whatever.. and many people on the project, the quality has risen greatly.
Personally, I like seeing the quality improvements on the Apache and PHP projects. Is there anything these guys can't do?
--------
Free your mind.
Ofcourse Open Source code is better than Open Sores code!
An Indian-American Hindu committed to non-violent thought/speech/action alarmed by the global explosion of radical Islam
"When more people can look at your stuff, you have a tendency to make it look nicer."
This kind of comparisons are stupid in general. The quality of the algorithm used can not be measured in this way. And so many things depend on it.
I call BS. More refined?? How about we have a semi-scientific study that lists competitors that have the same amount of hours put towards their code as the open source code.
To actually clarify what happened:
-Opensource code can have a lot more man hours put into it in a shorter period of time than closed source
-Close source code is only as good as the person doing the hiring.
As a Linux user myself for many years I now see the sideeffects of Open Source myself and started to eye for alternative Operating Systems such as MorphOS (Pegasos), MacOSX, BeOS Zeta and Microsoft Windows. There are various reasons for me to do this.
a) The Open Source community used to be a nice one, the philosophy of it was valued high in the first couple of years but meanwhile the entire situation has changed. Companies are trying to protect their IP, other companies don't work fair with the Open Source community by not backporting their changes in the original sources and so on.
b) The audience changed totally, you need to deal with more and more complaining and ranting people every day. People that are always dis-satisfied regardless what you do. Even I as Programmer need to deal with these people. I spent my time writing the programms, fixing bugs, answering technical emails, pay for the Webspace, offer the software and yet you need to deal with dis-satisfied people all overwhere which leads into demotivation of doing something better.
c) Many people wandered off from Linux and Open Source by using alternative Systems (preferabely MacOSX) thus they have a working, aesthetical, nice, round and standardized desktop environment with all tested tools. They can get their work done and don't care for Linux and it's Open Source that much anymore as they initially did. A lot of people started to work a lot less on Open Source because they don't see the need to do this anymore because they get all the software with better quality offered on their alternative System.
Here an example: A lot of GNOME developer moved away working on MacOSX these days and don't look back, while they still help with various fixes, coding etc. they still do this as funjob, they don't see the need to work as hard to make a good Desktop because they have a Microsoft independant OS (MacOSX) which offers them everything and more than GNOME for example. Of course they also see the points written by me here with all the ranting people, no fair play of companies and the general demotivation.
Face it, we all like to be honoured for our work, we all like to hear 'thank you' from the people outside that we spent our time working our ass off on the tools we offer. But the reality is that we deal more with complaining people rather than people who said 'thank you'. We all like to earn some money with what we do. Look, we sit down the entire day, weeks, months working on the Tool, we pay for Webspace and more and we don't even get the money back for the Webspace we pay once per year.
Open Source is indeed a nice thing but the times has heavily changed, complaining users, demotivation, dirty play with companies, sueing of people who wrote Open Source applications like the freecraft person. A very nice game and now it's not available anymore because he got is ass sued off.
Think about it, is it really worth the trouble ? We should concentrate back to the old roots and try making some bucks with our work, getting the webspace paid, stop the insanity with open source. it's a good idea but the license is only a hype. Like everyone can fork the code and release his own version of the software which only ends in 20 derivates which each of them still doesn't do the work it was aimed for. Not to mention that we all are individual people who work for fame, for money for being someone in the community. You work on the software because you love it because you never think about someone comming up forking it and then one day you see a derivate of your work floating around in the community and you get heavily pissed off and stop working on it and feel disappointed and have thoughts in your head saying 'what did i do wrong, why did this person fork my software' and so on. Please don't understand me wrong, think back the time when emacs got forked to xemacs. Or think back when KDE Desktop got heavily trashed by RedHat. You are itching at the egos of people with this. It's really better to start thinking about new and better ways and search for an alternative work on an alternative System.
This is obvious, as most businesses dont want developers to spend time on code that already works. If it doesnt work, then it gets rewritten. If the spec changes, then it gets rewritten. If its fine then you work on something else.
Opensource developers have to have a certain pride in their code almost by definition, as other people will be looking at it. Also if someone sees that a bit of code is not as efficient as it can be, then usually they rewrite it.
The one downside to opensource code that i have seen is that since many people contribute, and some of those contributions are not official, eg patches, then coding styles start to show through. In closed source business environments, coding styles are usually not a issue as we all have guidelines to work to, defining the use of the language so that anyone in our group can pick up code and instantly add to it, usually code written this way cannot be pinned to any one individual.
open source code has marginally worse quality than closed source code of the same maturity
So they compared the source code of an open-source project with what ? the disassembled code of a closed-source project ? how would they know if the source code of the latter has better quality than the former's, since by definition, you can't get the source code of the latter ?
I believe the guy is talking about the quality of the whole project, not source code quality.
"A door is what a dog is perpetually on the wrong side of" - Ogden Nash
In contrast, Open Source is driven by all-that-is-good, i.e free software, community spirit, because-I-can. When there is no paymaster (because you rarely get paid for OSS), the motives for development differ greatly, and pride-of-work takes priority.
The two disparate models do cross sometimes, like in the case of ReiserFS - features are chosen by donation, but don't expect development to be rushed. Hans seems to have got the balance right with his project.
"I am not bound to please thee with my answers" [William Shakespeare]
But is a typical OS project really peer reviewed properly by more people than a typical closed source project of a comparable size?
There's nothing inherent about open source that means it has a wider user base or that more people should report bugs.
Improving the code implies that your users are also developers, and that they are prepared to invest the time to fix it for you. In some cases, this is true, and the results can be great. It's hardly a universal truth, though.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
First of all it looks like line 29 is disappeared, but maybe it was just whitespace. Looking at the code above show me that the strlen function is called with the pointer returned by the malloc in line 27. That's great, since strlen is looking for the "null termination byte" in the string it will return the position of whatever random zero byte will be next in the allocated memory because nobody was writing anything to the allocated space. I suspect, that line 28 should refer to "fspec" instead of "filespec" but since the program obviously compiled it can also be that filespec is a valid global identifier.
Anyway, this simple example from them shows, that their automatic tool doesn't find all bugs and so the numbers returned can be just a sort of wild guess. BTW: I would really like to know what their code inspection tool will report if they use it on their own code inspection software. :-)
bah. Not that I'm some kind of win95/ms fanboy, but what a silly comparison.
Apache and IIS would be a marginally more fair comparison, and IIS 6.0 is an improvement in many important respects than the first verion of IIS web server that came with NT 3.51
but even point that would be a waste of time..
Lots of closed source/ unrelated pieces of software that HAVE improved in reliability/ utility with age, but that doesn't really prove any more point than the above.
No, it's not. Microsoft Office and Microsoft Windows are about the worst examples of "typical" closed source projects imaginable.
Ladies and gentlemen, please do not feed the troll.
As a professional developer who works on closed source projects, I find your generalisations deeply offensive. We provide industry leading products where new features are added based on what our clients want, our new versions offer improved performance not backwards steps, we normally turn around critical bugs and get fixes out to our clients in a matter of hours, there is no open source software around that even comes close to what we can do, and our company has developed from humble beginnings to a successful group with several product offerings over the same decade or so as Apache. None of your accusations about viruses, bloat, messed up UI etc. could fairly be aimed at us.
And the thing is, while I have a lot of respect for my employer, I'm not just saying this because I think the company is great. I'm giving one of a million examples of good development that happens to be closed source. None of the problems you mentioned is implied by keeping the source closed. You are spreading FUD, pure and simple.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
I can get most commercial Unix's to core dump by running 'pwd' in the right circumstance. Yes, that's right. A command that takes no arguments and reads nothing from standard input core dumps in the correct circumstance. The circumstance is usually just being in a directory whose path name is several hundred thousand characters long, but some will crash if you set the environment variables right and it looks at them for something having to do with POSIX compliance. I don't know what POSIX compliance should have to do with pwd but then again I'm just a dummy.
OTOH I have never been able to get GNU 'pwd' to dump core.
What does this mean in the big picture? That after many man-years of intensive effort you can write a robust piece of code that takes no input or command-line arguments :-)
So then, did they act in the spirit of things and report these back to Apache?
Cheers,
Ian
The reason OS software is good is because when people publish OS software they know thousands of experienced geeks will be perusing their code, and they don't want to look bad.
This is a powerful motiviation.
It's Christmas everyday with BitTorrent.
Another thought along these lines is: perhaps the projects that fail often fail due to project management (in the most Bazaar sense of the word), rather than the usually heard competing time pressures, personality conflicts, loss of interest, and so on.
I have worked in the software industry for 5 years now and I tend to disagree with this articles view. Many closed source projects have horrid code that can be hidden by a "Closed" or "Proprietary" label. Open source is exactly that, "Open" therefore people who write the code automatically have "Big Brother" watching over them. Your coding practices is a direct view of your knowledge of the language and I know for personal experience that the open source code I have written was much better tested and reviewed then MOST of the code I have written for contractors.
My mother never saw the irony in calling me a son-of-a-bitch.
This is a M.Sc paper that tries to explain how the open source development is working. It's an interesting read.
These OSS vs CSS comparsions are just the dumbest things ever. How can you take a couple of OSS programs and compare them to a couple of CSS and come to ANY conclusions? I've worked in places that have had GREAT code, the developers had a clue, and they had reasonable process (given the usual capitalist based time constraints). Then again I've been in places where the code is crap, the process is broken, and mgmt doesn't have the first clue. Now which view of CSS is this co. going to take, well I'd assume they'd use whichever one will make the outcome the way they want it to be.
Fact is that they are looking at nothing but process and demographics. When you look at "bigger" OSS projects, then you'll notice a couple of things. They have a tendency to have their act together, because the project has been around and therefore has had time to get it's process together. Imagine an OSS project that had no clear "leader" or "leaders". One where anyone was allowed to check in code with review. What would you end up with, CRAP. Now imagine a CSS that had regular code reviews, where developers actually unit tested their code, and where QA depts had their act together and had good test plans. Assuming a decent level of developer skill, you'd probably have a decent product. The the quality of the product is based purely on the process's put in place to ensure that quality.
BTW, if I see one more post about "many eyes", I'm going to puke (oops, too late). Those who write that pie in the sky crap don't really seem to have a clue about any real development. Sure it CAN be true, but I highly doubt it typically is. If that was the case, if the "magic" of OSS were so clear cut, then damn, OSS should be as close to bug free as is attainable, which OBVIOUSLY is not the case. You work on some code, you get it to work, you move on, period. OSS, CSS same thing. Someone else probably isn't going to bother with it unless it is A) broken B) too slow C) needs a new feature.
I'm sure I've read here, and more than once, that people who have seen Windows source code (I believe many universities have access?) have generally described it as being very good.
/. for "Microsoft source code quality" :)
Hard to find references to it though - try searching
Anyone got a pointer?
Read reviews of shopping cart software
Again, it would be interesting to see how open source projects that follow this maxim compare to ones that don't.
If you are in a crazy place which just wants to get something out the door as fast as possible, even if you do reviews they may be of little use (e.g. not much more than "does this meet the coding standard) or the reviewer may be pressured not to ask for rework because the insane management see no value in reworking code that does performs this month's cool feature, no matter how poorly implemented.
The New Zealand Hearld is an unreliable paper, they get basically everything wrong one way or the other (to cite an example, they can't even get the name right for a 700 people land, that had everybody playing CS 'against terrorism' on ONE server).
NZ is small, if you have a contact with Microsoft, you do everything you can to please them. Otherwise they might cancel the contact next time it comes up for review. Which in NZ could mean the company would have to scale back significantly or even shut down.
Ohh and yes, MS is a big boy in this country and throws its weight around quite happily.
GPLv2: I want my rights, I want my phone call! DRM: What use is a phone call, if you are unable to speak?
When you can't code above your level how will you ever improve it?
By failing. That's how you usually learn.
"We returned the General to El Salvador, or maybe Guatemala, it's difficult to tell from 10,000 feet"
Very seldom do you see a commercial entity really bust their ass trying to make their code as clean and elegant as possible. There's just no money in it past a certain point. Why the hell should they care if you can make it .2% faster by rewriting the i/o subsytem interface here? Not crashing is it? Then who cares?
Turn it around to Open Soruce, and you end up with a whole hell of a lot of people just doing it for the hell of it. And yea, the initial products are probably sloppier than a lot of commercial code, and a lot of that code ends up on the metaphorical scrap heap. But the stuff that is good, the stuff that's really cool, suddenly you've got dozens of people going over the code. Everyone wants to be on the developer team. Everybody is reading through it, scratching their heads and offering little improvements. That's the thing about Open Source.
ad logicam Claiming a proposition is false because it was presented as the conclusion of a fallacious argument.
When you are comparing code against closed source code, you must consider that most closed source code has hard time deadlines. There is rarely any cost benefit to revisiting code and cleaning it up.
...but my experience differs. I used to work in a beta testing group for a small german software publisher. Actually my job was to implement this team since there was nothing like this before. When we started I was confident that we could enhance the quality of our products but reality cured me: The only thing that changed was that they put a huge sticker on the boxes "Quality tested by our great beta testing team!" or something like that. But they turned down EVERY single review we wrote and whenever it would have caused a delay for launching the product they just didnt care. After two years they shut the betatesting group down again since we didnt improve the product quality [cough]how could this be?[cough]. As far as I know they kept the stickers, though. ;-)
> if you're really lucky they explain how
And if you're really, really lucky you pair program with them. Then you get to watch them make mistakes like everyone else, and they get to explain how they write good code - the thought process they go thru, how they remove duplication, etc.
The Army reading list
Many times, this results in bad code crystallized into finely polished and chromed pieces of garbage. Which, incidentally, makes it also more difficult for others to change or refactor it, lest they make it "less pretty".
I believe it's better for the quality to show the code, in general, but how about trying to formalize code review and other better-coding-through-groups practices with sites like SourceForge?
Jouni
Jouni Mannonen | Game Designer, Consultant
If you write bad closed source code, all the developers in the company will se it.
If you write bad open source code, the entire fscking world will see it.
More shame -> more incentive to write clean, solid, well-commented code.
First, they ran it on 2.1-dev code as of 1/31/03, which is some time ago now.
They found 31 supposed "defects".
29 were null pointer dereferencing, 2 were uninitialized variable use. You got it, they don't do any analysis of defects much more complex than a good compiler may do.
After looking through a handful of their supposed errors, many of them are pure crap because their tool isn't smart enough to figure out that a variable really can't be null.
Their analysis also doesn't consider the fact that subroutines may have APIs that are guaranteed to return certain things, so not checking for null is perfectly legitimate.
Bottom line is this is a company with a fairly primitive product trying to get advertising; some fraction of the alleged defects are actually bugs, most most of them are of a very very minor nature and many of them don't really exist at all.
Year One:
- The open source project begins by a 0.1 version on a student web page deep in the unknown parts of the net. Only the writer know how to use it.
- The closed source project begins by a 1.0ß version made by full-time professionals. Full functionalities, user-friendly, full of bugs.
Year Two:
- The open source project evolves towards v 0.5. Main functionalities are there. The program is basic but rock-solid. A small community is growing. New comers write some doc, fix some bugs. New users write bug reports. Backward compatibility is broken every week.
- The closed source project becomes v2.0 Special Edition. The overworked team does not fix any bug as it has no time left after 15h/day on the v2.0.
Year Three:
- The open source project gets into Debian Unstable. Developpers are flooded by bug reports. Standards conformity is enforced. Version numbers reaches 0.9.
- Close Source IV+ appears in the shelves, with new wizards, new shiny icons and DRM. Compatibility with 1.0 is there, at least in theory, not in practice, but ensures that the code is a mess. There is no developper left from the first team. Microsoft announces it will innovate by adding the features into the next Service Pack of Windows.
Years Four:
- The Open Source project crosses the 1.0 line! The main developpers claim "Mission accomplished!" A few other projects gravitate around this one, mainly graphical interfaces to the command-line program. Only advanced Unix users will ever hear of this project anyway.
- The Closed Source company files Chapter 11 after the CIO has flown to Mexico. Failure make the headlines. Code is lost.
Christophe (Don't hesitate to point out my spelling and grammar mistakes, I want to learn - Thanks).
I've also worked for a large number of companies over the years, and have also worked on open-source. I'd venture that one of the main reasons closed-source doesn't improve is that many (actually most) employers do not want to pay for 'code cleanup'. An employee will see little gain from trying to improve the code, and will certainly get penalized if his work causes even a single bug.