Fred Lakin, The Performing Graphics Company, © 2010
"Literals or constants are the values we write in a conventional form whose value is obvious. In contrast to variables, literals (123, 4.3, "hi") do not change in value." Dennie Van Tassel, "Literals in Programming Languages," 
Visual Programming Language design has run into some problems. Most VPL systems are special purpose; as yet there are few if any good general purpose notations. This is in part because designing a visual notation is very difficult, let alone implementing it. Therefore, appropriate tools are needed to make design and experimentation easier. Visual literals can help. They are a notation convention that allows visual objects to be mentioned directly in code which lives in a graphical programming enviroment. Very useful if you are trying to write parsers and interpreters for visual languages (both human computer and human human).
Visual literals are also handy for GUI's and other graphic programming tasks.
For example, here is one way to set the value of a variable using a visual literal (your syntax may vary):
Discretionary Eval in a ManDiMan Interface
But first some necessary foreplay. Visual literals
Manual display manipulation, or "mandiman," is when all control of objects on the screen is explicitly managed by the user. New objects appear at a place designated by the human, and are then dragged, scaled, evaluated, rotated and edited by her or him until such time as they are erased (also by her or him). Nothing scrolls automatically.
Notice how I slipped in "evaluate" to the list of manipulations above? Discretionary evaluation of visual objects (as instructions for a computer within the framework of a programming language ) is one of the things a user can do in a mandiman environment. Mandiman and discretionary eval work together to create a programming environment which supports visual literals. Instead of having two windows, one for code chunks and then a scrolling shell where results are displayed (and statements can be typed in for evaluation), we have just one graphical space. Text and graphic objects are created and simply sit there until evaluated, at which point the result is returned at the cursor. This (no scrolling, remember?) could result in the screen very rapidly filling up with stuff; good thing the mandiman interface is so darn agile that the user can quickly and easily manage the screen manually by dragging, scaling and erasing new and old objects as necessary (just a flick of the finger, to think it is to find it already done).
So, visual literals have been used in the vmacs mandiman environment for quite a while .
It's like this: there are code chunks lying around on the screen, with text and also quoted
visual objects inline
Here's the ManDiMan spiel:
What to do with new output? Display managers that automatically put new stuff at the bottom suck, especially when they make room by moving the old stuff at the top up and out of view. Scrolling is just a hack because we can't make text and graphics do what we want really really fast. So we relinguished display management to robots in order to avoid the responsibility (like in The Day the Earth Stood Still).
Well I for one do not welcome our robo
Below are various examples from the vmacs mandiman enviroment with discretionary eval.
Because anything on the screen can be a form to be evaluated, or be the result of evaluating
such a form, in the static images below we have used as a
The claim is that the basic visual literal notation technique will work with any language, although langs with interactive interpreters are obviously more fun.
First example, Lisp version:
They are called "trees" even though they look more like roots. The fine lines show the
grouping structure of text
Note: all Lisp examples computed and returned on the screen as shown in running vmacs system (and visual programming environment).
Also note: is an example of cross
Python version (artist's conception):
More vizlisp examples:
(this last form starts a subprocess for animating the drag at 24 frames per second, resulting in the streak)
 "Literals in Programming Languages," Dennie Van Tassel, 2004
 "Computing with Text
 "The vmacs System for Text
 Visual Grammars for Visual Languages, Fred Lakin, 2010