Creative programming is programming as a form of creative expression, rather than solving a given problem, and usually involves some kind of visual and/or aural component meant to be experienced. The purpose of creative programming are as varied as there are different programmers. Some use it as a tool for learning, others as a form of art or recreational programming.
Whatever the purpose when doing creative programming you often find yourself in some kind of continous process of exploration. Constantly experimenting, tweaking, and discovering new and interesting things about your creation. Using a programming language which is built to allow remixing and recombining existing parts, while staying out of your way as much as possible, would seem like a good way to facilitate such a process.
This is where Ait comes in. Ait is a language created to explore what concatenative languages can offer a programmer in the context of creative programming.
Concatenative programming got its start with a language called Forth. Created in the late 60s by Charles H. Moore, Forth had its golden age in the 70s and early 80s with widespread usage in embedded electronics. The language is centered around words, which are analogous to functions or procedures. Programs are constructed by composing these words. Because all words, or functions, take the same number and type of arguments, composing functions simply become a question of concatenating words. This is very similar to what we now know as tacit programming and is the origin of the name given to the family of languages decended from Forth; Concatenative Langues. The simple rules words adhere to is what gives Forth the characteristics which makes it interesting in the context of creative programming: Minimal syntax and rules and an easy way to construct and compose programs.
These characteristics also gave rise to a philosophy of programming, described in the book Thinking Forth. Written in 1984 by Leo Brodie, this book introduces an iterative process for developing programs, very similar to what we would call XP or Lean today. At the heart of this process is something the book calls “factoring”, which is a set of guidelines for continously refining an evolving codebase.
Another language which shares alot of the same characteristics as Forth is a language called Joy. Created by Manfred von Thun in 2001, Joy combines the expressivity of functional languages with the simplicity of Forth. Still using concatenation as the method of composing programs, but with the added capability of evaluating quoted programs.
Taking the Forth philosophy to heart, Ait ships with a minimal standard library and the ability to create and import modules that extend the vocabulary of available words.
Ait also has the ability to evaluate quoted programs, like Joy, to give it more expressivity. This feature gives concatenative languages the ability to create higher-order words, much in the same way as functional languages use higher-order functions.
More information and code examples can be found at https://github.com/mollerse/ait-lang
Combining the extensibility from the module system and FFI, the expressivity of higher order functions and the syntactical ease of composition inherited from Forth is where Ait fits in the ever growing world of programming languages.
The goal of this demonstration is to show how this combination of features impacts the creative process in a positive way. Walking through a piece of art made with Ait, I will show how the principles of factoring and ease of program construction through concatenation allows for a continous, exploratory process of remixing and experimentation.