The scientific and technological advances leading to SubScript started long ago. The Babylonians started with Algebra around 1800 BCE. Language theory goes back to the 6th century BC, when Pāṇini wrote his Sanskrit grammar.

Half way the nineteenth century George Boole thought of algebraic multiplication and addition as logic operations.

In 1956 Stephen Cole Kleene published work on formal automata. His work led to the concept of regular expressions.

A year later Noam Chomsky published Syntactic Structures, introducing, among others, context free grammars. 

Around 1960, John Backus and Peter Naur developed a notation to express context-free grammars, which was called Backus Naur Form or BNF. Many variants would be developed later.

Also in 1960, Tony Brooker built the first compiler-compiler, to be followed by a bunch of related products such as Meta-II (1962) and YACC (1970).

In 2008, YACC creator Stephen C. Johnson said:

The ideas and techniques underlying YACC are fundamental and have application in many areas of computer science and engineering. One application I think is promising is using compiler-design techniques to design GUIs – I think GUI designers are still writing GUIs in the equivalent of assembly language, and interfaces have become too complicated for that to work any more.

In 1962 the first version of the programming language Simula was defined. It would become the first object oriented language. Simula also supported parallelism and time based simulation.

Hans Bekič tried to “develop an algebra of processes”, in his 1971 technical report Towards a mathematical theory of processes. His algebraic approach would later be followed up and improved by many researchers. More about this in the paper “A Brief History of Process Algebra”.

In 1973, Roy Campbell and Nico Haberman published the concept of “Path Expressions“: a mechanism for expressing permitted sequences of execution, inspired by regular expressions.

Around 1980 three algebraic concurrency formalisms were launched:

• Communicating Sequential Processes (CSP) , by Tony Hoare
• Calculus of Communicating Systems (CCS) by Robin Milner
• Algebra of Communicating Processes (ACP), by Jan Bergstra and Jan Willem Klop

ACP had at first been coined Process Algebra. Around 1990 people started to use that term as well for CSP and CCS, causing some confusion, so the theory by Bergstra and Klop was rebaptized.

Also around 1980, on the practical side, Jan van den Bos et al. developed the Input Tool Model (ITM) and thereafter the Input Output Tool Model (IOT). This applied the concept of Path Expressions to the specification of input patterns for interactive applications. IOT was implemented as a programming language extension to C, Pascal and Modula-2.

In 1987 André van Delft picked up the IOT implementation, and modified it so that not only input actions would be placed in the path expressions, but also internal actions and output actions. This way Scriptic-Pascal was formed, to be transformed into versions based on Modula-2, C, and C++. Step by step the language got based on the Algebra of Communicating Processes, while offering additional constructs, e.g., iterations, actions with a given duration, and different flavors of parallelism.

Around 1990 Scriptic was meant to be a simulation language which also happened to be useful for the specification of GUI behaviour. It was only used in a few research projects on simulations, though. For several years Scriptic was left aside.

In 1996 Van Delft made a version of Scriptic based on Java, now offering support for multithreading.

Still, there was no big spaghetti coding problem to be solved for GUI programming, and Scriptic would then not have offered a good solution for it any way. For 12 years the language was out of sight again. Meanwhile Van Delft noticed the emerging spaghetti problem, AKA Callback Hell, in his daily work as a software developer. He adapted Scriptic so that it could better express event handling and threading issues. In 2009 this new version went open source at Google Code.

In 2010 Van Delft used Scriptic on his job at NATO NC3A, for processing technical documents on communication protocols. This documentation was a kind of structured English; earlier attempts to process such documents using sh, Perl and JavaCC had taken lots of coding effort for the text parsing. With Scriptic, writing the parsing code became less hard; comparable to the output generation code.

That year Van Delft evaluated this experience with Scriptic at NC3A, and decided to move on to a follow up language: SubScript. This had several features removed so that the syntax became leaner. The new “here” reference and some other changes increased the expressiveness. Scala was adopted as a base language, because it promised to be a good means for implementation. As a side effect, Scala inspired some syntactic sugar rules that make SubScript program’s easier to read and write.

In 2011 Van Delft started programming the SubScript VM in Scala. He presented this at in April 2012 at the Scala Days 2012 conference in London, and March 2013 for the Scala team of EPFL in Lausanne. EPFL gave very useful feedback, resulting in a paper on dataflow programming using SubScript. Van Delft presented this in July 2013 at the Scala Workshop, co-located with the ECOOP conference in Montpellier.

After the ITM implementation of Van den Bos, many things have changed, and Scriptic/SubScript has moved over a number of base languages. However, the core of the implementation are the template trees and call graphs that were essentially already in ITM, around 1980.