🚀 go-pugleaf

tzs@halcyon.com (Tim Smith) writes:

> Christopher Browne <cbbrowne@hex.net> wrote:
> 
> >The notion of being able to push functionality out of Emacs into
> >separate daemon processes would be *really* rather worthwhile.

This is the only thing I really want Gnome for. The current monolithic
design of Emacs is a Bad Thing IMHO. Right now I'm running Gnus inside
Emacs, which really makes no sense. I would like to see Gnus ported to
guile (a a standalone program) and have it use Corba to request
"message-editing" (and "mime" and "nntp" and everything else)
functionality.

This functionality would be lookuped up by the ORB, and it in turn
would request the basic Emacs-like editing stuff. (so would every text
box in a GUI app, gush, and whatever else.) This wouldn't exactly be a
"daemon" but it's a pretty close idea. Cosmetically, Gnus could then
use GTK widgets for its display instead of being constrained by a text
editor.

Basically Gnome has the potential to replace Emacs the binary with
Emacs as "editing macros" like it really should be. Think what-you-
really-want-to-do-centric, not editor-centric. The best part is that
there might some day really be a reason to claim Emacs is better than
vi :-)

> But what would FSF and RMS think of that?  If you've got separate
> processes communicating using well defined interfaces, it is way to
> easy to (1) replace some of the processes with proprietary
> components, and (2) use the GNU components with proprietary
> programs.

This brings up an interesting point. I was about to say that free
software necessarily means having the freedom to use it; we can't
restrict anyone who uses proprietary software alongside it any more
than we can restrict anyone who makes money from their use of it. But
I began considering the distinction between "use" and "using source."
For example, where 'mbogo' is some proprietary program (and grep is
the GNU version),

mbogo | grep "fred"

Is usually considered OK. but if mbogo just had some grep routines
copied into the source (thus going against all guidelines of
modularity, but what do you expect from a program like this?), it
would clearly violate the GPL.

The fuzzy part is here. While Microsoft seems to think that faster
processing capacity is best used up by chrome and "upgrades", I
believe that extra CPU cycles could help us help free software by
allowing for elegant instead of optimized code and allowing everything
to be run interpreted, or compiled on the fly (skipping any bytecode
compilation for things like Elisp or Java).

Obviously, we're a long way off, but Guile is a sign that things are
headed in the right direction. Writing in Scheme and giving up extra
overhead to the interpreter is better than writing in C and giving up
extra overhead to multimedia cruft. Of course, it's arguable (and
winnable) what writing in C and not adding any glitz would be better
than either (today), but that's because of efficiency. Progress in
computing power should help to make it irrelevant.

It's better because scheme makes it simpler for non-programmers to
become hackers by writing their customizations in a *real* programming
language, and allowing them to see what's going on "under the hood"
more easily. Of the major freedoms of free software - redistribution,
modification, and inspection - I think inspection is the most
underrated and important. Both interpreted languages and Scheme will
make this easier. Of course, it is only my opinion that Scheme
"presents programmers with a more logical way of representing and
organizing their thoughts" - that's a paraphrase from the first CS
textbook I ever had (guess what language I learned to program in.)

But back to Dr. Mbogo. the point of all this is that at some point the
distinction between a pipeline and killing/yanking source will become
really *really* fuzzy. How do we define where one person's
intellectual property ends and another person's begins when they're
nested 7 levels deep inside of each other in an S-exp that's so
complex we couldn't parse it without running some other code, which
may suffer from the same ambiguity?

The obvious answer seems to be "abolish IP", but (1) hahaha good
luck[*] and (2) if there is no IP how exactly do we keep people from
breaking the GPL? It seems that such a scenario would totally break
down the rules of Gutenberg copyright, which assumes a finished work
of some sort. Software is now finished works, but in the future it may
be just a bunch of hypomodules that only "become" something when put
together, and then only for a fleeting instant. Hmmmmmm...

[*] this isn't really that funny.

...I don't know what to say, really. If anyone finds this worth
discussing, please make a new subject line.

-- 
please read: http://www.gnu.org/philosophy/
"cry me a bayou/and i'm leaving..." -tricky