while N not 0 do;
    decr N;
    incr X;
end;

Such a loop adds N to X, clearing N in the process. Without the optimizer, this is has time complexity O(N). The optimizer replaces it with a single macro that executes in O(1). This makes the supplied example program that computes Fibonnaci numbers run much faster.

For the next release, I’ve added more sample programs, including an example of a Bare Bones translation of a two-symbol three-state Turing machine busy beaver program. The Bare Bones program demonstrates that Bare Bones can perform any action that can be performed by a Turing machine, proving that Bare Bones is universal.

Brookshear states that Bare Bones is universal by comparing it to a Turing machine, but only actually shows that it can compute two simple functions that are computable by a Turing machine. He states that “researchers have shown that the Bare Bones programming language can be used to express algorithms for computing all the Turing-computable functions,” but unfortunately he does not give any reference to publication of such results.

One way to show that a machine or language is universal is to show that it can emulate a Turing machine, or that any Turing machine program can be translated into a program for the machine or language in question. At first glance it wasn’t obvious that Bare Bones could be universal, because a Bare Bones program can only use a finite number of variables. The key to its universality is that a Bare Bones variable can contain any non-negative integer. An infinitely long one-dimensional Turing machine tape can be represented as three variables: one contains all the symbols to the left of the head, one contains the symbol at the head, and one contains all the symbols to the right of the head. For a turing machine with an alphabet of n symbols, to move the head position right, one must execute these assignments (in pseudo-code, not Bare Bones code):

LEFT := LEFT * n + HEAD;

HEAD := RIGHT mod n;

RIGHT := RIGHT / n;

Moving the head position left is done by the same assignments, with LEFT and RIGHT swapped. For a two-symbol Turing machine, the Bare Bones code to move the head position to the right is:

# LEFT := LEFT * 2;
copy LEFT to TEMP;
while TEMP not 0 do;
    incr LEFT;
    decr TEMP;
end;

# LEFT := LEFT + HEAD;
while HEAD not 0 do;
    incr LEFT;
    decr HEAD;
end;

# HEAD := RIGHT mod 2;
# RIGHT := RIGHT / 2;
copy RIGHT to TEMP;
clear RIGHT;
copy TEMP to HEAD;
decr TEMP;
while TEMP not 0 do;
    incr RIGHT;
    decr TEMP;
    copy TEMP to HEAD;
    decr TEMP;
end;

That’s the most complicated portion of the Turing machine interpreter. I might write up an explanation of the rest at some future date. For now, anyone interested in the details can look at the example Bare Bones source code for a simulation of a three-state Turing Machine busy beaver program: tm_busy_beaver_3.bb.

Note that it is not currently practical to to use my Bare Bones interpreter to simulate a Turing machine with a long tape, because the division/modulus code used to shift the tape takes O(n) operations, where n is the number of bits to the right of (or left of) the head. To make that reasonably efficient, I’ll need to extend the interpreter’s optimizer, and make the interpreter use bignum arithmetic (probably using the GMP library). Once that’s done, it would be nice to try running a universal Turing machine in Bare Bones. The smallest two-symbol UTM I’ve heard of uses 22 states.

• clear var; — set a variable to zero
• incr var; — increment a variable
• decr var; — decrement a variable, unless it is already zero
• while var not 0 do; <statement list> end; — loop
• copy var1 to var2; — introduced for convenience

Bare Bones is universal, in that it can compute any function that can be computed by a Turing machine. In fact, it would be universal even without the clear and copy statements, as those can be synthesized from the remaining statements. Needless to say, writing programs in this language can be tricky. I wasn’t confident that the programs I wrote for the homework exercises were correct, and decided to write a Bare Bones interpreter to check them. It’s released under the GPLv3.

I wrote example Bare Bones programs to compute factorials and fibonacci numbers, and they are included with the interpreter.

I teamed up with Luke, and I think we’ve got a good entry.  I think there are only two other teams.  Today is the due date for the program; I’m looking forward to finding out the competition results, and comparing programs with the other students.

The textbook suggests as an exercise writing a program that copies itself to a different memory location and jumps to the copy, which would then repeat that process.  It is challenging to write such a program for the Appendix C machine because it only has absolute addressing.  The program has to be modified as it is copied, or after it is copied, so that loads, stores, and jumps use the new addresses.  My first attempt used the extra instructions available in the simulator, before I was told that they were not allowed.  Without those instructions, it was a much harder problem, but I have a working program.

It has a full-page sidebar on page 32: “PRACTICAL PERSPECTIVE: Why LEDs Are Usually Active Low”. They get points for the attempt, but they fall short:

This is one reason to use active low LEDs: It is preferable to source the current to light the LEDs directly from the power supply than from a logic component.

Ignoring the grammatical error in the sentence structure, they fail to explain why it was preferable in the past, and why it rarely matters in modern designs.

Bipolar TTL devices, which are all but obsolete, usually have much more capacity to sink current than to source current. Modern CMOS devices commonly have equal source and sink ratings, leaving no particular justification on the basis of drive capability.

They attempt to proide a second justification:

A second reason to use active low LEDs has to do with speed. The logic signal to light the LED often comes from the output of a gate, usually an AND or OR gate. For active low signals, the faster NAND or NOR gate is used instead. Thus, active low LED signals are often generated faster than their active high counterparts.

This is not universally true, and is completely irrelevant even in the cases where it is true.

In each class the instructor has had us introduce ourselves in an online forum.   Unsurprisingly the majority of my classmates are in Illinois.  There are four in California (including myself), and one each in Colorado, Florida, Kansas, North Carolina, New Mexico, Oregon, South Carolina, Tennessee, Texas, Vermont, and Wisconsin, and a few others who didn’t state their location.

Perhaps in the future I might actually be able to meet my classmates in California, Colorado, and Oregon in person.  I visit family and friends in Colorado and Oregon whenever I get a chance.
I’m taking:

1. CSC 376 — Computer Organization
2. CSC 385 — Data Structures and Algorithms
3. CSC 387 — Foundations of Computer Science

Given my extensive experience in programming and embedded system design, I don’t expect any of these to be too difficult.  I’ve skimmed the textbooks for 385 and 387; the textbook for 376 should arrive here tomorrow.

I’m not taking any math classes this semester.  I wanted to take MAT 332 — Linear Algebra, which is a prerequisite for several of the more advanced math classes I will take for my minor.  I took a linear algebra course at De Anza college last summer, but the UIS math department says that I have to take “upper division” linear algebra.  At least the course I took previously should give me a headstart on MAT 332.  Anyhow, by the time I was able to register for classes this semester, MAT 332 was full.  That’s OK, since I was able to take an extra CS class instead.

I notice that the online UIS tuition and fees have gone up by 17-20% per year for the last two years, from $158.50 per semester hour in the 2004-2005 school year to $185.00 for 2005-2006 and $226.00 for 2006-2007 year. The in-person tuition is rising as well, though at a slightly lower rate. Is the cost of education really rising that rapidly, and if so, why?

I’ve been unbelievably anxious about this over the last three weeks, but I just received email notification of my acceptance.  The official notification will be in the mail.

I can hardly wait to get started!  The Spring semester begins on January 16.

The CS department recommends that students in the first semester of the program take:

• CSC 305 – Entrance Assessment – 0 units
• CSC 385 – Data Structures – 4 units
• CSC 387 – Foundations of Computer Science – 4 units

I need to find out from my Academic Advisor whether I need to take the CSC 410A Java Programming bridge course.

You can play the game online in your browser.