[Date Prev] [Date Next] [Thread Prev] [Thread Next] Date Index Thread Index Search archive:
Date:Mon Aug 26 11:32:24 2003 
Subject:Re: word completion (Was poplog interactive mode - PS -> Syntax editor) 
From:Jonathan L Cunningham 
Volume-ID:1030826.02 

On Sun, 24 Aug 2003 11:23:32 +0000 (UTC), A.Sloman@cs.bham.ac.uk
(Aaron Sloman) wrote:

>
>Jonathan L Cunningham writes:
 
>> Along the same lines, especially if you know the argument list, is
>> something like
>>
>>     define cook(meat, veg1, veg2) -> dinner;
>>        [cook called, args are ^meat ^veg1 ^veg2]=>
>>        readline() --> [?dinner];
>>     enddefine;
>
>I first encountered this when I visited the AI lab at BBN (Bolt
>Beranek & Newman) in 1975. They were working on the ARPA speech
 ...

>Moreover instead of just calling readline, the program could allow
>the user to invoke the Pop-11 compiler (or interlisp interpreter) to
>run arbitrary programs, interrogate data-structures, etc. Sometimes
 ...

>[JLC]
>> But not nearly as useful as it might look. Strange.
>
>It depends on your software development strategy. If it is mostly
>bottom up (build and test simpler things first, then use them in
>programs that do more complex things) you will not normally need
>incremental simulation mechanisms, expcept occasionally for
>debugging.

That's an interesting point for exploratory programming. Although
when you know where you are going, you can use a top-down design
approach, the risk in exploratory/research prototyping is that
you end up needing a bottom level procedure which you don't know
how to implement, or you implement it and it doesn't do as well
as you expected.

For example, in machine vision, you might have edge-detectors
as your low level primitives. With a top-down implementation
strategy, you could write your entire scene-recognition program,
then when you write the last few lines of code for the edge
detectors, suddenly discover they are not as reliable as you
expected ...

So, yes, even in exploratory programming you can do a top-down
*design* but it's definitely much safer to do a bottom-up
*implementation*. That way, if you get stuck it's either right
at the beginning, or your design had some flaw which you
overlooked (in which case it's your own fault). And if you *do*
manage to implement edge-detectors (say) with some useful
degree of reliability, chances are that a revised design could
make use of them. And if you *can't* you need a whole new
approach anyway ...

Just my tuppence worth.

Jonathan

-- 
(To e-mail me, replace spam by jlc in the e-ddress)