localoutline

Good morning!
  Today we swing back to the discussion of what is and isn't open source. It became a big issue for the software industry in 1998 when Netscape released the source code to their browser, with much fanfare and press coverage.
  It hailed a new beginning for software, tossing out all the rules that came before. It promised that individual programmers would melt into a utopian whole, personalities would no longer be an issue, a ouija board would write the stuff, and people would come and go from projects, everyone happily working for free, the users would be empowered, Microsoft would be routed around. No more bugs, no more dictatorial leaders, and a swarm of Internet programmers working for free, would take Microsoft out of the browser business once and for all.
Did anything really change?
  Developing user-oriented software is hard work. Someone has to have a vision, and stay with it, for years, often many years, if the software is to achieve its goals. If the creator of a piece of software walks away from it, it usually dies. The people who are left to pick up the pieces have a hard job to do. It's like almost every other artform, you don't see too many new Rembrandt portraits or Beethoven symphonies in Y2K. Lotus 1-2-3 didn't go too far after Mitch Kapor quit, and it took 15 years for a fundamentally new version of the Mac OS to appear, and since the original creators are gone, it's quite different from the original.
  But I'm gullible. Ask my friends. I fall for irony and sarcasm, sometimes even outright lies. So when the open source rage came along two years ago, I went on an investigation. I couldn't imagine how a software project could work if anyone could check-in any code they wanted. Even on commercial projects, ones where quality control is a central issue, we don't allow check-ins by new team members, every change has to be analyzed carefully because there are always weird interactions, and lots of rules you have to fully understand to move a program forward. Every bug fix could introduce more bugs. And of course they always do. That's why programmers pray to the Software God, Our Lord Murphy, the one who makes sure that anything that can go wrong, does.
  In my investigation, I found that open source projects work like commercial ones. Check-ins are carefully controlled, and often new code is merely taken as a feature request in source code form. This is not different from how it works in our world, since we ship a lot of source with Frontier, very often people submit bug reports in the form of requested changes to our code. This is neither good nor bad. Often we can't tell why they wanted the change. But sometimes people do spot bugs because they have the source and we try to fix them when we can, again, balancing the changes against possible breakage, and in priority with other features and fixes that people are waiting for, and factoring-in where we want to go with the software.
Gravity is still here
  It would be great if just by changing a few rules that software could turn from a time-consuming and expensive process to a free and loving and always-wonderful process where everyone gets everything they want without waiting. But software is still software, it's still a difficult process to make great software.
  The Netscape source code was a mess when they released it, so the open source team started from scratch, which is not a tactic unique to open source, all programmers new to a project want to rewrite it. New code is simple. Code that's used by millions of people often is a convoluted impossible to understand mess.
  We all make compromises. Even open source purists must run their software on chips that are just software that's not open source. Intel does not release their source code. It's even worse. Try to find the line between open source and commercial software on Windows and Macintosh, both of which have active open source development communities, and both support dynamic linking that allow runtime mixtures of different philosophies. Chasing this to its conclusion, and there's no way to find a line, the program counters of our CPUs cross in and out of opensourceland all the time, and we're no worse for it.
  Most users don't care if the source is available. I am a programmer, if the code were available for the programs I use, I would never look at it. I'm busy. I have lots of other things to do. But users were intoxicated by the hype of open source. The promises sounded good. This undermined conscientious commercial developers, to be so vilified. When users demanded the source code, and we had to say no, they often punished us, so the hype hurt. I don't think this is well-appreciated.
  While the open source hype was targeted at Microsoft, the people who really got hurt were commercial developers who work hard to create software that people love. Of course the users got hurt too, because the developers of the software found it hard if not impossible to get investors interested in their software while the open source hype raged through the investment world. The open source hype added new barriers, just as the fortresses of the big commercial companies were crumbling. So sad that we couldn't have just let the freedom be, that people had to try to control it, monetize it, and stand in the way of people working together.
  I did a survey of Scripting News readers and found that most of them want to work together, crossing the boundary between open source and commercial software. As I was trying to process the hype of open source, I incorrectly concluded that the philosophy of open source was against commercial software. This created a disconnect, people who do open source would say "We think your stuff is cool" but I couldn't reconcile that with the hype which seemed to say otherwise, quite strongly. I have finally reconciled it, the disconnect is between the leadership of open source, or the most vocal leadership, and the people who actually do the work, many of whom are moonlighting commercial developers, who like their jobs, and also like to do pro bono work. Duh. I wish I had figured that out earlier.
  We're not as different as some would have you think. An open source project can only work if there's trust in a single leader, and if the leader stays with it. From that place, there's delegation, trust is distributed, but the source of trust must be identifiable. Someone's got to make the decisions, the arguing stops, movement happens. Otherwise there's fragmentation, and lots of unhappy people. This is exactly how it works in commercial projects. No difference.
  Yesterday I read a story on Lotus.Com that reviewed Eric Raymond's Cathedral and the Bazaar, and said that his theories about management of open source projects are contradicted by actual practice in real-world open source projects. According to the Lotus article, there are no differences between the way open source projects are managed and any other kind of software project.
  http://www.lotus.com/developers/devbase.nsf/articles/doc2000091200
  So, if open source projects behave like all other software projects, is there actually such a thing as open source? You may be surprised to hear that I believe there is. But it's not in agreement with what the open source leaders say it is. I'm going to give you Dave's definition of open source, and you can see if you agree.
What is open source?
  A program is said to be open source if the full source code for the program is available publicly, with no constraints on how it can be used.
  That's it. We've looked at so many other possibilities, I've even discussed it publicly with Stallman, and he agrees that his philosophy is not open source, because there are constraints on what you can do with his code.
  So, if this is what open source is, how long has it been going on? The answer -- a long time. Programmers are not the money-grubbers that some make us out to be. Most programmers want their creations to exist beyond their lives, both in space and time. We want to make things that people use, and we want respect, and mostly we want respect from our peers. Sometimes we release the source, and other times we don't. When we do, and when it's done unconditionally, that's open source.
  Sometimes people distribute source to balance a similar kindness that they benefited from. In the mid-1970s I learned how to program reading the Unix source code from Bell Labs. To this day that experience influences the code that I write, and I've passed the lessons on to my team at UserLand and to people who learn to program using Frontier.
  I learned to write software for the Apple II by reading Woz's code. Peter Norton taught me how to write IBM PC software, again by giving me code that works. Same on the Macintosh, and every other platform I've coded for, including the Web. The View Source command in the Web browser makes it virtually impossible to hide the secrets of the Web. You can always find out how something works. That's part of the magic of the Web.
  Programming is a human endeavor, an artistic one, like writing or music. The art is in the process. What is this program? How do we decide which features to add? Who does it serve? Where should it run? Which bugs should we fix? Whether or not it makes money is often secondary to the purpose. The primary purpose is to make the world a little smarter, and to get the good feeling that comes from playing a part in that.
  Free source code releases, or open source, are an essential part of being a programmer, and it dates back to the beginning of programming. It's not a new thing, and not complex. Basically the rule is, here's the source, have fun with it, if you want.
  After the hype, the world is much as it was. Some have new fortunes, and new software is still being made, some of it commercial and some open source. That's as it is, and imho, as it should be.
  Dave Winer