Asymptote is a vector graphics programming language with a C-like imperative grammar. It's a niche language, notably because it has tethered its success to the LaTeX typesetting language: It's meant to replace the natively supported Metapost graphics package.
Although asymptote is embedded as a package in LaTeX code, it does stand on its own as a Turing complete programming language. Not only that, but its compiler effectively converts source code into the low level postscript graphics language (analogous to assembly), which allows you to generate graphics in an encapsulated postscript format. This is actually quite convenient as .eps is well supported to be converted to many other graphics specifications.
I have made many fine graphics over the years with asymptote. I figured I'd show of some of them now and again along with any grammatical constructs I've innovated within the language itself.Gradients
March 6, 2016
I wasn't trained in graphics design, and I only recently discovered the value of gradients. I wanted to create my own reusable interface in a flexible way, and I realized the stream paradigm is a natural fit for this purpose.
Streams are essentially a manual implementation of lazy evaluation. They're created with the expressions delay() and force(). Streams are a more natural fit for functional languages. As asymptote is more imperative, an alternative interpretation is that streams allow you to manually pause and play the iterations of a looping construct.
Think about it though: Many graphics are etched out most easily with parametric curves. In terms of code this is effectively the same as running a loop to draw the curve piecewise. If for each increment, you change the color slightly so that it ranges over a spectrum over the whole curve, you'll end up with a gradient:
The thing is, you can code such a gradient loop without streams, so what's their value? Two or more streams of the same length can be combined to create a new stream. This is like saying you have two or more loops (each defining separate gradient curves) and you wish to combine them into a single loop. The imperative paradigm doesn't let you do this, but streams do:
Then depending on what we've started with, we can compose our curves in more interesting ways. With the circles, I decided to create the illusion of continuity and the completeness of a gradient disk:
Or you can define your curve by means of some fancy polar coordinate functions and create a truly beautiful image:
You might not believe it, but this sunflower was generated with nothing more than a single polar coordinate curve and a gradient from black to yellow.
As for implementing streams, given that asymptote is imperative in nature and stream are functional, it wasn't straightforward. If you're interested though, here is the basic code for it: streams.