Re: choice of character for relational division

"paul c" <toledobythesea_at_oohay.ac> wrote in message news:5Z_Ph.15666$6m4.4070_at_pd7urf1no...
> Marshall wrote:
> > ...
> > So ... what kind of code was this? If it was assembly, I could
> > see that working, because the format is so regular. If it's
> > anything in the algol family, I don't see how it could work.
> > There is formatting in the comments. There is formatting
> > in where the line breaks happen in long source lines. None
> > of this info is preserved in object form. And if it was, how
> > would editing be enabled such that everyone could edit
> > this information according to their own style, and yet others
> > could see it in *their* style? I don't see any way to make
> > that work without discarding some set of things programmers
> > are used to having.
> >
>
> No vi or such. Only practical way to write code was to use system's
> built-in editor (which was written in the same language app developers
> used, although it was quite easy to generate object with the system or
> for that matter any other tool you liked, as long as you knew the object
> format which was trivial compared to what most people were used to then
> as well as today. Tiny number of verbs, all table oriented, Get,
> Forall, Insert, Replace, Delete. Displays were sets of tables, IMS
> databases were tables, along with all the big-name DB products (to help
> encourage migration), although the preferred storage was the system's
> native organizations. Funny structure to code, conditions preceded all
> imperatives using what looked like a graphical truth table but was
> really just a disguised if then else arrangement. Programmer's interface
> was a table 'row'. Not relational by Codd's standards although I know
> for certain that he was prepared to be its architect around 1990 or so,
> money no problem, a little issue of titles put the kibosh on it.
>
> However, none of that matters to my point - object code was stored in
> system's own tables which were accessible to any programmer, not just
> the system itself. The point is that original source code was not
> saved. Some users complained that they couldn't add comments but mostly
> we ignored them. To this day, I think source code management systems
> are a bizarre unnecessity.

MDL, a variant of Lisp (1971) did somewhat the same thing. "Real MDL code" was not the text version of source code as such. Instead, it was the data structure that the reader (which contained the parser) turned it into, "object code" if you like. The printer had the inverse capability, which I guess you could call de-compiling.

This had the advantage of allowing machine generated code to be decompiled. If you looked at this stuff with a text editor, you weren't looking at what a human orginally wrote.

However, MDL retained the capability of associating commments with code. MDL had a general association manager that could keep track of the association of any object with any other object. "comments on" was just one particular kind of association. Interestingly enough, comments could be of any type, not just character strings. Thus you could have MDL code that served as commentary on other MDL code. Wierd, but sometimes wonderful.

Commentary can be retained in the system tables of many SQL DBMSes, and "source code" reconstructed from the system tables. Received on Mon Apr 02 2007 - 07:35:10 CEST