PDQ: Queries with Objects in 1986
I've specialized in formal language design and implementation since the '80s,
usually as a consultant. I managed to build some commercially successful systems.
In 1986, I consulted again to a client in silicon valley I'd worked for before
my stay in Japan. But the start-up had changed its name from CADTec to Sherpa.
They were building what would later be called 'configuration management' systems.
These always needed human interfaces, and so I designed and built a few human
interfaces for them. One was a language, simply called PDQ, or 'Product Data Query',
essentially a query translator in front of the database system they ran on their
PDQ became the heart of a system called 'Sherpa DMS' (for 'Data Management System'),
a customizable design-and-construction workflow application, which became heavily used
by the aerospace industry from the late '80s through the late '90s. It helped with
logistics and engineering management, a field then called 'Product Data Management'
which would later be called 'Product Information Management' and later 'Lifecycle Management'
and 'Supply-chain Management'. Most US jetliners, fighter planes, and submarines produced
in the '90s were designed using Sherpa DMS. It was still in use after the dotcom boom,
apparently for producing whiskey labels in different markets. It was bought by Siemens
and might still be embedded in some legacy software today.
PDQ might have been the first object-oriented query language in a successful
commercial product. It's hard to tell, since such subsystems are often hidden,
and most products are lost.
Also, it's hard to call PDQ an object-oriented query language in our contemporary
sense (I'm writing in 2017), since the intention was not to integrate with o-o
languages, whose compilers were not considered reliable commercial products in 1986.
Instead it simply offered an optional approach to describing relations among
products, parts, and attributes -- with a 'dot notation' that had not yet been
rigorously studied. It simplified use of the relational query languages of mid-'80s
database products, but I implemented this translator as a pre-processor for
those systems (using Lex, YACC, and C).
Utimately, this set of features trickled into all general-purpose query languages.
The ideas had been floating around labs for years, so I'm not sure if this
implementation was the primary influence -- but it was certainly successful
enough to be influential.
(A few years later, several of my close colleagues at Sherpa formed a successful rival
company known as Agile Software.)
Here are my working papers for the initial implementation, finished in the summer
of 1986. It's a nice example of the process required to delineate any query language's