Slashdot Mirror
All Source Code Should Be Open, Revisited
cconnell writes "In my last article, I presented the idea that all commercial source code should be open. In other words, part of the delivery package for any software purchase should be a copy of the source files. If everyone saw software vendors' design and coding, the vendors might stop shipping us such lousy programs. The article generated a fair amount of controversy. My latest piece follows up on this idea and includes a few adjustments that respond to reader feedback."
the cost to develop an app will always stand before cost of quality of the app. to think that every commercial app will be released as open source is very naive.
Reading this and at the same time see ad for Microsoft .Net Enterprise at slashdot.
Ciryon
In any large software system, the truly unique code probably accounts for about 1% of the source.
Hmm, not on any large software system I've ever worked on... The important part isn't some magic 1% of the source, it's the fact that you got a group of people together for long enough to ship the thing.
This negates one of his basic points, and doesn't really contribute much over his previous rant...
Nae bother
For "things that will never ever happen in reality" type articles.
If a company had to release their code for products they sold, it wouldn't do any good to the end user. The code would be way to complex for 99.9% of all users to understand. The only users who would really understand it are the programmers, and even then they would need to spend a LOT of time analyzing it (Assuming it is a decent size program) before they could even start to understand it.
The only people who would benefit are the releasing company's rivals, who would have the time & money to sit down and reverse engineer the code, and then rerelease it as their own.
Then again, maybe I'm missing the whole point of this and should RTFA.
No
If I spend 400 hours writing code for something I want to sell, I'm not gonna give it away. I'm sorry
I contribute to open source projects as well but, I have to eat. That's just the facts of life.
Support of user modified code is impossible
Competitors may take advantage of reading the source
It's "my money" that went into developing the source and "I" want to reap the benefits of "my" work
Bug handling would be a nightmare
There are several other reasons too. I'm not sure why all source has to be open source. Sometimes I feel that a lot of people just want a system to be Open SOurce just because it is The Right Thing (Tm), not because it would give them anything.
I have no problem with non-commercial software beeing open-sourced or even to a certain degree commercial software. But is it really necessary that ALL software is open source? I fail to see the need in all cases or the reason for it to be so.
If you mod me down, I *will* introduce you to my sister!
Now imagine every script kiddie having the full source to W2K or XP, or heck even Office. Lets say, following the rules of the article, MS removes the 1% of intellectual property and replacing them with stub routine. There is still enough there to determine the weaknesses, and maybe even enough to create a new trusted OS that really isn't trusted?
I understand the benifit is to be able to determine the weaknesses and report them back, but as fast a MS is at getting patches out, this would become insane really quick.
If this was an industry requirement, you wouldn't have developers shipping tight, well-planned code.
You would have no developers and no applications. Technological progress has always centered on riding the bleeding edge, where the programmers themselves barely have a clue what the heck they're doing. If people knew how much of the stuff they use was designed under impossible time requirements by bleary-eyed schizophrenics, we'd still be riding in horse carriages.
Look at how today's technology compares to NASA. They sit and pore over every detail, examine and re-examine; approve and check. What are they using in the space shuttles? 386's for main computers still?
Requiring open code would put many companies out of business. A lot of customers have their own businesses depending on applications, and they don't care if the code is nice; they just want something that works most of the time and keeps their business running. That and a support contract keeps them happy, and the developers can gradually issue fixes to reduce the twinges of sloppy-code guilt.
...
99% of the people absolutely don't care about the sources, why should they have to spend 20 more minutes downloading a bigger package if they absolutely don't care about it ?
Who do you think you are to require people to open their code ? If you don't like closed source software, don't buy it, it's as simple as that.
Authors also have a right to freedom, it's not only for the users.
how many people really would look at the code anyway? Most people don't understand coding enough to make it worthwhile. The people that need to look at the coding probably already have access to it through their software contracts. It sounds like a good idea, but not many people really care to look at the source of their programs in real life (other than the slashdot crowd)
While I think the _quality_ of the code, when released as open source will certainly improve; a corporation would not want the image of having sloppy code, I think this could be a bad idea in certain areas, particularly for propriatary military and defense department systems.
On the other hand, it could be a very Good Thing (tm) for those same systems because the Many Eyes concept would certainly "harden" the code. In the meantime however, more exploits and bugs would certainly be found, and DoD is not the type of establishment that wants to have known visible security flaws.
I'd rather be a conservative nutjob than a liberal with no nuts and no job.
The problem with OSS is that there is no money in it.
Some have said that the money is in tech support / documentation, but that is just as bad.
If your product generates enough tech support revenues to support a large project then you simply wrote horrible software, and chances are if you did write horrible software it won't be used. It's a paradox, so it probably won't actually happen. And people aren't that stupid - I hope.
And if you charge people for documentation, then I simply call that bundling. You are paying for a bunch of documentation that just happens to come with some software.
The way to make companies produce good software is to stop buying crappy software. It's pretty simple. If people stop paying for expensive tickets to go to professional sports then guess what, they will lower the price. It's simple economics of backlog.
"Not knowing when the dawn will come, I open every door." - Emily Dickinson
I have been wanting the source for this wonderful program for years. ;-)
If we take source to mean the building materials of a program, everything else is open.
Words of a novel can be yanked off a page. You can order enough parts, individually, to make your own car rather than purchasing it from a dealership.
You can always order wood and build a desk yourself. Got enough heat? You can make your own wine glasses that are exactly the same as those ones off the shelf. Everything, in reality, is pretty much open.
There's a difference with code, though. If I write a program, a person with the source can compile it and use it without having any sort of skill. Whereas someone lacking skill can *not* write Lord of the Rings. They can't build a car for themselves that I'd wish to ride in. Their desk would likely fall apart. Their glasses would end with them receiving severe burns.
If you wish to compare source code to everything else that's open, then, by the Gods, compare it fairly - compare the compilers, the availible libraries, etc.
The tools and materials are there. The skill? The skill is why source is often closed, and in many cases, should be closed.
http://saveie6.com/
No profit to be had in selling software? Tell that to MSFT!
I want my rights back. I was actually using them when our government stole them after 9/11.
What kinds of steel were the supports and cables made of? What was the mix of the paving materials and how thick are their layers? Did the contractors skimp on the re-bar? How deep were the foundations sunk?
Just try to get this information about any big public bridge. They'll say, "We can't tell you for security reasons." ...just like certain software vendors we know.
-Rick
...and the closed source version of a car wouldn't work, but you can pay for support to give you the run around and try to convince you that YOU must be doing something wrong.
come on fhqwhgads
Is it possible to have good products without "good code?" Depending on the product, I think yes. Do great videogames necessarily have "good code" or whatever the author decides is good code? Maybe, maybe not. For games, the distinguishing factor is not as much the coding (ie fulfilling the designer's vision) as it is establishing a good vision.
YES, maybe it makes sense for security related products, but don't get greedy and claim that EVERY product needs to release its code.
Another error in drawing similarity is that giving away code would beequivalent to giving away another bridge for free. (I'm myself not against that idea; I just think we cannot draw reasonable parallels).
The law of excluded middle : Either I'm foo or I'm foobar
belong in National Enquirer, along with pictures of two headed babies and Michael Jackson.
The article itself is just blatant flamebaited advertising. I fail to see how he addressed any of the points in his previous article (which I also thought was codswallop).
Did anyone ever see films of the Verrazano Narrows bridge collapse? There's an example of a bridge that looks fine on external viewing, (even by TRAINED experts), but doesn't work for real. Joe Average knows squat about bridges, and won't recognize a faulty design unless he's falling into the river with it.
As for the 1% of "real" code in a product - what a load! If your key code is buried deep in some subroutine, then how can you "remove" it from your product and still make it functional?
Feh!
To beat a dead horse - If we built houses like we build software, .....
When you buy a house, it is either pre-existing or soon-to-be-existing. In the case of the former, you can only know as much as the owner tells you, and the builder's reputation and the packaging. In the case of the latter, you can visit the site as often as you want (just don't be shocked if you see some beer cans sitting around).
I agree that most software sucks, but to say that you need to take the walls down to inspect the plumbing both trivializes a nontrivial problem, and tells one no-more-than 'next house on the list' inasmuch as they know what they are looking at.
For mass-market products like Windows, Office, etc, (ie, those where the users themselves are not computer science people), I'm sure 99% or so are absolutely unqualified to look at the source code and make informed decisions about code quality, so they'd have to trust some third party. And even if there is some software "Ralph Nader", how much influence it would have over those users who haven't got any idea of the importance of "good" code is doubtful.
Incidentally, the mass market products are those most likely to cause a security risk like worms or viruses, because of the very fact they are used so much by clueless folks.
I'm not saying it won't work, but it may not be as effective as it seems.
There's 10 types of people in this world, those who understand binary and those who don't.
Packing the source code along with commercial distributions of software is an excellent idea, and it's really a shame that it doesn't happen. It looks to me like the company would benefit the most from such a solution - for one thing, they could leave patch-making to the community and needs for support would possibly decrease.
GPL and things alike aren't the whole truth, either. If the source code is licenced such that it may only be modified in private and not get distributed, this will of course not promote OS, but it will be a great thing for the users, as they can fix bugs and add features for their needs.
As a fine example of OS commercial software, look at the editing communities for id Software's games. Granted, Doom, Quake and Quake II don't really have any great commercial value any more. Case is, though, that the release of these games' source codes have sported heaps of enhancements to the game engines and helped preserved the communities, resulting in a fantastic respect for John Carmack and id Software.
If a company or customer has the resources to fully and properly analyze your code then why wouldn't they just use those resources to write their own software; fully customized and programmed for their needs?
The biggest benefit I see to having it be open is history. We should establish an organization where people "check-in" the source of their commercially realesed product. That way, 20 years from now, when we desperately want to get at a document from said product, we might actually have a chance.
then again, by that point copyright will probably prevent us from looking at anything interesting...
-kscd
The lack of MS source has not in any way slowed the discovery/exploitation of Windows flaws. But because the only peoples looking that intently at the poor design of MS products are a) the people who poorly designed them and b) the exploiters and the kiddies who use their tools, the vicious cycle continues. Opening the source code could allow others with a more positive inclination in to help fix the problems and point out the potential future points of trouble.
As interesting as it would be to be able to see the source code behind such programs as Windows or Office or even ICQ, is it even that important?
.doc handling program that's free, for example. But even that can be effectively remedied without complete open source. Even a behemoth like Microsoft could be made much friendlier through some well placed stubs, open protocols, etc.
Windows runs like ass, and therefore it's a pretty safe bet it wasn't coded very well. I don't need to see the source code to figure that one out. And quite frankly, even if it was coded badly, as long as it were to run well, I don't think most people would care anyway. Hell, it DOESN'T run all that well and a lot of people still don't care anyway.
The only nice thing would be maybe if the source were available a few people would be nice enough to fix it up or something. Other than that, it's not too important, except for anti-trust reasons, so we can get a decent
As for everything else, source code just isn't always the best idea, or even very necessary. The government or other high security needing people should have source code, and experienced hackers to audit it. That makes sense. But other than that, to have everything done ONE WAY is usually not the best idea. That's the beauty of being able to choose a license or just make your own up-- you can choose the best tool for the job.
Error 2: printf undefined.
You forgot "#include <stdio.h>"
General Relativity: Space-time tells matter where to go; Matter tells space-time what shape to be.
Yes, it's possible to get certain specific bits of the code after signing Non-Disclosure Agreements and/or handing over large amounts of money. Get the whole of Windows source? Nope. Understand it all in any reasonable amount or time? Nope. Get busted by Microsoft for using part of their code in an OSS project? Almost certainly, and if in the process of trying to prove you didn't, you have to show Microsoft your code, expect to see a competing product soon after.
This article is pretty confusing, actually. Chris Connell claims that vendors should "Open Source" for transparancy, but then obfucascate the code by adding or subtracting code to keep it from being truly functional. Well, there goes the end user's ability to compile and test the code, to debug the code, and to really be certain that what you've got in the binary version is the same as what was shipped via source distribution.
He goes on to suggest that vendors withhold crucial functions or methods, and 'stub' them out in the source code. Well, those are easily enough to reverse engineer from the binaries and the debugger, so that's no real solution from the vendor trying to protect IP. And it doesn't help the 'customer' at all, because your still stuck with not having the full tranparency that Open Source is supposed to provide.
I'm actually not pro- or anti- open source. I kinda sit on the fence on this issue (Though I do like the BSD style license). However, I think that Mr Connell is trying to stand on both sides of the fence at the same time. It doesn't really work.
-jerdenn
In short, RTFA.
Ryan T. Sammartino
"Ancora imparo"
To put it simply, there is no profit to be had in selling software anymore.
/. poll.
Please tell me you are joking. Microsoft makes a lot of money off of software. How about Adobe? Macromedia? Real Networks? Symantec? The hundreds of game companies? Should I keep going?
I believe that source code should be released when the product is out of support (the source for Windows 95 should be release, for example). To release the source for commerical applications with many users (Windows 2000, Windows XP, even antivirus software) would just be insane because of the amount of hacking that would take place.
I do contribute on a few open source projects, but I do not believe that everything should be opened just because a few of us write code that is opensource. What is the percentage of OSS coders compared to programmers that code closed source applications. Might be a good
1. How many people would understand/follow the code? How many people would even be able to find anything of interest?
2. If it is really of life/public safety/importance, then the big bucks would have paid for the code/testing/standards already.
3. Seeing code != perfect end product
The surprise isn't how often we make bad choices; the surprise is how seldom they defeat us.
2) the resulting executable would not operate in a meaningful way without the key routines. Why bother? How would the customer test or debug it, or suggest extensions?
3) Shame on the designers; their indiscretion should be on display for all to see If you have the rare privilege of working in an organization that doesn't need it yesterday, is understaffed, and has to scale up very quickly, then I can see your point. The rest of us have to deal with a competitive marketplace.
I agree that open source has an important role to play in many types of commercial software, but this article is a trivial discussion of the problems involved.
I'm the CTO of a software development company called Intellinger.
We're young, new on the block, and competing against some big fish in the performance monitoring space.
One of the biggest issues we have is trying to placate potential customers that are worried about us going out of business and leaving them with un-supported code.
To get around this, we've put copies of source code, with docs, build environments/scripts, etc., in escrow. This way, if we DO go down in flames, all registered license holders of our software are entitled to complete access to EVERYTHING required to support the software themselves.
This keeps our investors happy, our customers happy, and us, the developers, happy. There's NO WAY IN HELL that our investors, or me, for that matter, would condone or support making our entire product OS. We've spent a couple of years working on this thing, and we'd like to get some benefit out of it.
There is an infrastructure (that we call Brazil) that will probably be put into open source in about 6 months, but the customized/specialized modules that plug into it that we've developed will NOT be made OS.
Obviously, our position could change in the future, but for now, it's not an all or nothing proposition.
$0.02 (CDN)
Apart from word processors, spread-sheets and other "untrusted" apps, banks and anybody else who spends upwards of six mil a year for development and maintenance, will damn well make sure that they get the code.
For some of their stuff on mainframes and PCs they HAVE to to comply with banking commission and/or SEC and/or government regulations. Its more than just a good idea, its the law.
They have to be able to TOTALLY reassure the auditors and inspectors that NOBODY is 'skimming' pennies from each transaction. When you're talking a trillion transactions a day, week, month or year, it adds up to big time fraud damn quickly.
You CAN'T do that with a "pig in a poke." They get the source code to keep the baddies who can shut 'em down from shutting 'em down.
MSBPodcast.com The opinions expressed here are my own. If you don't like 'em... Think up your own stuff.
However, for things that have other forms of protection, such as encrypted DVDs or executable source, there should be no copyrights, because, for such works, there's no guarantee at all that they will be available to the public when the copyright period expires.
What makes code good or bad?
Is it the resultant way in the program runs? Is it the effeciency of the code?
Finally, is it possible for two different programmers to look at the same source code and have strongly differing opinions about its quality, or is it a pretty much agreed upon criteria?
While I honestly do not think that an idea such as this will ever come to fruition, I cannot help but wonder at what the standard of judgement will be should it occur. If code is deemed to be good or bad based solely on subjective criteria, then I think the whole idea is doomed from the get go.
If brevity is the soul of wit, then how does one explain Twitter?
Well, yes and no. If you compile it as straight C code (with a .c extension) it will work without the include (using gcc or cc). If you compile as C++ (with a .cc or .cpp extension) it will give the error you stated.
come on fhqwhgads
If you pay for a tailored product , then you should get the source code. Point.
Now if this is a comercial distributed product , this is another kind of problem and what you said above apply.
C. Sagan : A demon haunted world:
http://www.amazon.com/gp/product/0345409469/
visit randi.org
In an academic, Computer Science research sort of way, you're probably right. And there is a lot of common code in many applications, it's true - but that's what vendor-supplied and third party
The #1 cost in most software is time - to design, to code, to test and to document. That's what adds value. What you are saying is like saying that "houses should cost no more than the bricks they're made of, or that cars should cost no more than what the iron ore cost to mine. Hell, iron ore should be free, right, it's just sitting there in the ground waiting to be dug up!"
Here are the facts:
People like you will continue to say that software should be free, and you'll keep coming up with ways to justify your belief. That's fine, because you're fighting the laws of economics, and they're just as implacable as the laws of thermodynamics.
They spend hours and months poring over the code, providing traceability and working on correctness because if they fuck up, people die.
I wonder if people expend the same effort on the embedded software that controls traffic lights. Seems to me that borking traffic lights are a lot more likely to kill large numbers of people.
"I have opinions of my own, strong opinions, but I don't always agree with them." -- George H. W. Bush
If 1% of the source were to have the magic, then if that part is hidden, basically all you have left is gui and i/o. So What's the Point of releasing it?
Furthermore, this guy somehow thinks that removing the #define is an effective barrier to piracy? I think I heard of something called a symbol table at some point.... maybe that would help black-beard?
This guy is just trying to stir up shit so that he can make a mark. The only customers that would be dumb enough to hire him, are the same ones that would believe his inane ramblings.
Good luck Mr. Connell, if you ever have a good idea, feel free to share it.
The entire point of his article is flawed. It seems he wants to open source just so that people can point out the 'bad design' or 'coding gaffes'. Now, I write a lot of code in a day, some good, some bad, and probably even a bit brilliant, but if it gets the job done properly and well, nitpicking over 'bad design' is just that.
I'd imagine a lot of really great code is fugly as hell, and just because code is design well doesn't mean it will do its job well. The two are relatively independant, unless you like to take a holier than thou stance, which it appears this article is doing.
In Other news today Molson and Labbat both changed long standing policies and decided to give away their recipes in every two-fer purchased
Canadian Geeks everywhere cheered Free.. as in Beer
The More Knowledge you have the Luckier you Get- J.R. Ewing
The benefits of Open Source or Free software to its users are undeniable. If the software has a bug, or the software does not do something you want it to do, you can change it. There are many advantages, and they have been explained at length by various people. If you are going to be using software, you are definitely better off if you have access to the source code.
Trust
The fundamental difference between open source software and closed source software is the level of trust required. For a business to use closed source software, the level of trust required is enormous. It is not simply a question of whether the money spent purchasing the software is a good investment. The time invested using the software is far more significant. Almost inevitably your own business information becomes tied up in a format that is specific to the software you are using. In order to buy software from a closed source company, you have to take the following on trust:
- They have not left gaping security holes in the code.
- They will fix bugs in a timely manner.
- They will eventually add the features you want.
- They are not using your computing resources to do things which are
not in your interest.
- They will not increase the price unreasonably once you depend on them.
- They will not go bust.
In fact, when you consider all the things that people are expected to take on trust when they purchase closed source software, it is amazing that anybody ever does so. The truth of the matter is that very few organisations properly considered these factors before they bought the software. They bought the software because they needed it and although there are terrible dangers involved in relying on closed source software, there is often no alternative. Companies and other organisations are only just starting to wake up to the dangers of closed source software.Business Models Having access to the source code makes good sense to the users. However the business case for the software vendor is far less convincing. In fact, the dangers of closed source from the user's perspective can be considered opportunities from the vendor's perspective.
The open source foundation proposes "4 ways to win" which is reproduced here: Four Ways To Win
Now for a higher-level, investor's point of view. There are at least four known business models for making money with open source:
In fact, the number of companies that have had success with any of these models is miniscule. This is hardly surprising, they are simply not very good business models for software companies.
Taking each in turn... Selling Support The better documented and more reliable the product is, the less support it needs. A business model where the more perfect your product, the less money you can make has got something fundamentally wrong with it. Loss Leader The very fact that this can be advanced as a viable business model for OpenSource shows desperation. What it comes down to is an admission that the best way to make money from software is by selling it. Widget Frosting This makes perfect sense if you are a hardware company, or when the software is a side issue. However, its no use at all for a business whose main product is software. Accessorizing Selling accessories is fine, but there is no pressing need to actually develop the software when one is in the accessories business.
There are of course other business models for Open Source. For instance, the one adopted by the Perl foundation and several others is begging. This is not a business model that many companies would find appealing though.
The basic problem is that for a business whose primary function is to make software, then the primary reward has to come from selling the software. We need a business model that actually works and we have one, it's called capitalism. It works like this: make something that people want and sell it to them. This model works for software too, and there is no reason why this model cannot work even when source code is available. Closed source vendors are relying on something a little closer to the business model of a heroin pusher. It starts off like capitalism, but there is the added feature that the user gets addicted and has to carry on buying the same thing even if he does not really want to. The more he uses the same vendor, the more reliant he is upon it.
The Solution Community software is software where the vendor can be paid a fair price for the software he creates, but where the buyer does not end up in a similar position to a junkie.
Community Source is software that guarantees the following:
- The right to see what the software is doing, ie access to unobfuscated source code.
- The right to add enhancements.
- The right to fix bugs.
- The right to sell his enhancements to other companies. This does not mean the right to the sell
software without the original vendor receiving any money. The buyer still needs a license from the original vendor, but he does not have to rely on a single vendor for upgrades and enhancements.
- The right to buy enhanced versions from 3rd parties.
Together these provide a guarantee that the buyers investment in the software is protected. The benefit to the software vendor is that he can sell to larger companies without them being scared of buying from an outfit which might go bust or be unable to properly support them. It is better for the client than software escrow since the client knows that if the original vendor does not maintain the software well, then someone else can do so.http://rareformnewmedia.com/
The assertion is that peer pressure will create better code. That indeed may cause some corners to get smoothed out, and some blatantly bad coding practices to get exposed. But fundamentally, it's not going to give the devlopers an extra three months, etc. to make it better! If a company has X dollars to put out a product, then you get whatever it is that X dollars will get you. Showing the code post-delivery will not have changed what you got in the first place. But back to the bridge: if there's only one bridge to cross, you're taking it, even if it's poorly built! But, if there is a choice of bridge to take, then the result is obvious.
Ok, I thought the first one was pretty off base and utopian in it's thinking, and I don't think this one-page update to the artice does anything to improve matters.
:-)
/. crowd - we all know GCC or compiler of choice like the back of our hands. Or, for some, the palm of thier hands ;-)
/. crowd's heads part of the time (picking an arbitrary number here) So what point was it in handing the source for a accounting system to someone who who is a systems administrator? Parts and bits of it make sense, but, without the background in accounting systems, there's parts of it that could cause more grief than it's worth for a simple change.
Now, before someone decides I'm an anti-Open Source type o' guy, forget it. I'm not - I use Mozilla (1. 2 - woohoo!) for my browsing and mail, and Open Office as a most-of-the-time replacement for MS-Office (*SIGH* I still have office loaded for a few oddball things OpenOffice doesn't do right.) I've got a nice firewall (linux) and fileserver (linux) all running open source operating systems.
So, consider that before markin' it as troll when I say... Oh, PUHHHLEEZ!
Look, makin' an application Open Source does not garantee quality. It does not reduce code bloat (in fact, I'm starting to believe that at it's core, the Open Source way of doing things is starting to increase code bloat. However, the really slick thing is bein' able to fix that on a personal level with a simple recompile most of the time! But, that's a totally different article to write...) It does not garantee an increase in quality - just because you can LOOK at a bridge's construction, do you fully inderstand the architect & engineer's design methodology? Would adding another bolt hole here and throwing a bolt through it increase or decrease stability of the bridge. You have to be a specialist in the field to truely understand (just being an engineer doesn't cut it - you need to understand BRIDGES before you work on a bridge
Same applies to software engineering - while anyone could look at the source, and start hackin' at it, that does almost nothing for other people in the first place. You've got to redistribute the improvements, get it back into the source tree, and convince other people to re-compile before you do it. Most of the steps above require specialized knowladge of one form or another. (Before someone debates that point - no, not people don't understand how to run a compiler. I'm not talking about the
But, even then, some of this stuff is way above 75% of the
There's also somehow the impression that this would "change things". That somehow, because of magically having the source code available, this would make products better. Well, it's not going to increase the quality of the code from the original company who released it. And unless there's a clearing house for everyone to update thier application, what's the point? Overall quality doesn't improve, only single installations (or corporate installations where someone made the nessisary change and distributed it on the desktops - which to be honest, DOES indeed provide some promise to the concepts he presents in his article. Corporate licensing would be handy.)
Tech support becomes a nightmare too - "Oh, sir? You changed that bit of code? Sorry, can't help ya..." Let's face it, it's hard enough to support an application and all it's versions - it's hard to support it when someone can make a simple change. Add a public code repository to it, and man it just gets worse. Once the code is touched, there's no support anymore. (But, of course, if you know enough to mess with it, is it a downside? *SHRUG*)
Licensing would become an even deeper nightmare. If companies are putting horribly restricting EULA's on compiled products, imagine what they are going to want to do with the source? Sure, he talks about how to protect it with copyrights and excluding certain modules (more on that in a moment), but, companies aren't happy with copyright now, how will that improve with source code involved?
And of course, there's this interesting idea that you could just exclude some modules. Well, that does a couple of interesting things. 1, it defeats part of the purpose (but not all of it.) So there's still parts of the code that's buggy and unreleased. Whoo... what exactly did we fix there? 2, it would be an absolute Haven or Hell for Open Source developers. Companies would fall very quickly prey to people who simply replaced that core module, and suddenly have a working application - no need for the original developer anymore, just release a new open source core for the program. Open Source developers are going through a lot of effort to copy the current functionality of an application - if there was an even shorter route to gettin' the job done, someone would end up doin' it. Of course, given the paranoia level of some companies, Open Source developers could end up having to deal with ELUA's that prevent you from having looked at another company's source tree and writing your own. MS is already attempting this with a couple o' items. Why would the situation improve?
While it's an interesting set of thoughts, to me it comes down to a combination of personal choice, and company motivation. If you want the source code to an application, then choose your application wisely - use Open Office over MS Office. Linux over Windows. Etc. Almost anything out there has an Open Source equivalant (almost, not quite.) Use it.
As for companies - it's up to them to decide what resources become available to the end user, and under what license. If I can get one more feature out of Mozilla (contact synching with Windows CE... er.... PalmPC machines, not just PalmOS machines) I'll begin moving everyone in our offices to it - the combination of MS's licensing and features -vs- Mozilla's Licensing and features will make it a logical choice. Companies are now starting to have to take that sort of thing into account already - I'm not the only commercial developer out there deciding how much of my application (games, in particular) source I'm going to be providing to the end user. If Collaborative Source, Shared Source, Open Source, or model of choice where the user gets the source code, is truely of importance to end users, we'll see it happen. And the companies that didn't follow that path will have a hard time - adapt or die.
I personally choose to have applications that have the source available, as long as everything involved fits my needs. And, not including the "Everything should be free" crowd, I think that' show most users will have to make thier choice anyway.
Davis Ray Sickmon, Jr - looking for something to read? Check out my three free novels at MidnightRyder.org
The original article (and the subsequent followup) attempt to solve a problem using a desired tool, rather than looking for the right tool for the job. A lot like the old saying "If all you have is a hammer, everything starts to look like a nail."
The base problem that I think he's trying to solve here is that software quality is abysmal. That is, all commercial (and most free/open) software is riddled with bugs, many of which are well-known at ship time, but haven't been fixed.
Making source code available (whether as Open Source, Free Software, or a eyes-only copy-restricted) is orthagonal to this problem. yes, maybe, it could help. But that's incidental to the Free/Open software movement. And (as many people have pointed out), there are many problems with providing source with all programs, most of which are massive barriers to any help with quality of the software.
The fundamental flaw here is that commercial software's quality is the producer's responsibility, not the target audience's. In Free/Open software, the developers and audience have significant overlap, so it can be truly said that the audience can help quality. This is patently untrue for closed-source programs: the development community is very tightly controlled, and the user community has no real method of influencing quality (other than by not buying the product), even if provided with the source code.
So, this leaves us with the case of how to make the developer's produce better quality software. Fundamentally, we do this the EXACT SAME WAY all other industries insure minimal quality control: LEGISLATE IT. There are oft-quoted sayings about "if the car companies built cars like software companies build software..." and others to that effect. They all point a massive discrepency in the legal status of software: it doesn't play by any of the traditional product-liability and quality-control laws that every other product industry abides by. Yes, that will change the nature of the software industry: that's the point. And NO, it will not harm Free/Open software (as gifts - i.e. giving away something - are not coverd bty under the various product-liability laws)
You really want to fix the software quality problem? Require that software companies have a warranty of fitness. Require them to refund money for defective products (opened or not). Make them liable for damage caused by known defects. In short, treat them like anybody else. Software isn't special. It's time the software industry grew up.
See my previous post on why the software industry should quite being treated like a spoiled teenager.
The problem is real. The solution provided by the article is wrong. I'm right.
:-)
-Erik
There are always four sides to every story: your side, their side, the truth, and what really happened.
The source is part of the product.
Hm. I think you missed part of how the market works. The Product is definied by what they throw in. It's thier choice - if they throw in the source code, it's part of the product. If they don't throw in the source code, it's not part of the product. The end user does not determine the extent or limitations of a product, the producer of the product determines those things.
Now, the issue of if it SHOULD be part of the product - that's a different story. Putting it into the analogy of real-world products - What you want in this case is a set of blueprints, architectural drawings, etc. that went into producing the product. (Ok, VERY loose analogy - maybe what you want is the CNC code that went into running the machines that made the molds, and the automation code that went behind creating the product.)
Davis Ray Sickmon, Jr - looking for something to read? Check out my three free novels at MidnightRyder.org
An interesting idea, but:
That said, I agree that it would be great if more vendors shipped the source with your product. However, people just want software that works. They don't want to have to hire someone to fix the bugs in the software they bought that was supposed to 'just work' in the first place. Where it would be more useful to have the source is if you've got a system that has been around for a very long time, and it needs to be extended in some way -- especially if the original people who designed the system are not around any more. Anyway, I just wanted to point out the big 'might' in your statement.
The linux kernel, for example is a HUGE program. Much larger than many (most?) commercial products. It is constantly modified and dissected by thousands of interested users
/. reader, how many of you have ever taken a look at the kernel source? How many have actually tried to understand any piece of the source (vs a casual browse)? Like the person said, there is a lot there, how much coverage does the "kernel" really get. Somehow I think that the "thousands of eyes" effect is quite overstated when it comes to OS, but I would be curious to see a show of hands and opinions.
OK, I hear this over and over, so I ask you, the average
What must be realized is that, with a decent debugger/decompiler, it's possible to reverse engineer executable applications without the source code. It has been done for ms-windows, by Andrew Schulman et.al. some ten years ago, when they published a series of books on windows and ms-dos internals.
It can be done for hardware too, there are methods for dissolving chips layer by layer to photograph the lay-out, from which a schematic diagram can be recovered. It may be even simpler, if off-the-shelf chips have been used. I was once given a circuit board from which the manufacturer had scraped the chip part numbers. After removing the chips and reading the printed circuit connections with a multimeter, I put each chip in a test jig. Without much effort, I found they were all 4000 series CMOS chips and easily found the part number for each. It took me less than a half day to reach the exact circuit schematic, which wasn't very orignal, nothing that a patent could be applied for.
He forgot:
"I don't want to show the source because we make a ton of money from crappy code and the maitaince fees we get for fixing our bugs."
You laugh, but I've heard statment very similiar.
Of course if people would stop paying companies to fix broken code.
We just bought some code, it had some bugs, the company wanted 200.00 an hour to fix bugs in there code. Outrages.
The Kruger Dunning explains most post on
I find the article somewhat lacking. The points from the other side which he addresses are ones which the open source movement has addressed from day 1.
Anyone who understands the open source movement already knows that peer review is superior to any internal QA process. Despite what the FUD claims, there is little question that the quality of open source software has been higher than that of closed sources software. I think the fact other people might see their software as "lousy" only accounts for a very small % of the reason why most software companies are not open source.
Intellectual property is a much bigger issue, one which the article's author failed to address properly. Right now, I may have no clue what the best way to design a piece of software to do some particular task. If some other vendor has already designed that piece of software and released the source, I might not understand the details of what exactly is going on, but it would not be too hard to get a high level understanding of how the software works.
From there, creating the better mousetrap becomes a much easier task. The design of the software is often as time consuming or more time consuming than the implementation.
Sure, if I used their work in the creation of mine, I have created a derivative work. However, copyright law is a very grey area. If I kept my work closed source, how could anyone prove that I didn't steal my design from their product? They could sue me, but it would be at great cost to them, and if enough of the implementation was changed, they may not even win.
Managing any company successfully is not a trivial task. Executive board meetings are not filled with people who want to create poor software and hide that fact from the consumer. However, when someone presents a concept that could a) help competitors get into their market and b) result in a huge loss in revenue (directly and indirectly), what do you expect them to do? If you were a developer at that company, what would you want?
Regardless of how good you are, there's always going to be someone better out there. Most companies are realistic and realize this. Why give them an edge on your company's business? Do you really want to be out on the street that bad?
Overrated Moderation: This posts sucks... because.
Long ago in a galaxy far far away... ... it used to be that ALL software was distributed in source code form, and then built by the customer prior to installing and putting it into production. The industry would have left things that way were it not for the fact that we were increasingly running into a number of big problems not solvable in that model:
- Customers didn't follow directions, so they always were screwing up the build and/or install. These were very simple tasks back then, much simpler than they are today. And in theory customers were far more educated since they were the very few who could afford those multi-million dollar machines and the huge costs of the rooms and facilities they required. Somehow, though, they still were able to find ways to screw things up, and support organizations spent much of their time walking
customers through these processes.
This would be worse today given many software users have no clue how to program.
- Support was a total nightmare as you never knew what source code customers were using.This was because customers would choose which patches to apply, and would add their own, leaving each customer with a totally unique piece of software. When something went wrong in it, it was impossible to know what the code was supposed to be doing, and what it was doing wrong.
While this might not be quite as bad today, since we no longer must rely on "core dumps" to diagnose bugs, there still is the basic problem of being asked to diagnose problems when you really don't know WHAT source code that customer might be using.
- the intellectual property problem... there were plenty of lawyers back then, but there really is a big problem with investing lots of money to build something, a unique set of code, and then making it easy for people to lift it. A variety of methods to secure it while still distributing it to all customers were attempted as there was tremendous cost associated with changing from a source distribution technique to a binary distribution technique, but none ever worked. If anything, today there is far more sophistication on the cracking side, so it seems even more doubtful that it is possible to secure code from mis-use when its considered IP. And there ARE valid arguments against giving away all code.
SO...
There were good reasons the computer industry turned away from distributing their software in the form of source code. I don't think they have been addressed, and thus I am unconvinced the equation has changed.
It seems to me that the actual code behind a program isn't all that important. Sure, you might come up with a beautiful algorithm, but for most problems that a programmer deals with the most efficient algorithms have already been discovered...and published.
What's impressive to me is that someone saw a need and designed a program to solve the need. If anything should be patentable, it's the general solution. For example, the chair I design might be patentable, but the way I put the bolts and the nuts together is well understood.
No to take anything away from the programmers. It's not that putting everything together is easy. But, even if you write an elegant solution to a problem there are 500 other programmers who might very well have solved the problem in the same way you did.
IMHO the real challenge is finding the need.
Kind thoughts do not change the world
at least in the whole, with the author's premise, although I do believe the background philosophy to be sound. There are certainly cases where it is not to the advantage of the code *producer* to open their code.
However, those that claim the availability of code is worthless to 99% of the users are missing a key point. It isn't important, per se, that certain code is available to *me.* It is of great importance, however, in certain cases, that source *be* available to all comers.
I've never hacked a kernel and have given the code nothing more than a cursory glance out of pure curiosity. However, I *personally* benifit from the code being openly available nonetheless.
The same goes for emacs and vi. I use both. I've never so much as glanced at the code for either, even out of curiostiy, but I *personally* benifit from all the people who *have* looked at the code and contributed. I benfit from the features they add, from the bugs they squash and the support they provide.
What's more it *is* a benifit just to know that if the projects are ever abandoned I *can* get the code myself and learn my way about it.
You may not fix your own car, may in fact be mechanically "all thumbs," and yet *you* derive great benifit from the fact the Chilton publishes freely available workshop manuals.
Open Source is just such a workshop manual and its availability always benifits the greater populace of users.
The code producer is another story.
KFG
Hell Evian sells water in bottles. We all know the flipping chemical formula. Hell, it comes out of the taps in most of the industrialized world. What they are actually selling is the packaging.
THAT is where the money is.
"Learning is not compulsory... neither is survival."
--Dr.W.Edwards Deming
As much as I hate DRM as a user-limiting technology, when it comes to programming code, you at least need something.
If your source was Open-yet-Copyrighted, the law of the land is on your side to protect you, but the laws of physics are not.
What if somebody was to take the critical for loop from your program, change the variable names, and then release it as their own. That's a definite copyright violation if you can prove that it happened that way, but if the other guy's claiming otherwise, it's gonna be one hell of a lawsuit.
Maybe the performance of the software might have something to do with how you rate it. I'm not against making software open source, but I can't honestly say that I've heard any argument for it that made any sense. Do you also want a complete parts lists and break down of the engine theory for your car?
I assure you that NO ONE has seen ALL the source code for Excel or Word (or any other of the "too big for our own good" line of MS products).
"We shall party like the Greeks of old! You know the ones I mean." - HedonismBot
Freedom is a sloping mountain and everybody wants to get to the summit, forcing all software to be open would be climbing up over the top and then starting down the other side. Nobody should have their creations FORCED away from them, it's THEIR creation, so THEY should get to deside how to distribute it to people. Ideally all people/companies would open their software, but that doesn't mean that they shouldn't have the right to refuse to open it.
;-)
Richard Stallman has talked about how all software should be open and that's always been where I start to disagree with him. Again, I agree that it would be beneficial to the world if all software were open, but I still think that people should be given the right to choose whether or not they want release it as "open".
Oh well, it's not something I really need to take a whole lot of time thinking about and defending against because it's really an unpassable law (and pretty unenforcable too). Just think about it, it'd be about as unenforcable as anti-piracy laws
Saying "All source should be Open" implies he means Open Source. He doesn't - he just means the source code should be available. See later in the original article when he tells readers to "Note that I am not advocating open source licensing for commercial software. ".
You're exactly right. When I buy a piece of software, it should work, period. I shouldn't have to look at source code at all, just like I don't have to ask Honda who makes their starters, and in turn as the starter manufacturer who they buy their windings from, and check out the winding manufacturers, and check the quality of the copper. That's bullshit. Software should be warrantied, and if it doesn't work as sold, it's fraud. Period. Software license agreements that say "we don't warranty this product" need to be challeneged in court because they are simply illegal. Just like those truck on the highway that say "we aren't responsible for damaged windshields". That's bullshit. They're carrying gravel, it's uncovered, gravel flies out and hits your car, they're liable, regardless of what the back of the truck says.
We need to see some civil cases in which software companies are challeneged based on nonperformance of their products. It's not my responsibility to check the source code. My responsibility ends when I pay someone for the product. Period. I don't want to see the source code. I want the product to work.
What are you comparing against? How do you know it hasn't slowed it, the source has never been available.
It's fair and reasonable to assume that if everyone had the windows source, a great many more flaws would be found, quickly. It's a thousand times easier to find buffer overflows when you can analyze the source than it is without it.
On the contrary, software should have no secrets, trapdoors or hidden features (excluding games). An operating system should not be like a conspiracy novel. Even if the source were not 100% open, the system should be fully documented. Of course the source is the best possible documentation you can have, in terms of not lying or hiding.
Escher was the first MC and Giger invented the HR department.
I do not see why source cannot be an integral part of the product. Yes, I am a developer. Yes I do want to be paid.
Let's look at the problems described in the article:
1. Piracy.
How is having the source making it easier to pirate things? People have been swapping microsoft binaries for ages. It is actually easier to just copy the installation disk (whether floppy or cd) than to recompile the program from sources.
2.Copyright laws.
Wouldn't it make it actually easier to check if people conform to copyright laws? If I release all of my source code and you are required (by the marketplace perhaps, not as a law) to do the same than it is quite easy to see if you copied some stuff of of me. How many people have wandered whether Microsoft has copied some code from GPL licensed programs (I doubt it personally). How many have the opportunity to CHECK if they have?
3. National Security.
I do not have a lot of confidence in a nation that bases its security on the ability to sweep them under the rug. The idea is to avoid having those problems in the first place! Maybe if this practice became accepted we would not have destroyers being run on windows.
4. Safety-critical applications.
Even if there is little to gain from having this code available to the users - not having it is worse. What are you trying to hide? If this is a safety-critical application then the answer should be "nothing, have a look".
Nobody is asking to release the source code without compensation. It's just that the source becomes part of the application. IF most people will not use it - then fine. What are you worried about? Is your code really that bad that you could not write good code if forced to?
It happens in cases where the source is part of the product.
Giving away source is adding value to a product; you not only get the product itself, but the ability to completely modify it to your own needs however you want.
Many companies WILL give you source, for a price, and a contract to protect them.
Some products DO include source, where it makes sense.. my favorite example being Starbase's Codewright. Codewright is a wicked cool programming editor, it's not cheap, and you pay per-seat, but they provide full source by default, so you can extend the editor to meet the needs of your development environment.
This makes sense, as the product is geared towards programmers themselves.
My mom, however, does not need to pay for the added value in the Office source, were it available; it means nothing to her.
Does your car come with blueprints and CAD design CDs? Does it even come with a parts list? No. Does your computer? Does your washing-machine? If they are really nice, your washing machine will have a little schematic in it for the repair guy to plug in his multi-tester and have a clue which overly expensive part to replace but you get nothing more.
Just because we currently get LESS out of software, ie. a guarantee only that the media is readable not that it actually works, doesn't mean we should expect more out of it anywhere else.
$#!^ happens, but why does it always have to happen to me???
Typically you would use proprietary formats to lock your users in to your solution. That is, what good is a file if you are unable to open it?
And while lock-in, tie-down, etc, is all well and good for business NOW, it is horrible for business in the future. What if the vendor goes out of business? What if the vendor no longer supports that app (and assume that you don't have a contract) - nothing short of a pre-signed service agreement could force the vendor to do anything about your obsolete files (although a good company would do it anyway to keep the client).
Tie-ins also keep your competitors from competiting on features. That is, if you have invested thousands (or even millions) on a particular solution, you'll probably think twice about moving to another solution if that means you loose all of your data.
I believe in giving clients access to source code for nothing simpler than letting them customize it to their absolute needs over time. Something like "here's the code, we're here if you need us (and it'll cost you) or you can do it yourself, have fun" - is much better than the closed way of "here's the program, if you need anything done we're here (and it'll cost you)."
But you must respect the IP in business. It's not nice to expose your blueprints to potential competitors. So if giving your code to your clients is not an option, an escrow service would be much nicer ("if we ever go out of business, you'll get the code") than simply abandoning the code to the annels of reverse-engineering.
Sorry for wasting your time, there was no point to this.
Price, Quality, Time. Pick none. What, you thought you had a choice?
something like
"Be sure your sins are born in secret!"
Meaning that you are FAR more likely to do *naughty* things, if you feel that your naughtyness is secret and won't be found out.
Its an old saying and it damn sure applies to programmers!
In the free world the media isn't government run; the government is media run.
News for Geeks in Austin, TX
Commercial software sucks because there is very little direct profit to be had from refactoring your code base. In the general case, you're lucky if your company survives a major refactoring.
More generally, commercial software sucks because users demand that it suck.
Why? Because it is clear that the original lawmakers were aginst the extensive use of trade secrets as a form of competetive advantage. This is the entire reason that patents were conceived. If you have a secret formula, you get a patent on it and reveal the secret in return for a limited time monopoly on the use of that formula. The public benefits because your innovation doesn't disappear when you die, and they can build on your knowledge as soon as the patent is published. You benefit because the risk of somebody reverse-engineering your formula is eliminated.
The other major form of IP, copyrights, applied to literature and music, which by its nature is non-secret. In addition to stimulating production of new works, copyrights also encourage people to openly publish works they might otherwise only release under NDA.
Notice that both forms of IP, as originally conceived, are intended to reduce secrecy. Somehow, though, when software came along, people forgot the original principles under which IP protections were created. Software binaries are naturally a secret formula. The founding fathers wanted to discourage secret formulas by granting IP protection. However, binary-only releases were given full copyright protection with no requirement that the secret formula ever be released.
The public never gets the benefit of the secret knowlege that is protected by the government force that is handed out for free to the creators of binary software releases. Software patents are often of little use to the public because they usually detail only a tiny detail of the entire system. Enough to block competetitors from building a competing product, but not nearly enough to reveal in detail how all of the APIs and file formats work.
At any rate, I don't think that either copyrights or patents are a good match for software, which is a product unlike any physical good or work of literature. They should have invented a third form of protection just for software that balances the interests of the creators and consumers. Kludging patents and copyrights (simultaneously) onto software, then letting the creators keep it all secret anyway, has created huge distortions in the marketplace which tends to create monopolies, buggy code and noninteroperable products.
Can you back that up with any kind of evidence? Even anecdotal?
A person who believes that removing constants from your source code imparts protection from international copyright hijacking, probably can't back up anything. I'm going to take a wild guess and say this guy hasn't written any real assembly source code in his life, or he'd know just how stupid his assertion is. If you're cutting out constants (not macros), I'm betting that in 30 minutes I could be set up to recover one of them, and each one after that would take about 30 seconds. Why can't we moderate articles as -1 Troll??
Education is a better safeguard of liberty than a standing army.
Edward Everett (1794 - 1865)
I don't think this is necessarily a stupid idea, but it's wrought with problems.
/. post). Saying that the entire software industry should start distributing source with their applications is ridiculous. On the other hand those folks out there that are making really kick ass apps with really clean and beautiful source might benefit from releasing their source. They can say, "Hey, look at our code it's beautiful. Our competitors don't let you look under the hood, ever wonder why?"
Providing source code should be left up to the individual person or company who wrote the software. The market would dictate whether you provide source or not. If your competitors all provide source and you don't; you will probably have to provide the source or adjust your price.
Providing source that has functions and constants removed sounds like a simple thing to do, but it requires effort on the part of the software maker. The amount effort depends on the types of things you will have remove and how well your software is designed. Having to take into consideration the aspect of providing a stripped down version of the source during the design of the software would seemingly increase the cost of the software. Having to maintain a separate source that gets shipped with the product and the one you develop with would increase the cost of the software.
I write code that I release under the GPL and I write code that no one gets to see but me. The code that is mine and mine alone is my bread and butter and the GPL code is for fun.
There are rarely solutions that work for an entire industry. Remember when everyone said, "Everyone's switching to Microsoft, that's why I am." Well now everyone is not switching to MS; there are very few absolutes (other than I take a shot at MS in every
But what's good for one business may not be for another. It's a business decision that is mostly dictated by the particular market the business is working.
LoRider
Tomorrow, I going to my boss and I'm going to tell him "we can solve all the software quality issues. No more worrying about underfunding, time to market, sudden mid-development directions changes due to marketing stupidity, expensive yet crummy dev tools, poorly spec'd requirements, weird hardware, lousy host o/s's that are chosen for the sole reason that "that's what everyone uses", unrealistic expectations from senior management, competitive pressures, ridiculous stock market and share holder expectations, etc., etc. We'll just release all the source and the developers will be shamed into fixing those issues from the bottom up. Let's go out on a limb and be world leaders here!"
The following day, I'll go to the employment office.
No argument that there is a lot of bad software out there. No argument that some things have to be done. Yes, developers could do a better job, but that is only a very small piece of the problem. Whole books with a multitude of recommendations have been dedicated to the subject. But no more magic bullets, please. This is not a simple topic and requires a top-down re-think (that I don't see hapenning).
Note: I am not against open source - I quite like the concept and I'm trying to find the time to get involved. But that is not what this is really about.
Sigs are bad for your health.
Like the bridge analogy, you can see that the bridge is sturdy and will hold a sherman tank. That's swell. What you don't see are the misplaced rivets that will cause the bridge to fail in unanticipated ways.
In other words, this is a kick-ass design, and I didn't notice that off-by-one bug until it was too late.
Another thing to ask is what do people really want? Bug-free software? Of course! And you know what they say they really want on airlines? More legroom and good meals!
Unfortunately, airlines that provide more legroom and good meals are running in the red. Unsurprisingly it turns out what people meant is they don't care about legroom and actually want the cheapest possible tickets and on-time flights. They complain that Southwest Airlines sucks, but everyone still flies with them!
My point is that people want the cheapest possible mostly-working software. Let's say, for the sake of argument, that there somehow existed some kind of free operating system for which anyone could look at the source. Would it have fewer bugs than closed-source OSs? Possibly. Is that really important to people?
No--really. Is it?
Code produced internally is a different thing and I wouldn't expect companies to publish in-house code to the rest of the world but I would never accept a binary again unless I had no choice.
Yes, this means that a whole bunch of business models from the dawn of time are obsolete but that's life. I'm not going back to gaslamps and I'm not going back to closed-source.
TWW
"Encyclopedia" is to "Wikipedia" what "Library" is to "Some people at a bus stop"
your walking analogy makes better sense when paired with reverse engineering, which should not be illegal.
I want 2D games back.
when you buy a radio do you get the schematics for how it was built and with what parts?
When you buy a painting does it come with an instructional video starring a hippy with an afro on how to recreate it?
I don't care how you guys think, not everyone else is into open source. You think source should be open, alot of developers like to keep their work secret.
Does David Copperfield show you how he does his tricks? I don't think so.
To say that everything should be open source is absolutely ridiculous. Why should any company be forced to go the extra mile and clean up their source and make it available and ship it and support it when it gives no extra income, or 99.9% of the population doens't give a rats ass about it.?
Is source code really equivalent to blueprints? Blueprints to me means more the high-level design and architecture. Now that may be included in what the author here means by "source" - certainly in some cases it is included as comments. But really software is something that exists on many levels: machine code (binary), source code, algorithms and design patterns, requirements and specifications, etc. Having source code allows the user to re-compile with various optimizations; even to debug, and to compile for other platforms, but it doesn't necessarily give the whole farm away...
Would it satisfy the question here if the source code were run through a munger that removed all comments and randomly changed all variable and method names?
Anyway, I feel all this would be a lot clearer if the copyright law on electronic files was a little more widely accepted and understood...
Energy: time to change the picture.
Actually, yes, I am willing to pay for good, solid software. Being a former developer, I understand the time and effort that goes into software, so I know that it would be a good bit more expensive. That's why I chose W2K over Linux. It "just works". That's why I chose my expensive POS system over a freebie. It's extremely critical to my business (and me being able to support myself). It works. But, I still don't feel like I have legal recourse to go after a company with software that doesn't work as advertised. I don't have the time & money to set a legal precedent, but I wish that somebody would. I'd also pay for a hard drive that worked for a long time and had a good warranty. I also pay extra to buy Japanese cars that last longer, and have better warranties.
So many software buyers feel like they're at the mercy of the software companies. Software quality is just abyssimal compared to other products. Then, they all try to claim that "our software may or may not work as advertised, and we absolve ourself of any liability". I know of no other product on the planet that is sold this way.
If it's closed source, it's very unlikely to be infringement, and there are different rules covering behaviour anyway. Not that the US patents office is much to be proud of, but that's a different issue.
You miss the point completely.
The problem is not some guy doing a quick search and replace across the source. The problem is when your code embodies trade secrets, such as algorithms you've researched and developed yourself. If your competitors can just read off your algorithms, reimplementing them in some completely different form, or even in a completely different language, is easy. No five-minute tool by a TA is going to help with that. In fact, none of the points addressed in either of the original articles really picks up on this, which to me was the first big stumbling block that came to mind.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
Well, at least the comments won't nearly be so bad. All those
// igregious hack
comments will have to go. Other than that I don't see much change.
Darn, where are my mod points today? ;-)
You hit the problem there pretty much head on. Good code is subjective, at least to an extent. There's probably no such thing as perfect code, but most good programmers would probably agree fairly consistently on what is good code and what is not. However, their benchmark may not be the same as a user or their manager.
To me, good code is simply the input that makes a good product, and a good product is simply one that helps me to do something. The more it helps me, the better it is. That may mean running faster, or covering more different cases, or intercommunicating with other products, or any number of other things, depending on my requirements. Furthermore, those requirements may change over time.
Now, from a software developer's point of view, in order to write such good code, you have to follow certain basic rules. You need the code you write to be correct (giving the right answer, with no bad output, and usually with graceful handling of bad input as well). If you're going to keep up with changing requirements, or fix bugs that come to light, you also need your code to be maintainable (so that a developer can find his or her way around it, and adjust it to meet new requirements or fix deficiencies, without compromising the overall standard of the code or expending undue amounts of effort in the process). Correctness and maintainability in turn lead to various typical rules of thumb about commenting well, having a clear design, using meaningful names for things, etc.
I rather suspect, though, that if anything like this ever came to fruition, the holier-than-thou L337 developers would look at things backwards, and see those rules of thumb as indicators of code quality. Lacking any insight into the processes and people behind the code, they will try to do the impossible by reading everything from just those rules of thumb, and judge accordingly. Sadly, this would lead to what are actually quite good and well-managed projects being criticised because the code output does not meet Joe Public's Handbook of Rules of Thumb, page 173, paragraph 2. The fact that that code might correctly and efficiently implement the best algorithm in the world for medical research would be lost on many of them, and the damage would be irreparable for years.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
That's why the binary copy shouldn't be copyrighted. The seller is being benefitted by the strongest protection available, but is giving nothing in return. If the seller chooses to use secrecy as protection, the product should be ruled by trade secret laws, not copyright laws.
Your analogy to the writer's notes is not valid. The right analogy for software would be to make public the annotations the programmers wrote while creating the program. Source code is the final product of a programmer's creation. Binary executable code is created by a machine, not by the programmer. What copyright protects is the fiunal fruits of human creation, i.e. the text of a book or the source code of a program, not the metal types used to print the book or the binary code generated by a compiler.
I agree - making good software is a difficult task, but most of the reason why general quality is so low is because producers can get away with it. It's such a magical fairyland - crank out some code as quick as you can, distribute the binary, tell people it does something (which may be true, partially true or an utter lie) and then you make them click through an unintelligble agreement which frees you from all liability, while enforcing your rights of ownership. The crowning glory is that anytime anything goes wrong with your software, you can blame everyone else: the operating system vendor, the hardware vendor, code libraries, driver software, other installed applications, virus writers and script kiddies. Extra credit for charging the customer a large sum when your software breaks down. There's no proof anywhere, it's all guesswork and lies, smoke and mirrors, marketing and salesmanship.
Forcing people to release their source is a kneejerk reaction. It might clear up some of the lies, but the real problem is that the industry is doing whatever the hell it wants, and getting away with murder. I agree that legislation (refunds, real guarantees and codes of conduct) would be a better path.
I think the fourth sentence in the article was:
In other words, part of the delivery package for any software purchase should be a copy of the source files.
I don't think he was limiting it to work done for hire. I think it was open to any software purchase.
Education is a better safeguard of liberty than a standing army.
Edward Everett (1794 - 1865)
No, that's certainly not why copyrights exist. Copyrights are NOT about protecting the seller. Copyrights exist to assure that the results of creative work will be available to the community after the creator has amassed some profit from it. Trade secrets are good enough to protect the seller's interests; the Coca-Cola Co. for instnace, has survived for a hundred years on trade secrets. The recipe for Coke is not copyrighted, it's a trade secret.
Should buying a pepsi bottle entitle you to the recipe as well?
Certainly, if it was copyrighted! Since they, just like Coca Cola, chose to protect their intellectual property by means of a trade secret, I don't get the formula, but, on the other hand, I'm free to reverse-engineer it, if I want.
By your logic copying movies should be legal because you're not copying the people just some mechanical product.
Yes, I believe I can copy freely anything that's protected by a secret, like the CSS encoding in DVDs, for example. However, if the creator of an intellectual work chose to publish his work openly and let it become public property after a certain period, under copyright protection, then I respect the spirit of the law and I won't copy those works as long as the copyright period holds.
I believe the spirit of copyright law should be, as stated in the US Constitution "To promote the Progress of Science and useful Arts, by securing for limited Times to Authors and Inventors the eclusive Right to their respective Writings and Discoveries".
As for making money? If anybody wants to make money, fuck them, why don't they get a job?
Something reminds me the bad word "pornography"...
Wait, how about software from startup companies? That would be certainly a case of child abuse!
So, what you suggest is wrong.
Less is more !
You can charge more for a product with included source code, with no extra effort on your part.
And Mrs. Fields could give charge extra for cookies that include the recipe. And then she could wonder why a competitor's cookies started looking and tasting so much like hers.
The cost of software production does not go up, and the price goes up, when the source is included, increasing your profit margin.
And what do you do when you find your source code posted on a warez site or a Usenet newsgroup? What's your course of action when you suspect that your competitors have started to look at your code for "inspiration"?
A license isn't worth squat if you don't have a way to audit it and enforce the terms. And that's the problem with selling source code. It's like letting your customers hold a gun to your head so long as they promise not to pull the trigger. It only takes one dishonest customer to ruin everything.
I am so sick of people accociating having source code avaliable the same thing as free.
I personaly feel that no software should be considered copyrighted unless it is sold with its source code.
Just because the source code is open doesn't mean they can't charge for the product, sure, the linux/gnu comunity don't do it now, but they should. If I buy MS office, there should be a cd or two with source code. I shouldn't be able to get redhat for free, but if I pay for it, I should get the source code.
I don't care for free, paying other people to do things that I don't want to do, or that I can't do, is how society works. What I want, is the source code avaible to prevent abuse such as what we have seen from many vendors besides just microsoft. Also, I like the ability to control things that are mine. Weither its to tweak it, fix it, or even break it.
Free bah, I want open. And I vote with my money.
The spirit of resistance to government is so valuable on certain occasions that I wish it to be always kept alive
I know all about the Berne convention and I don't need a parasite lawyer to tell me about it, thanks.
I never said that the copyright is transferred automatically during work for hire, but I was implying that I make sure that it is when it's an issue.
The reason for this is...
The reason is that this what governments, after serious bribery by vested interests, have decided. Don't go trying to read any deeper logic into it. Your example of the carpenter demonstrates this: the nail gun is the carpenter's yet the house isn't? There is no logic to that; it's just the way the rules are written and nobody in government gives a shit what you or I think about it unless we have a few million bucks in the bank.
There has been a lot of litigation in this area. Anyone affected _should_ run (not walk) to a good IP attourney.
Getting advice from an attourney is like asking for dating tips from a whore: all the answers seem to involve you paying them money.
TWW
"Encyclopedia" is to "Wikipedia" what "Library" is to "Some people at a bus stop"
Interestingly enough, when a design is revealed, engineers take more pride in their work. It doesn't matter whether you pop the hood on your automobile or open up some piece of professional equipment, you see that someone tried to design it properly.
I'm not accusing you of holding your customer's hostage with poorly designed code, but it is quite possible that someone else is trying to do this.
If as a member of the public, you tried to get details of the bridge's construction then you may get a few goons interested. If you had a good reason, i.e. you were a qualified engineer concerned about load-bearing, then it would be quite hard for the authorities to stop you.
There is one very good reason for commercial source code to be closed - patents. A commercial organisation in the software development industry is almost certain to have inadvertently infringed on a large number of software patents. In most cases, a competitor who possesses software patents will not be able to tell there has been an infringement without source code.
The result is that, even where a commercial software company would like to open their code, they will not, particularly if they have competitors with few ethical constraints and many patents
Comment removed based on user account deletion
"the vendors might stop shipping us such lousy programs"
Actually, probably a lot would stop shipping any programs. If they didn't, they would see their market suddenly swamped by remarkably similar 'clones' of their software... The lawyers of course would love something like that, more work for them...
If you want to get higher quality programs, get a good support contract with the software maker so that they fix bug on the double when you report them.
If that is not possible with the software make you're eyeing, then switch vendor or accept the software as-is.
Support and warranty for the product that you're buying, that's how it works. There are too many 'release and run away' software releases out there, but that's the 'AS IS' sale, as clearly stated in the license. You can buy a car with a warranty, or buy it off a lot 'AS IS', same for software. You choose.
--- Hindsight is 20/20, but walking backwards is not the answer.