Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!mnetor!seismo!ut-sally!husc6!think!ames!oliveb!sun!plaid!chuq
From: chuq%plaid@Sun.COM (Chuq Von Rospach)
Newsgroups: comp.sys.mac
Subject: Configurability (Was: Re: Big Mac Systems)
Message-ID: <19433@sun.uucp>
Date: Thu, 21-May-87 12:16:08 EDT
Article-I.D.: sun.19433
Posted: Thu May 21 12:16:08 1987
Date-Received: Sat, 23-May-87 11:48:06 EDT
References: <6187@dartvax.UUCP> <19103@sun.uucp> <839@goanna.oz>
Sender: news@sun.uucp
Reply-To: chuq@sun.UUCP (Chuq Von Rospach)
Organization: Fictional Reality, uLtd
Lines: 46

>	Couldn't it be easier for the user (not the programmer though)
>	to construct configurable software?

Yes, and in fact I made the following suggestion to Microsoft as a requested
enhancement to Word 3.0.  Since it is of (hopefully) general interest to
people writing large commercial programs with a number of discrete
functional modules, I'll comment on it here, too.

What I think programmers ought to consider is plug in functionality.  For
instance, Word 3.0 has a number of different, independent functional modules
-- the basic WP, the outline processor, the spell-checker, the hyphenation,
etc...  All of these are compiled into a single large binary, meaning that
even if you don't use the outliner, you carry it along on each disk you
have, and you have to see the outline commands in the menus.

A better alternative would be to strip the functional module into a separate
resource file that lives in a known location (for instance, the System
Folder).  When an application starts up, it checks for the existence of that
file, and if it exists, opens it as a resource file so the CODE module is
accessible, and does the appropriate initialization.  If it doesn't, then
that part of the program is not initialized for use by the user. 

You could go one step futher and define an initialization interface to the
program, so that the initialization is done by a CODE segment in the opened
resource file -- this would mean that the main program would not need to
know anything at all about what that program did (note:  the interface would
probably NOT be trivial, but it would be an interesting exercise).  End
result:  third party people can write modules that plug into a program that
supports this interface that become part of the program, as opposed to
writing large and complicated DA's. Imagine if someone wrote a version of
ACTA for word 3.0, or SpellSwell, or MacLightning.  No more kludgey hacks to
get control around the main application.

You could even, in theory, write a shell that calls 'applications' as
modules, and do everything in term of a meta-application.  not exactly
multi-tasking, but...

anyway, It looks reasonable to me on paper.  I'd be interested in hearing
any holes in the proposal.

chuq


Chuq Von Rospach	chuq@sun.COM		[I don't read flames]

There is no statute of limitations on stupidity