unofficial mirror of guile-devel@gnu.org 
 help / color / mirror / Atom feed
From: Tom Lord <lord@emf.net>
Cc: gnu-arch-users@gnu.org, guile-user@gnu.org, ttn@glug.org,
	guile-devel@gnu.org
Subject: Re: ITLA
Date: Mon, 1 Mar 2004 13:55:25 -0800 (PST)	[thread overview]
Message-ID: <200403012155.NAA20825@morrowfield.regexps.com> (raw)
In-Reply-To: <87r7wc4bxm.fsf@alice.rotty.yi.org> (message from Andreas Rottmann on Mon, 01 Mar 2004 20:14:29 +0100)





    > From: Andreas Rottmann <a.rottmann@gmx.at>

    > I'll quote parts of your initial ITLA mail here, adding my view how
    > things would/could look like when *I*'d do this in Guile, building
    > upon/integrating my ITLA stuff.

    > ,----
    > |   Each interactive command will be defined by an ordinary Scheme
    > |   procedure supplemented with a _declaration_.  The declaration lists:
    > |   [....]

    > I'd make the declaration result in registering a GOOPS class instance
    > somewhere. Type declarations would map to classes directly, along with
    > generics that deal with I/O, completion, etc.

"To GOOPS or not to GOOPS" is for me, at this stage, an implementation
detail -- it might or might not be the right thing.

The critical thing, in my view, is to have a data-driven system
(programmers write declarations) such that you can implement various
flavors of Emacs' function "call-interactively" -- for CLIs, for smart
terminals, for GUIs, etc.

Getting the abstraction level of the declarations right is critical --
both for abstraction over interaction environments (e.g., CLI vs. GUI)
and for accessability (e.g., make it possible to write  a single
implementation of "read-file-name" for blind users and have that used
for _all_ commands that read file names).

Ok, I exaggerate slightly -- I'm not quite agnostic about using GOOPS
in this particular area.  Really, I'm mostly against it except as it
helps "internally" in various modules.  And the reason has to do with
(surprise!) modularity.  Here's why:

Declarations are going to be _written_ as simple list structures
following some (extensible) syntax -- just as they are in emacs (the
"interactive" declaration mechanism).    There's a choice here between
having all the dependent code process that data directly, in that
simple form, and trying to make an abstraction around it.

Now, we're talking about making _extensible_ applications (like
Emacs).  So we should imagine lots of different people and code bases
here.  There are:

   ~ many, many people writing declarations.   Some of these wind up
     in the core distribution but many do not.    Therefore, it's
     important to Get Right, early on, a declaration syntax that will
     be stable for a very long time -- we can't afford to continuously 
     tweak it and then tell people "update your declarations".

   ~ a few people writing the core interaction engines.   There will
     be a _little_ bit of code to do things like CLI processing based
     on declarations.   This goes in the main distribution.   The
     challenge for this group is to build an interaction framework
     that is extensible in _unanticipated_ ways.

   ~ interaction customizers:  people who make local customizations of
     interaction loops (such as for accessibility)

The disaster that can happen here is if the code bases of these three
groups becomes two tightly interdependent or interdependent in too
complex ways.  There's no room in this wildly distributed and
uncollected style of development (the kind that characterizes
extensible applications) to make a "global change".  So, while it
might be ok if, say, the interaction engine uses GOOPS internally, it
would be disasterous if every little change to the interaction engine
classes required users in the other two classes to update their code
correspondingly.

One way to avoid such disasters is the "lego approach to lisp
programming".  People sometimes compare object oriented programming to
legos but it's a poor analogy.  Legos classically have a finite number
of types of parts, all of which plug together in simple ways.
Object-oriented style, on the other hand, winds up with hundreds or
thousands of parts, with lots of complex rules about what fits
together with what.  A better lego analogy than object oriented
programming is programming just using basic lisp types for everything
and taking great care to specify extensible syntaxes for data
structures built on top of those.  Perhaps you are familiar with the
famous debate between Jamie Zawinski and RMS about whether events and
keymaps should be built up out of simple lisp types (RMS) or should be
a special disjoint type (jwz).  RMS was, in effect, applying the "lego
principle" and I think his was the superior idea.

It's kind of a situation where K.I.S.S. is the dominant design
consideration.


-t



_______________________________________________
Guile-user mailing list
Guile-user@gnu.org
http://mail.gnu.org/mailman/listinfo/guile-user


  reply	other threads:[~2004-03-01 21:55 UTC|newest]

Thread overview: 17+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2004-03-01  3:32 Extended -e syntax Clinton Ebadi
2004-03-01  5:04 ` Andreas Rottmann
     [not found]   ` <E1AxlJY-0002cb-00@surf.glug.org>
2004-03-01 14:27     ` Arch and Guile Andreas Rottmann
2004-03-01 19:04       ` ITLA (was Re: Arch and Guile) Tom Lord
2004-03-01 19:14         ` ITLA Andreas Rottmann
2004-03-01 21:55           ` Tom Lord [this message]
2004-03-02  0:11             ` ITLA Andreas Rottmann
2004-03-02  2:50               ` ITLA Tom Lord
2004-03-02 14:04                 ` ITLA Andreas Rottmann
2004-03-02  3:26             ` ITLA Miles Bader
2004-03-03 11:22           ` ITLA Neil Jerram
2004-03-03 11:55             ` ITLA Andreas Rottmann
2004-03-06 15:47 ` ttn's build system [was: Extended -e syntax] Andreas Rottmann
     [not found]   ` <E1AziNk-0007mW-00@surf.glug.org>
2004-03-06 20:39     ` ttn's build system Andreas Rottmann
2004-03-10 18:59   ` Andreas Rottmann
2004-03-10 22:28   ` ttn's build system [was: Extended -e syntax] Clinton Ebadi
2004-03-10 23:22   ` Tom Lord

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

  List information: https://www.gnu.org/software/guile/

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=200403012155.NAA20825@morrowfield.regexps.com \
    --to=lord@emf.net \
    --cc=gnu-arch-users@gnu.org \
    --cc=guile-devel@gnu.org \
    --cc=guile-user@gnu.org \
    --cc=ttn@glug.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).