morrison@accuvax.nwu.edu.UUCP (Vance Morrison ) (01/30/88)
Hello, I just felt that I had to get my two cents in on the discussion of big vs small languages. I'm sure that most of us agree that we would much prefer more consistancy in the languages we use. At the moment it seems we have to learn a new one (usually its a simple one) for every new application (reading mail, editing, command line etc). Now many would say that it is impossible to combine all these languages into a consistant interface because the applications are so diverse that major compromises in either machine or human efficiency would have to be made to combine them. While I am convinced that this is true if for simple minded notions of 'programming languages', I am not convinced that this is true in general. First of all, I belive that if such a composit language were to exist, it should be 'modular' in the sence that large pieces of it could be brocken off and used completely independently of the others. In addition, this language will not have a defined syntax (in the usual sence). That is the user interface of the language is defined outside the language itself. In a sence we have brocken the problem of designing a language into two large pieces, namely its syntax or user interface, and its semantics or what it can do. This is not to say that the interface (syntax) of the language is 'user defined', that is the individual user can define the interface. To some extent this can be allowed, but if it were left unchecked, there would be milions of different interfaces and our problem would be almost as bad as it is now. What this means is that large syntax modules can be layed on top of the semantics of the language for every significantly different user environment (ie one for the mac-type interfaces, one for line oriented etc). Another crutial idea is the fact that the interface between the syntax and the semantics is not completely defined by either side of the innterface. Most of the time when we think of an interface we think of a set of functions that has been decreed by one side of the interface. It is then the job of the other side to conform to it. Instead I suggest that each side decrees only what it has to, leaving as much 'degrees of freedom' as possible. Then there is a non-trivial binding process that attempts link the two sides of the interface while satisfying the constraints of both sides. This allows the interface to be formed by an agreement between BOTH sides and for constraint information to flow both ways. I believe that this two way information flow is critical to designing flexible interfaces. May I say that I am working on an implementation of just such an interface structure. There are many problems to be worked out yet, and I realize that any one of these problems may severly limit the effectivness of the interface, but so far I have been able to solve some fairly nasty ones, and this gives me hope that the approach is a practical one. Vance Morrison morrison@accuvax.nwu.edu morrison@nuacc.bitnet morrison@northwestern.arpa