• How to code and run a program
• Syntax of language
• Statement types
• Initial values
• Detailed description of language
• Sample programs
• Bigger universe (Big Unicorn)

• P paint. Example: P4 will paint four squares in the current paint colour, going in the current direction. The paint colour starts as dark blue, although you can change this. The start direction faces right. Both these are displayed when you 'step' through a program. The squares look like a thick blue line, as they touch each other.
• C colour. Example: C changes the paint colour to a little person. So C P4 will paint four little people. Note that C doesn't paint anything of its own. It just sets the colour for a Paint statement.
• T turn. Example: T1 changes the current direction by turning clockwise one right angle. T1 P3 will paint 3 squares of dark blue downwards since you start by facing right.
• G go. Example: G2 will move the current position two squares in the current direction without painting anything. P1 G2 P1 will paint a square, then a gap, then another square.




A common programming language used by young British school children is Logo. This was designed to control a simple robot called a turtle. If you are used to Logo, then P in Unicorn acts like Pen down, Forward, and G acts like Pen up, Forward, and T acts like Right turn 90 degrees. There is no Back in Unicorn (use T2 P4 T2) or Left (use T3). There is also no angle apart from multiples of right angles. The line drawn in Unicorn is made of squares which are quite large, so the numbers used by P are usually single digit, and the line drawn very thick. You can also specify a 'colour' as a character, like a little person or a star, which instantly brings the program to life.



• X sets X position. Example: X0 will set the horizontal part of the current position to zero, which is on the left hand side of the universe.
• Y sets Y position. Example: Y0 will set the vertical part of the current position to zero, which is on the bottom of the universe. X and Y are so-called to introduce children to x-y co-ordinates, and they move in the correct direction. However, for children too young for this, the numbers for X and Y and marked along the axes of the universe, so children can just read them off. You can use X and Y to jump directly to a known part of the universe rather than working out how to get there with T and G.
• D - Set direction. Example: D0 sets the direction to face to the right, D1 faces downwards, D3 faces to the left, D4 faces upwards. You can use D to face the direction that you want directly rather than using T to turn from your current direction.
  There are four more diagonal directions: D4 left and down, D5 right and down, D6 right and up, D7 left and up. The diagonal paint does not produce nice smooth lines! Since T will only turn through right angles, this means that you cannot turn from a square direction to a diagonal one. You have to use D to change from one to the other. I recommend that you become fluent using D0-D3 before starting on the diagonal directions.




These absolute instruction types do not exist in Logo, since a turtle has no knowledge of where it exists, so it can only move relative to its current position, or turn. But children can find this very frustrating, if they know that they want to go up the screen, and can't work out how to turn to get there. Also, it may take several moves and turns to get to a precise spot. These absolute instructions will do it a lot quicker.



• S paints one square in given colour. Example: S will paint one star in the current position. This does exactly the same as C P1. This instruction ignores the paint colour; it takes the colour from the instruction itself. It is particularly useful if you want to paint various single squares in different colours, since you only need one instruction to paint each colour instead of two.



• M moves current square along given number of places. Example: S M4 paints a little person, then moves him along four squares. Unicorn puts in a short pause between each square, so you can watch him. This gives the effect of a very simple animation. Be careful always to paint the square before you move it. M4 by itself may just move a white square along 4 places against a white background, which appears to do nothing at all!
  Move is in fact even more complicated than this. It doesn't just move the current square along, the squares it moves over get moved back. So if you had a line of coloured squares: red, yellow, blue, green, and you moved the red square along three, then you would have yellow, blue, green, red. However, if you are moving a square against a white background, you don't need to bother about this.




I don't think that this basic animation feature exists at instruction level in any other language. It does, of course, fulfil no logical function at all. But it will make the programming a lot more fun, and children will see the program in action, rather than just looking at the end result.



• I tests colour of current square. Example: I0 .S .G1 S does the following. If the current square colour is zero (i.e. white or background), then paint a star and go one square, then paint a person. But if the current square is not zero, then just paint a person. This introduces the idea of conditional logic. Any statements beginning with '.' is actioned if the I statement is true. If it is not, then these statements starting with '.' are skipped over. These statements are dependent on the If statement. There may be just one such statement or lots.
  You can have nested If statements, which means one If statement inside another If statement. The inner statements will then start with '..' to show they are inside two If statements. I recommend that you avoid nested If statements wherever possible - they can get very confusing!
  You will notice that in the expanded program listing, the contents of an If statement are indented to make it easier to understand. It will also tell you when you have an If statement not followed by statements starting with '.', or statements starting with '.' not proceeded by an If statement. This can easily happen if you insert a statement inside an If statement and forget to put a '.' in front. Using If statements is quite tricky, and needs practice, but a program without conditional logic or loops (see later) is very limited.
• E - Else. Example: I .S E .S G1 does the following. If the current square colour is an alien, then paint a star and go one square, otherwise paint a person and go one square. Note that the statements dependent on the Else statement (in this case, just one) also have '.' in front of them. The Else statement has no operand. It knows which If statement it 'belongs to' by the number of dots in front. If you find Else difficult to understand, then don't use it!




If statements often cause trouble in any language! Most computer languages signal the beginning and end of the If statement, using 'begin ... end' or brackets, or 'endif' or 'fi' (my favourite!). However, once you start nesting If statements, then either you or the language can get very lost as to which statement belongs in which If statement. Since the 'begin ... end' or brackets may signal the start and end of loops and functions as well, leaving out an 'end' or bracket can have really extraordinary consequences for your program, as half the program disappears inside the If statement. Unicorn avoids this by signalling every single statement that is inside the If statement. It also automatically indents the If statement on the listing, so if you have made a mistake it should be easy to spot. It uses a completely different technique for loops (see below) so you won't get the two muddled. Experienced programmers may be confused that the If statement only tests the colour of the current square, and cannot test, for example, the value of a variable. Unicorn is based on a Turing machine, which has a similar limited capability. It means that only visible things are tested, as opposed to things held by the program which you can't see. This concrete form of programming makes it easier for children to work out what's going on - necessary when the program doesn't do what you expect!



• B and N begin and end a loop. Example: B$ P3 T1 N$ defines a loop called '$'. (If you have more than one loop in a program, make sure that you use different characters as names.) It paints 3 squares, turns 1 right angle, then at the N goes back to the B, paints another 3 squares, turns another right angle, returns, and does it again, and again, and again... The first four repeats of the loop paint a square, but it will carry on drawing over the square again and again until eventually the program will decide that it's an infinite loop and finish. If you want, you can stop the program yourself by clicking on the 'Stop program' button, or you could 'Step program' as long as you wanted.
• L - Sets limit to loop. Example: L4 B$ P3 T1 N$ will only do the same loop 4 times, which means that it will stop itself after drawing the square. You can see that many loops need at least three instructions: L B N (and the contents of the loop of course). However, you can stop a loop with an If statement. B$ P3 G1 T1 I0 .N$ will draw the first side of the square, and go forward one square onto white. You do this four times, and then find that when you go forward, you are not on white anymore, since you have been round the square once and are about to go round again. But since the N is inside the If statement which fails this time, it doesn't get actioned, and the program finishes. This technique is rather involved. I recommend that you use L to limit loops until you are confident with them.
• Loop counter - When you start a loop with B, you have to give a character as a name for the loop. This can be any special character except '.' or '?'. You use the same character in N (this is to stop different loops getting mixed up with each other). When you start a loop, a loop counter is set up. This is 1 the fist time through the loop, 2 the second time, and so on. The value of this loop counter (and the limit set by L) will be displayed when you use 'Step program' - a useful debugging aid. You can refer to this loop counter by using the same character as the name of the loop. Since this loop counter is a number, you can use it in any statement inside the loop where the instruction is expecting a number. In the sample programs, there is a program which draws a spiral. It does this with code that looks like painting a square, but instead of saying B$ P3 T1 N$, it says B$ P$ T1 N$ which means that instead of painting a line 3 squares long, it paints a line as long as the value of the loop counter. So first time through the loop, it paints a line 1 square long, then next time, two squares, and next time, three squares, and so on. This makes a spiral, which gets bigger and bigger each time it goes through the loop. There is no loop limit; the program finishes when the spiral goes outside the universe (not a very elegant end, perhaps, but it works!) Using a loop counter as a variable is quite a complex idea. Try L4 B$ C$ P3 G1 T1 N$ and see if you can work out why you get that effect. (Hint - use 'Step program' to see what each instruction is doing.)




By labelling both the start and end of loops with the same character, it means that multiple loops do not get confused with each other. It also means that loops may not only be nested but 'linked' with the relevant B and N for the different loops not happening in strict sequence - a very unstructured procedure! However the results are well-defined, and if you don't understand them, then don't nest loops! You cannot alter the value of a loop counter yourself, and you cannot use it once you have exited the loop.



• K keeps current position and direction. Example: X0 Y0 D0 K# jumps to the bottom left hand corner of the universe and sets the direction to right. It then gives that position and direction the name # (you can use any special character for this except '.' or '?').
• J jumps to the position and direction kept by K. Example: X0 Y0 D0 K# G7 J# jumps to the bottom left corner, then moves right 7 squares, then jumps back to the left hand bottom corner. This is useful if you want to keep returning to a particular place. You could do it with X Y D but if you used K when you were last there, you can jump back with a single statement. Of course, you can remember several positions, but be sure to use different names (or characters) as otherwise you may jump back to the wrong place!




Loop counters are one type of variable in Unicorn, and position identifiers used by K and J are another. You cannot alter a position identifier except by another K. You cannot use the same character for different types of variables in the same program.



• V stores the current square's colour. Example: V& S0 G3 S& remembers the current square's colour, paints it white, goes 3 squares and paints the original colour there. You can use this instruction when you want to remember a square's colour later, but are about either to overwrite it or move away from it (or both in the example!) This is rather an esoteric instruction, but occasionally useful.




This is the third type of variable. You cannot alter it except by another V.



• Z defines a new variable and sets it to zero. A adds one to this variable. This is strictly advanced programming! Its main use is when you want to use the loop counter, but its value is one less or one more than you want. For example if you wanted to draw a line of squares across the universe's diagonal and you coded L10 B! X! Y! P1 N!, it wouldn't work, because ! runs from 1 to 10. This means that the first square wouldn't be at (0,0) but (1,1) and the last square would be outside the universe. However, Z* L10 B! X* Y* P1 A* N! would work. This can get quite messy, and in fact if you think hard about the problem you can usually find a way to avoid using this type of variable (for example, I can think of two other ways of writing that program. Can you?)




This is the fourth, and last, type of variable. Please note that this is the only type of variable that you can do any arithmetic on, you can only add to it, you cannot test it, and I suspect that you can always avoid using it. But these instructions are here for people whose loops are one adrift from what is required, who just want to get their programs working. Unicorn is not language for doing arithmetic, although it's interesting that you can write a counter and an adder (if only in binary), a prime number generator, and a sort (see sample programs). None use the Unicorn Add, and there isn't a compare between values!



• ? is not an instruction type - it's an operand. It gives a random number between 1 and 9. Example: X? Y? S? will paint some sort of colour somewhere in the screen - you don't know what or where! Although that program uses ? three times, you don't get the same number each time. Every time you use ?, you get a new random number, which might or might not be different.
• H sets the highest value for the random number. Example: H5 P? will paint a line of length between 1 and 5 squares long.
• R is similar to an If statement but tests a random number. This seems an odd thing to do, but it means that you can do something with a certain probability. Example: H10 R4 .D1 E .D3 will set the direction to downwards 40% of the time and upwards 60% of the time.




Random numbers help to make programs quirky, which adds to their interest. You will also get a different result every time you run the program.



• Q quits the program. Normally the program ends after the last statement in the program has run, unless that statement is a Next. In that case, it will end at the end of the loop, or if no limit is set, then it won't end! You can code a Q without an operand in the middle of a program to quit at that point. It should be inside an If statement as otherwise there is no point of writing the rest of the program!
  Sometimes Q has an operand. Example: Q0 means quit the program if the current square is colour zero. This is exactly the same as I0 .Q but uses one less statement.




There are three sorts of If statements in Unicorn, I, R and Q with an operand. Q is the simplest since it has no dependent statements.



• F floods the universe with a colour. F0 is the same as clearing the universe. You can do this by clicking on the 'Clear universe' before 'Run program', and the universe gets cleared automatically when you change the program, but you may wish to do it inside the program. It can be fun to flood the universe with other colours!




The complexities of clearing the universe arise because you can change the universe before running the program. You do this by clicking on a colour and then on the universe. This means that you can supply some input to your program. If you do this, use 'Run (no clear)' and 'Step (no clear)', or your carefully prepared universe will get cleared automatically before the program is run.



• U sets the universe option. Normally, when you go outside the universe, the program stops with an error message. However, this can be a bore. So you can set different types of universe.
  U0 is the conventional universe. If you start in the centre and do a long paint, you will end up outside the universe, and gets stopped. The only exception is if you use ? which takes you to the edge and not beyond.
  U1 is the wrap-round universe. If you go off the top, you will find yourself appearing on the bottom. Go off the left and you appear on the right, and so on. So you can wander at random and never disappear.
  U2 works like a single line. So when you fall off the right hand end, you appear on the left hand side, but up one. In the sample programs, the patchwork quilt program writes a hundred random squares in a straight line. But since it is in a U2 universe, it fills the universe. In this type of universe, if you go off the top you appear on the bottom in the same column.
  U3 returns you to the centre of the universe if you fall off an edge.
  U4 does the same as U3 and clears the universe as well.
  U5 bounces off the edge. This changes your direction.
  U6 is a cylindrical universe. So if you fall off the left or right edge, you appear on the opposite edge, but if you fall off the top or bottom, it stops the program with a message.



• W waits for a given length of time. Example: S1 W4 S2 will paint the current square with colour 1, wait four tenths of a second, and then paint it with colour 2. This means that you can see both colours being changed. Programs usually run very quickly, probably too fast to see. If you put a wait inside a loop, you will see each repeat of the loop as it happens.


• O sets the run slow option. Example: O1 will pause for a tenth of a second after each instruction. Usually the only instruction to have pauses is Move, where there is an automatic pause after each square. O0 not only removes the run slow option, it also removes the pause during a Move as well, to make the program run as fast as possible.




Another way to slow your program down is to use the 'Step program' button. Each time you click this, you get one more statement of the program run. You also get every variable displayed, and the paint colour, and the current square colour, and the direction, and the next line of the program to be run, and there is a cursor showing current position. This means that if there is a problem with the program, you can check everything that's happening, at each statement, to see what's going wrong. That will show you your mistake!

© Jo Edkins 2004