source access vs dynamism

[Francois-Rene Rideau]

Dear Erik, dear readers,
   just in case I'm not (yet) in your kill-file, here is

Erik Naggum <erik@naggum.no> writes on comp.lang.lisp:
> * Philip Lijnzaad
> | yes, but at the same time I cannot conceive of a well managed Linux that
> | does not give source access.
> 
>   sigh.  neither can I.  _please_ note that my argument is not against
>   source access, but against giving it to anyone, without restrictions or
>   need or any concept of investment in it.
I believe you mix up the issues of *fact* and *right*.
Free software is about anyone having the *right* to access the source;
it doesn't mean they will or should actually do it,
and it doesn't mean doing it will happen free _of charge_,
and even less free of personal time investment.
(How could they read the sources without time investment?
And if they just compiled it, what difference with giving binaries,
except that it will work on more platforms?)

Just like having the *right* for anyone to repair a car
(as opposed to having to return it to the maker) doesn't mean
that everyone will repair one's own car, but that proficient people can
and will do it in a free market.

>   I want source access to be granted by the author/owner to
>   those deemed worthy as part of building a community of people who agree
>   to co-invest and share knowledge.
and the author is refused work on his own program (frequent case,
particularly in the proprietary LISP community)?
What if the owner is a marketing guy who doesn't care zilch
about sharing knowledge? That's precisely what happens
with proprietary software. The owner has absolute power to decide
who will touch the program, and this absolute power corrupts him
absolutely. Who will want to share knowledge with someone who can
reject him at his whim and prevent the use of further modifications?

>   I don't want source access to be a
>   "right" to be demanded of authors/owners regardless of personal values or
>   intentions.
Do not confuse right and opportunity.
I demand the right to copy, understand, and modify, software.
But I'm ready to pay for the _opportunity_ to do it.

>   on a higher level, I want to solve better the problem that
>   source access is solving badly: helping people get software that works
>   the way they, individually, want it to work.
Free software is not the end of software engineering problems,
only the beginning to their solutions.
Just like free market is not the end of economical problems,
only the beginning to their solutions.

> | that might seem so superficially, but big part of the motivation for open
> | source developers is to do something well, and be known for it (somehwere
> | I read the strange term 'egoboo' for this).  The packages/projects that
> | really last fall in this category.
> 
>   my argument is that you get more egoboost (I'm sure that's the word you
>   saw) out of being part of a community with privileges than you get out of
>   having access to source code.  with source access to any stray comer, it
>   is actually _harder_ to build the community, and the time it takes to
>   deal with the eager incompetents is alarming.
>
The idea is that when there are no rights that get in the way,
the mindshare structure will naturally emerge out of remaining criteria,
that is, actual proficiency.
Compare technical decisions taken by political motives
with technical decisions take by technical motives.
When political criteria take precedence over technical criteria
in technical questions, you don't obtain technically good technology
(conversely, if political questions were to be taken engineers,
the world wouldn't be good, either).

>   at issue is using _dynamic_ languages.
>   I'm arguing that source access is a necessity in the static language camp
>   and that by giving people access to source in static languages, you deny
>   them the opportunity to do what they really want, which is to add or use
>   dynamic properties of the system as delivered.
Your statement would be true if computing was merely compositional.
However, it is also decompositional.
You can't add real-time properties to a software component,
modify its GC infrastructure, make it network-transparent,
security-aware, internationalized, "Y2K-compliant", etc,
only by composing it as a black box;
you need be able to see its source so as to weave new aspects into it.

Dynamism does solve the compositional problems.
But to solve the decompositional problems, you need Reflection,
whose ultimate form is the ability to reify source code.

Access to source is also essential to get rid of the "hardware compatibility"
and "binary API compatibility" problems that tie computer science to
obsolete hardware and system software design.

>   I'm opposed to giving people access to the source as a
>   means of "solving" their real problem: insufficiently dynamic software to
>   deal with the complexity of real-world applications and people.
Free software is not the be-all end-all of software design;
it's not about design at all; it's about rights.
Dynamism is not the be-all end-all of software design, either,
although it's an essential and oft undervalued property.

>   most
>   people who code leisurely fail to appreciate the inherent complexity of
>   every problem that actually deals with real people, and I'm NOT talking
>   about the user interface, and I want to remove the source access from
>   people who are likely to be hurting themselves and the whole profession
>   by doing stuff that they should rather communicate in a human language to
>   a human developer.
Free software doesn't remove that.
All the serious free software projects I know have active mailing-lists;
just like all serious proprietary software projects, I suppose.
Non-serious posters just get ignored (or possibly flamed or kicked out),
and eventually go away;
just like in all serious proprietary software projects, I suppose;
until the non-serious guys happen to be in some decisional committee
concerning the project.

Free software does not _replace_ project management;
but it _allows_ management to be proficiency-based,
rather than boss-hair-pointiness-based.

Stupid people will hurt themselves and other people stupid enough
to trust them not to be stupid. Let them do so, you just can't prevent that.
Just don't prevent good people from doing good things,
and don't force them to follow the whims of stupid people.
(hey, you had a .sig just like that, once!).

Best regards,

[ "Faré" | VN: Уng-Vû Bân | Join the TUNES project!   http://www.tunes.org/  ]
[ FR: François-René Rideau | TUNES is a Useful, Nevertheless Expedient System ]
[ Reflection&Cybernethics  | Project for  a Free Reflective  Computing System ]
Tolerance is not about respecting other people's ideas.
We have every right to fight ideas we think are stupid.
Tolerance is about respecting other people's persons.
We have every duty to respect even persons we think are stupid.