Hackaday blog: Picking An Old Operating System

[Tony Gravagno]

https://hackaday.com/2025/08/23/picking-an-old-operating-system/

It was nice to see Chandru comment on this "hey look what we dug up from the history books" article. There aren't many comments there to note that Pick is actively developed and still sold and used. As always, it's the industry's best kept secret - and it stays that way because no one in a decision making position is interested in marketing, sales, or growth.

But ... you've heard that all from me before.

Crawling back under my mainstream rock.

T

[Optimus01010101]

I love seeing stuff like this. And it's wonderful to see Chandru still around. I have very found memories of working with him. His knowledge in the database is without equal I would say. He once wrote a series of standard A type dictionaries that would, without use of a program, get you the last value of a multivalue attribute. It worked like magic.

[Scott Ballinger]

Actually that is a pretty standard old trick, e.g.

dict invoices last.payment:

<1> = S last payment id

<2> = 85

<3> = last]payment

<8> = f85;p;s;_

<9> = L

<10> = 7

<8> = f85;p;s;_

85 = mv field of payment ids applied to this invoice

p  = pop a copy onto the stack

s  = sum

_  = swap stack 1 & 2

... this returns that last value from field 85, i.e. the last payment id in the mv list

Although now that we have the "call" processing code (attribute 8 from dict item) you can do this in a way that later, anyone will understand what is happening.

There are lots of these that exploit what were probably originally bugs;  best relegated to the dust bin as undocumented tricks.

/Scott Ballinger

[frosty]

Scott, that's a well-known "hack" in F-correlative, but Opt85 said Chuck did it in A-correlative... where, presumably, it's much more difficult!

[Optimus01010101]

Yup. A-correlative is what he did. Not saying that F-correlative is not impressive, but to do it in less that a day, and for me to get it into production for the client the day of the request.......

Well, that's Chandru for you.

[Joe Goldthwaite]

Back when I worked for Interactive Systems on CompuSheet I preferred F-correlatives to A. The logic was a lot cleaner and much more specific. Some of the things you could do with A-correlatives looked confused and clunky by comparison. Maybe part of that was influenced by handling Compusheet support.  The formula compiler was written by Larry Wilcox. Larry wasn't a compiler writer and had no formal training but he got a working converter that would take alpha formulas and convert them to stack operations that worked like the F-correlatives. It was a pretty impressive feat considering he figured it all out himself from scratch. It worked but it had a lot of little glitches that could sometimes be exploited to do things that worked but really didn't look right.

For CompuSheet+ we brought in a compiler guy. I think his name was Greg Klinkel but I can't be certain. He came up with a table that would cleanly parse the alpha formula and create a stack format that CompuSheet could execute. To me as a young programmer it was a thing of beauty. I it handled the order of operation, parenthesis and everything simply and cleanly. We were all amazed.

Later when I had left the company they had ported CompuSheet+ to Universe. They were having trouble with the compiler. I guess original table with all the logic had been lost and they had tried to re-create it. Luckily for them I kept all that documentation. I wrote a basic subroutine that would take the alpha formula and produce the stack opcodes exactly like the original. They paid me $600 for i and I think they used it until they retired CompuSheet+. I probably still have that documentation but I think it's on some 5 1/4" floppy disks so it may be lost.

Anyway, it's easy to write an interpreter to process stack type instructions. That's why (I think) the F-correlatives came before the A-correlatives. Correct me if I'm wrong but I've always thought that A-correlatives are converted to F-correlatives for execution.

Joe Goldthwaite

--
You received this message because you are subscribed to
the "Pick and MultiValue Databases" group.
To post, email to: mvd...@googlegroups.com
To unsubscribe, email to: mvdbms+un...@googlegroups.com
For more options, visit http://groups.google.com/group/mvdbms
---
You received this message because you are subscribed to the Google Groups "Pick and MultiValue Databases" group.
To unsubscribe from this group and stop receiving emails from it, send an email to mvdbms+un...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/mvdbms/bc04e7e7-c43c-48cc-b848-bcf679e65554n%40googlegroups.com.

[frosty]

Joe, you are not wrong. A-Correlatives are (well, were... back in the day) compiled to F-Correlatives.

Don't know how I remember David Gries but the original A-to-F-correlative compiler was lifted directly from his Big Blue book. 

That compiler was two modes and each mode assembled down to 512 bytes or less, so not a lot of code.

And that < 1024 bytes of code included his BNF for expressions, as A-correlative only compiled expressions, originally.

Later, the IF/THEN/ELSE structure was added to that compiler; I don't remember if the code+BNF crossed the 1KB threshold.