Terminology: FOSS vs. `Legacy Software'?

[Lori Nagel]

I actually kind of liked the term
legacy software, well, at least at first.  Then I thought about it a
bit more and realized that legacy software could easily be
confusingly applied to things like the old Athena Widget set, and X11
user interface being used currently in the Wograld project.  (I could
never get the basics of SDL to work or figure it out, plus SDL is
upgrading to a new broke version from what I read on the SDL list.) 
But if Legacy software was used like
this, then I guess my old Athena Widget set and X11 user interface
for Wograld is "New, trendy and up to date" okay, I'm a
hardcore dork and proud of it.

Conversely, there is unfortunately new
proprietary software being written everyday, including new versions
of things like Skype and Flash.   I think it's going to take a while
to convince all the programmers not to write proprietary software
anymore, part of it is being paid to write proprietary software, and
the other half is companies making the decisions that the business
model relies
on closing the source up. 


I think what has to change is some of
the business models and the ways people think about making money. I
think people are already being forced to change some business models
whether they like it or not. If proprietary software isn't a viable
business model anymore, people will probably stop making it (with the
exception of some crazy paranoid hobbyist who doesn't want anyone to
see his code, but then who would care about using it anyway if
everyone considers proprietary software a bad thing.) 


________________________________
From: Joshua Judson Rosen <rozzin at geekspace.com>
To: Greater New Hampshire <gnhlug-discuss at gnhlug.org>
Sent: Friday, August 5, 2011 7:42 PM
Subject: Terminology: FOSS vs. `Legacy Software'?

I originally wrote this as a private e-mail, but I figured I'd send it
along to greater GNHLUG--because I realised that I would actually like
to engage you all...:

                         --------------------

maddog has written a blog-post proposing that the terms "closed-source"
and "proprietary" be replaced by the term "legacy software":

    http://www.linuxpromagazine.com/Online/Blogs/Paw-Prints-Writings-of-the-maddog/Do-not-say-Closed-Source-or-Proprietary-Software-instead-say-Legacy-Software

I've been thinking a lot about this, myself--following mainly from
a couple of recent conversations with friends and family:
one that came out of the `cobbled whole-home audio' thing, and another
that took place upon someone seeing my NanoNote (sayng, `More Linux?
Really, what can Linux do that Windows or Mac OS X can't?');
and, actually, now I remember that there was another relevant one--
with the owner of the local pharmacy down on Main St., about
their digital signature-pads; and another with my wife (the nurse)
about software-based medical devices and the modern `medical science'
(or lack thereof) behind them....

I agree with the idea that maddog's expressed, but I'm not so sure
about the specific choice of terminology.

I should, perhaps, apologise for the length of this, up front
(there's a pile of other suggested terms toward the end--actually,
more toward the middle--with context between here and there...).

I've been thinking about what terms would best help to articulate to
`the typical uncaring luddite', which required me examine the terms
in which *I* actually think about the issues; and I think it's,
basically, mainly along two lines....

One way that I think about these issues is, as a maker, something like:

    I have a project to do, and my choices of collaborators are
    either a cooperative community, or a hostile corporation
    that's going to fight me at every step (and charge me a premium
    for it!). Which would you pick? I don't really care for
    the `Nerd Fight-Club' thing....

I guess that's in the same vein as `my favourite paintings are bought
as blank canvases, et idem for books'.... And maybe it's telling that
I really wanted to remember my friend's question as "What can YOU do
WITH Linux that YOU can't do WITH Windows or Mac OS X?", when I'm
pretty sure that's not how he asked it.

The second line of thought, which probably makes for more generally-
applicable conversation, could be classed as the decison between
`permanent vs. disposable' systems. Like, with the home-audio thing....
A friend and colleague remarked that it was `hilarious that I had
cobbled together an audio system far nicer than what some major
players in the home-audio market have been able to do'. My response
to him was (bear with me...):

    The *really* funny part is that I *was* ready to just put a switch/amp
    into the basement and run speaker-wire all over the house..., but then
    I went looking into ways of doing remote control fo the switch/amplifier,
    and didn't find any open/standard mechanism for that other than
    goofy IR stuff (like `relay infrared signals through a wire to a
    serial port and write custom code to deal with the lack of standards
    in IR signalling').

    Then I remembered that I knew of a company that made this sort of stuff--
    because I'd actually worked there a few years back. Of course,
    when I was there, they were using a junky, home-grown protocol
    (with a single-layer `stack') which was basically unworkable
    for anyone outside the company (it was close enough to unworkable
    for people *inside* the company...). So, I thought: I wonder
    if they're off of their weird-proprietary-junk protocol yet...,
    or if anyone else has actually filled the `use open standards' hole'.

    So I looked at their current lineup, and found that it was using
    something called `Gridcast'--which made me wonder:

        `Gridcast'? WTF is that? Yet another weird, proprietary thing...?

    I was also reminded that their prices were multiple orders
    of magnitude more than I wanted to spend (especially for something
    that's not clearly extensible--throw-away stuff is supposed to be
    *cheap*...).

    Since it wasn't obvious that there was any open standard for
    doing remote control of audio switches, and the "AV" in the
    "HomePlug AV" term that I'd seen associated with `Gridcast'
    didn't actually seem to have anything to do with Audio or Video
    aside from being `a fast-enough link for audio and video'...,
    the thought occurred to me: maybe circuit-switching really is
    finally dead?

    So, then I went looking at all-digital audio distribution, went looking
    for ready-made products (like `Gridcast', I guess...), and ended up
    figuring that it was probably going to be quicker to just hack it up
    myself (possibly with some gently-repurposed standards) than to even
    figure out what any of the consumer products I saw were even actually
    doing..., and then it worked.

    Maybe there's something wrong when you find yourself saying
    things like, `I'll do it myself because I don't have time
    for the ready-made solutions'.

    Maybe I should be an entrepreneur....


It's illustrative of my more general thought-process, which often
starts with:

   "I'm not even sure what my needs are right now, let alone what
    they'll be in the future...."

... and resolves as:

   "I'm not going to pay a premium to lock myself into something that
    might not meet my needs, and certainly not something that it may
    not even be possible to *make* meet my needs."

Is that how it resolves for everyone? Or do most people think
something more like, `I don't know what my needs are--but surely
the provider of my solution does!'?

I know I'm too young to be saying this (and I'm probably in entirely
the wrong eneration)..., but I hate throw-away junk. I remember
someone on Slashdot actually had a good quip--oh, here it is
<http://slashdot.org/comments.pl?sid=1691504&cid=32625306>:

    > People are not engineers: they buy air conditioners,
    > refrigerators and cars. Very few people can design, build and
    > service them.

    It's not about being an "engineer". It's about taking
    responsibility for yourself and not buying into American
    anti-intellectualism where it's actually trendy to be helpless and
    stupid.

    It's so trendy to be helpless and stupid that you're discouraged
    from knowing enough to even recognize a well made device.

Though, it's not that throw-away items are all bad *per se*--
it's just..., like I wrote above: if the throw-away actually
costs more than the option that lasts and grows with your needs,
then the economy's all backward and it's a bum deal.

So, trying to come up with a vocabulary to express that pithily,
here's some free-association type stuff from my notebook
(in two generally-opposing columns):

    free                                     proprietary
                                             high-margin
    open-source                              closed-source
    open-ended                               closed(-?)
                                             limited
                                             restricted
    permanent                                disposable
    durable  (as in `durable goods'?)        throw-away
    reusable                                 single-use
    extensible                               limited-use
    growable (as in `grows w/ your needs')   limited-(?)
    expandable
    organic                                  manufactured

    repairable  (as in `user-'?              irreparable
    serviceable (as in `user-'?)             ?-serviced

                         ¿commodity? (either col: unsure connotation)

    renewable                                constrained
    free-market                              captive-market
    free-range                               cage-raised (cathedral)
    peer-reviewed                            unreviewed


"Commodity" is in the middle, surrounded by uncertainty, because
"commodity" can have either a very good connotation (a good investment
due to matching standards and being easily replaced/extended, and
being cost-effective) or a very bad one (cheap crap) depending on
context--and "commodity" can be aptly applied to either FOSS
(for all of the good reasons) or proprietary systems (with all of
the negative connotations), but I'm not sure how stable that is.

And I'm not sure if it's noticeable, but there's a certain theme
in some parts of the collection above, that leads to "legacy"
not being present as a `standard term of deprecation': one of
the problems with proprietary software (and I've heard this complaint
from at least one developer of proprietary software) is that
the throw-away nature of binary-only software means that it basically
`doesn't work as a legacy'.

I seem to recall, several years ago, hearing someone say something like:

   "Gosh, I've been maintaining my resume in troff for 20 years--
    what's the likelihood that a given piece of [what we're now
    considering calling `legacy'] software will survive 20 years,
    let alone long enough to really be `someone's legacy'?"

(kudos if the person who said it remembers that it was him :))


I guess I have two issues with the word, "legacy", in this context:
one issue is that a person must be somewhat technical to understand
it when it's used in the `legacy system' sense--or to even parse it
as an adjective; consulting my `dict' command, the only adjectival
form of "legacy" I find is in FOLDOC (via the Jargon File):

    legacy system
    legacy
    legacy code
    legacy software

        <jargon> A computer system or {application program} which
        continues to be used because of the cost of replacing or
        redesigning it and often despite its poor competitiveness and
        compatibility with modern equivalents.  The implication is
        that the system is large, monolithic and difficult to modify.

        If legacy software only runs on antiquated {hardware} the cost
        of maintaining this may eventually outweigh the cost of
        replacing both the software and hardware unless some form of
        {emulation} or {backward compatibility} allows the software to
        run on new hardware.

        (1998-08-09)


And, yes--that's perfecly (*perfectly*!) in line with maddog's suggestion :)

But (and here's my second issue): if it's parsed as a *noun*
(as by a less-technical person) then "legacy" stands a fair chance
of being interpreted as meaning something *good*.... :(

Take, for example, this quip by Markus Fix (which I found
on lispmeister.com, back when it still existed--it's since
been living in my private `fortune' file):

   "I bought the Meisterstueck No 149 at age 20, and it served me well
    during all my travels throughout Europe, Asia, Africa, America
    and the Pacific Islands. It's a remarkable and beautiful piece
    of engineering. During the same timespan I worked through
    more than 30 keyboards. People keep asking me: "Why do you keep
    a journal in longhand using a fountain pen, isn't that a bit
    archaic?"

   "People have been asking me the same kind of questions about
    Lisp. The answer is:

   "You can't leave a legacy using ephemeral technology."


It seems like `legacy software is no way to leave a legacy' has
enough hackish irony in it to be dangerous....


-- 
"Don't be afraid to ask (λf.((λx.xx) (λr.f(rr))))."
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://mail.gnhlug.org/mailman/private/gnhlug-discuss/attachments/20110806/7bdb2194/attachment-0001.html