On Tue, Feb 18, 2020 at 09:27:47PM -0500, Clem Cole wrote:
That said, we have deviated from what it means to be
"open." What I'm
hearing from Ted and Larry that they think open can only mean stallman's
definition. I have said, that is not, was not the original definition, nor
is it the only case and that the UNIX technology itself was really not as
tied up as he claims.
I think "Open Systems" failed *because* it failed to stop the Unix
Wars. Or in other words, because we had proprietary system vendors
who all were implementing extensions to Unix in incompatible ways, was
a sign that the original definition of Open was hopelessly idealistic
in that it assumed the suits would allow companies to operate the same
way it did when everything was funded by things like DARPA grants at
the engineering work was done in Universities.
So I accept that the original definition was different, and to the
extent that most of the Legacy Unix systems no longer have much
commericial impact, and have now been replaced by Linux, is a strong
hint that while the *goals* of the original "Open Systems" mantra may
have worked, and while it may have allowed VMS to be displaced, in the
end, as everyone implemented their own versions of various
enhancements to Unix, and over time, as people even stopped publishing
them at Usenix conferences (with Sun being the last holdout; I was at
IBM when IBM stopped incentivizing engineers to publish at
conferences, and then given the amount of work engineers were asked to
do, it effectively meant very few papers were getting published from
industry --- especially as Usenix cranked up the work factor for
academic-quality papers), I think you may be viewing the "Unix
community" with rose-colored glasses.
A point Ted has made and I accept is by the time of
the UNIX Wars, the old
proprietary folks were trying to keep their own versions of UNIX 'secret'
and to use Larry terms those roadblocks to >>there<< code was real. But
the truth is that the AT&T codebase (while getting more and more expensive
as the HW dropped in cost), was always available, and people both
commercial and research had it.
The AT&T codebase by itself wasn't particularly interesting if the
hardware you had was a Ultrasparc 5; or an SGI pizza box; or DS 5100.
For that, you needed the proprietary Unix sources. Maybe you don't
consider that to be part of "Open Systems", but I consider it all of a
piece. And I don't see any solution to head off the Unix Wars and
"secret, proprietary sauce" strategy, *other* than the GPL.
Even if people were talking and publishing at Usenix, so all of the
ideas were out there (even if the source wasn't) consider the sheer
*waste* of having N different engineering teams all reimplementing the
exact same feature --- except it wasn't exactly the same, because each
company was trying to claim its own proprietary enhancement. And one
solution to that was this like the POSIX standard, but that took a
huge amount of effort as well. I consider all of that to also be a
legacy of that original "Open Systems" definition, in terms of how it
was actually implemented in the real world.
In the end, what matters to me is the ideas, the real
NOT the source that implements it. This has been proven within the UNIX
community too many times. It has been re-engineered so many times over.
In the Silicon Valley, one of the things they tell people who try to
make people sign NDA's before they tell people about their great idea
for a startup is, "don't stress over it"; ideas are a dime a dozen.
What matters is the execution, and the product/market fit. While
certain ideas maybe very simple, such as for example "the setuid bit",
past a certain point, things have gotten complex enough that it's not
just about the idea.
Consider how many person years was required to create ZFS at Sun. My
research into production quality file systems was that it requires
between 50-200 person years to create a true enterprise quality file
system, which is trusted as such. This was confirmed from my talking
to many industry contacts about how many years were required for a
number of file systems, including advfs at Digital, GPFS at IBM, etc.
Any idiot can make a random file system prototype that mostly works;
that doesn't take long. Creating an enterprise-ready, quality file
system, is a very different thing altogether.
I've seen the source code for projects that were written so that a
paper could get published. I've tried to turn some them into
something that could be used in production --- and that's one of the
best places where you can see the huge gap between "the idea" and
"something which can be used in production".
And that is because the *ideas that makeup what we
call UNIX ARE open* and
the people looked at the sources, looked at the papers, talked to each
other and the community built on it.
Did the people who worked at SGI get to take a lot at the sources for
Digital's advfs? How much of advfs was published? And how much
community was there between the different file system teams for xfs,
advfs, ZFS, etc.?
Is GPL licensing perfect? Heck no. I'll admit it has more than a few
shortcomings. But consider an alternate world were at the point where
AT&T was constrained by monopoly ruling, that someone had decided to
release the Unix sources under a GPL-like license? How might have
changed how (or whether) the Unix wars would have played out?
Perhaps the community of OS developers would have been even stronger
compared to the height of the Unix Wars? How might that have eased
application programmers who had to struggle with configure scripts to
make code that could run on N different Unix systems, which were
almost, but not quite, identical? How might have that changed the
availability of desktop applications like Quicken and Turbo Tax and
Photoshop on Unix-like systems?
I'm not GPL extremist; there are many positions where I'm sure
Stallman and the Software Freedom Conservacy disagree very strongly.
But the licensing terms of Unix(tm) were by no means perfect --- both
the AT&T proprietary license for which you had to pay $$$ and sign
licenses containing methods and concepts clauses, and the BSD license
that came later --- and if you're going to criticize the GPL, perhaps
it's also worth considering how other licensing regimes for Unix
systems have worked out.
P.S. And remember, Linux is *not* Unix(tm). It neither has the
source code lineage, nor have people paid the $$$ to the conformance
testing labs so that it can be called Unix(tm). And people can debate
whether or not it walks sufficiently enough like a duck that we should
consider it a duck, but while I certainly will acknowledge where Linux
owes an intellectual debt to those systems which came before, it's
also perfectly fair to point out its shortcomings.