Backtalk Script Language
Tutorial

1. Introduction

This document is meant to give a enough of a basic introduction to the Backtalk script language to help you figure out what you are seeing when you look at a script, and make simple changes.

For full details of the language, see the Backtalk Script Language Reference Manual.

2. Postfix Notation and Stacks

In a typical procedural computer language, you might write a statement like this:

   print("The answer is ",(abs(x) + 1) * 5);

Postfix notation writes the operator after the arguments. So the statement above would be written as:

   "The answer is " x abs 1 + 5 * print

   2 1 + 5 * print

1. Take the number 2.
2. Take the number 1.
3. Add the two things you have and keep the result.
4. Take the number 5.
5. Multiply the two things you have and keep the result.
6. Print everything you have.

Returning to our more complex example:

   "The answer is " x abs 1 + 5 * print

1. Take the string "The answer is ".
2. Take the value of the variable x.
3. Find the absolute value of the thing you have and keep the result.
4. Take the number 1.
5. Add the two things you have and keep the result.
6. Take the number 5.
7. Multiply the two things you have and keep the result.
8. Print everything you have.

The data structure used by computer to do this is a stack. It's just a linear pile of values which allows us to add a value onto the top, or take a value off the top. Adding a value is called pushing it. Deleting a value is called popping it.

So we'll run the above command again, this time using stack terminology and showing the stack after each step. We'll assume that the value of x is -7 and we'll write the stack with the bottom at the left and the top at the right:

Operation		Resulting Stack
(1)	Push the string "The answer is ".	"The answer is "
(2)	Push the value of x.	"The answer is " -7
(3)	Pop a number, push its absolute value.	"The answer is " 7
(4)	Push 1.	"The answer is " 7 1
(5)	Pop two numbers, push their sum.	"The answer is " 8
(6)	Push 5.	"The answer is " 8 5
(7)	Pop two numbers, push their product.	"The answer is " 40
(8)	Print everything on the stack from bottom up.	empty

So the execution of a Backtalk program is really very simple. Backtalk starts at the beginning of the program and executes one item at a time according to the following rules:

• If the item is a number or a string, push it on the stack.
• If the item is a variable name, push its value on the stack.
• If the item is a function name, execute it. It will pop its inputs (if any) off the stack and push its result (if any) back.

3. Backtalk Syntax

3.1. Comments

    % This is my beautiful program

    1 2 + print   % This should print the number 3

3.2. White Space

    1 2 + print

    1   2
        +
        print

    1 2+print

3.3. Strings

So the classic hello world program is:

    (Hello world!\n) print

    (Hello world!\nHow you doing?\n) print

    (Hello world!
    How you doing?
    ) print

   (Hello world! \(copyright 1978, Kernighan and Ritchie\)\n) print 

   (Hello world! \(copyright )
     year
     (, Kernighan and Ritchie\)\n) print 

You can concatinate strings with the + function. "(Hello )(World)+" gives "(Hello World)". Sometimes this gets big and ugly:

  (Hello )(World!)(\n)(How are )(you)(?/n)+++++

  ` (Hello )(World!)(\n)(How are )(you)(?/n) '

3.4. Variables

   /year 1978 def
   /name (Tom) def 

   (My name is )name( and I was born in )year(\n) print

You'll see several other forms of this. The xdef function does that same thing but takes the arguments in reverse order:

   1978 /year xdef
   (Tom) /name xdef 

The store and xstore functions are similar to def and xdef but they can only store new values in previously existing variables, while def can either update or create variables. In most Backtalk scripts the difference doesn't matter, but Backtalk does have a notion of local and global sets of variables that we won't get into here, and it may matter when those are being used.

3.5. Constants

   /year 1978 defconstant
   /name (Tom) defconstant

   (My name is )name( and I was born in )year(\n) print

   (My name is )(Tom)( and I was born in )1978(\n) print

Backtalk will even do some computation on constants at compile time. If we write:

   /msg `(I was five years old in )year 5 +(\n)' def 

   /msg (I was five years old in 1983\n) def

3.6. Arrays

  /weekname [ (Sun) (Mon) (Tue) (Wed) (Thu) (Fri) (Sat) ] def

3.7. Procedures

   /addone { 1 + } def

   7 addone print

Procedures are also used to create conditionals and loops. Here is a conditional:

   (The value is )
   x 0 lt {
     (negative.)
   } {
     (postive.)
   } ifelse
   (\n) print

There are a number of different loop functions, all of which take a procedure argument and execute it repeatedly until some condition arises.

Conditionals interact in a special way with constants. If I do:

   name constant {
      `(My name is )name(\n)'
   } if

   (My name is Tom\n)'

3.8. Implicit Print

This has a number of advantages. One of the odder ones is that you can put the name of a variable on the stack fairly early on, by doing, say /number_of_rows. Then you can generate a whole page of data, keeping count of the number of rows of data generate with the number_of_rows varable. When you finally output the page, when the /number_of_rows literal is printed, it's current value is substituted in. This way I can print the count at the top of the page although I don't know it's value until the bottom of the page.

For large pages, however, it is generally better to do regular prints calls to keep from using up too much memory, and to allow output to begin transferring to the user's browser.