Analytical Engine Programming Cards
Paradigm(s)  imperative 

Designed by  John Walker 
Appeared in  2000 
Computational class  Turing complete 
Reference implementation  Web emulator 
Major implementations  Java cmd line interpreter 
Influenced by  Analytical Engine 
File extension(s)  .ae 
The history of general purpose programmable computers begins with Charles Babbage's Analytical Engine. In an effort to give modern audiences an experience of what it would have been work like to work with such a machine, John Walker devised the Analytical Engine Programming Cards programming language as an interface to an Analytical Engine emulator. The language was most likely defined in the year 2000, although the concepts obviously date back to 1837 and the inception of the Analytical Engine itself.
Babbage's design
An Analytical Engine consists of 1000 columns, each representing a stored 50decimaldigit integer. These can be connected to three special purpose input columns called Ingress Axes on a central processing unit called the Mill. The Mill is capable of performing a handful of arithmetic operations on the Ingress Axes with the results being set on two output columns called Egress Axes. Egress Axes can also be connected to the storage columns or to a specialpurpose printing press. A full computation, then, will tend to look like:
 Read one or two storage columns into the input columns OR read one or two numbers from cards into the input columns
 Set the Mill to perform an operation and run it until the result is on the output columns
 Write one or both output columns back to storage and/or to the printer
By Babbage's design, there are three different control mechanisms, independently controlled by three different chains of Jacquardstyle punch cards.
 The Variable cards set the connections between storage columns and input output columns. That is, they select which variables will be read into the Mill and written back from the Mill.
 The Number cards can be read to set input columns directly to a given number. In modern parlance, they would be called "immediates."
 The Operation cards set which operation (addition, subtraction, multiplication, or division) the Mill is to perform, including any stepping up (left shifting) of the Ingress Axes or stepping down (right shifting) of the Egress Axes.
Although the only data type is the 50decimaldigit integer, fixed point decimals can be represented by assuming the presence of a decimal point that is not physically represented in the machine. The Step Up and Step Down features make it possible to perform multiplication and division while keeping this abstract representation intact.
The first Ingress Axis has and auxiliary column called the Primed Ingress Axis. The Primed Ingress Axis contains the 50 most significant digits for input into a division. The Egress Axis also has an auxiliary column. The Primed Egress Axis contains the most 50 significant digits of the result of a multiplication, or, in the case of a division, the quotient (while the remainder appears on the regular Egress Axis.)
Control flow is performed by advancing or reversing the punch card chains contingent, perhaps, on the setting of the Runup Lever which can be set by the Mill while carrying out the arithmetical operations. The Runup Lever is automatically cleared by an arithmetic operation that does not set it.
John Walker's Assumptions
Because the original programmers of the Analytical Engine (Luigi Menabrea, Ada Lovelace, and Babbage himself) did not seem to care too much about exactly how the threechain system was to be represented textually, and in fact, combined the operation of all three into a single tabular representation, John Walker has skirted the issue of synchronizing these three separate system by combining all three types of punch card into a single sequence. In this way, they do not need to be distinguished or programmed separately. As such, all command syntax for the Analytical Engine Programming Cards language can be summarized in a single table (below).
John Walker has also incorporated assumptions about the humans operating the engine into the language. That is, his emulator can process directives addressed to these attendants under the assumption that, because the machine is so slow, the attendants will have spare time to compile an Analytical Engine Programming Cards program into the actual punch card chains to be mounted onto the machine, as well as to follow simple instructions that can be read off of the cards while the machine is executing or after it has finished. For example, they can fully specify a number on a Number Card by prepending enough zeroes to make it 50 digits long, convert references to specific locations in a program into card counts for commands that advance or reverse the chains, insert a sequence of cards from their library, report the text written on the back of a card at a particular time, configure the printing press to write out data in a certain format, or record and report an execution trace for a portion of a running program. In other words, under the guise of making assumptions about the human attendants, Walker has added several features present in more modern highlevel languages as well as some basic debugging operations.
An Analytical Engine Programming Cards program consists of a sequence of commands each on its own line, similar to an assembly language. The first one or two characters is the opcode, which may, depending on the operation, be followed by one or two arguments.
John Walker assumes that the Curve Drawing Apparatus would use a fixed decimal respresentation of 25 decimal places to draw curves in the fixed domain and range from 1 to 1. It would be on the user to scale their outputs to that domain and range.
Commands
Engine Cards
Key: IA1, IA2  first and second Ingress Axes. IA'  Primed Ingress Axis. EA  Egress Axis. EA'  Primed Egress Axis. [IA',IA1]  number formed by concatenating values on IA' and IA1. [EA',EA]  number formed by concatenating values on EA' and EA. RL= Runup Lever.
Command  Behavior  Example 

Nx <num>  Set storage column x to <num>, which can be any integer written in the usual way. (Columns are numbered 0 to 999.)  N341 1232957939 sets column 341 to the value 00000000000000000000000000000000000000001232957939

+  EA = IA1 + IA2. Set RL if sign of EA!=sign of IA1 or if carryout occurs.  +

  EA = IA1  IA2. Set RL if sign of EA!=sign of IA1 or if borrowin occurs.  

× or *  [EA',EA] = IA1 * IA2  *

÷ or /  EA' = [IA',IA1]//IA2 (integer division). EA = [IA',IA1]%IA2 (modulo). Set RL if division result exceeds 50 digits or if IA2=0.  /

Lx[']  IA['] = value on storage column x  L3' puts the value of column 3 on the Primed Ingress Axis

Sx[']  Storage column x = value on EA[']  S3 puts the value of the Egress Axis on storage column 3.

Zx[']  Same as L but it zeroes the storage the column  Z3' does the same as L3' but storage column 3 will be zeroed.

<n  Leftshift ("step up") [IA',IA1] n decimal digits inplace.  If IA'=1 and IA1 = 30000000000000000000000000000000000000000000000002, then <2 will make IA'=130 and IA1=200.

>n  Rightshift ("step down") [EA',EA] n decimal digits inplace  If EA'=301 and EA=111, then >2 will make EA'=3 and EA=3000000000000000000000000000000000000000000000001.

CF+n  Unconditionally skip ahead n lines in the program starting from the line after this one.  After CF+11 , the line 12 after this will execute next.

CF?n  Skip ahead n lines starting from the next line only if RL is set.  If an attempt has just been made to divide by zero, CF?5 will skip to the line 6 after this one.

CB+n  Unconditionally jump backward n lines in the program starting from the line after this one.  After CB+11 , the line 10 before this will execute next.

CB?n  Jump backward nlines starting from the next line only if RL is set.  If a subtraction has just been used to decrement 0, CB?5 will skip to the line 4 before this one.

B  Ring a bell  B

H  Halt (with indicator of last line executed)  H

P  Print the number on the mill axis the most recent operation most recently modified (optionally formatted as required by a preceding A write numbers instruction) 
P immediately after a ÷ should print the contents of EA.

. or space  Comment  .This is is a nop.

D[XY]  Set the X or Y position of the curve drawing apparatus to the result of the last arithmetic operation.  DX after + positions the curve drawing pen xcoordinate at the contents of EA.

D  Raise curve drawing pen.  D means the next DX and DY will not draw anything.

D+  Lower curve drawing pen.  D+

Attendant Cards
Command  Behavior  Example 

T1  Begin Calculation Trace  T1 followed by + would log something like Card: 5. (filename.ae:5) + to the Attendant's Log

T0  End Calculation Trace  T0 will prevent following lines from being logged by a preceding T1

(  Unconditional cycle (backing) start: Matching ) n lines hence will be replaced by a CB+n 
The code enclosed in parentheses is unconditionally looped. 
(?  Conditional cycle (backing) start: Matching ) n lines hence will be replaced by a CB?n 
The code enclosed in parentheses is looped while the last operation does not set the runup lever. 
)  Cycle end  See ( and (? .

{  Unconditional skip (advancing) start: Will be replaced by CF+n where n is the number of lines until a matching } 
{ will jump to the instruction past the matching } .

{?  Conditional skip (advancing) start: Will be replaced by CF?n where n is the number of lines until a matching } or }{ 
See following example. 
}{  Conditional skip alternation: Identical semantics to { except that it also serves as a line marker for {? 
{? B }{ A }will perform A if the runup lever is set, otherwise it will do B. 
}  Skip (advancing) end  See example above. 
A include cards filename  Insert program from filename.ae here  A include cards MyFunProgram would immediately perform the procedure in MyFunProgram.ae.

A include from library cards for libname  Insert program named libname from standard library here  A include from library cards for arctan would perform arctan (because this is defined in the standard library).

A set decimal places to n  Allows decimals with n places to be used with N and adds n to < and > commands missing parameters 
After A set decimal places to 5 , a simple < later on will be replaced by <5 , while a N001 1.23456 will be replaced by N001 123456 .

A write numbers as picture  Output numbers according to the format picture  A write numbers as 9.99999 99999 99999 99999 will cause the number 123456789012345654321 to be output as 1.23456 78901 23456 54321

A write numbers with decimal point  Output numbers with decimal point inserted according to most recent A set decimal places command 
After A set decimal places to 5 and A write numbers with decimal point , 123456 will be output as 1.23456.

A write in rows  Insert a linefeed after every number printed  A write in rows

A write in columns  Insert one or more tabs after every number printed so that text on each line is aligned in columns  A write in columns

A write annotation textual annotation  Output textual annotation  A write annotation Hello World!

A write new line  Output line feed, particularly to start a new line when writing in columns  A write new line

Number Formats
TODO
See also
Blindfolded_Arithmetic#Babbage.27s_analytical_engine