[...] What I wanted to ask is if you have plans for one more KataTwo lesson to wrap things up?

I still have one more writeup on Kata 2. I'm horribly behind, Dave has posted Kata 16 already.

The last writeup will try to use functional techniques to solve the problem. One version is dead boring (and very similar to the previously posted recursive version). The second version has some interesting features. I just need time to sit down and get some words on paper (or rather on disk).

Or have you gotten so frustrated with Ruby, that you've returned to your Forth roots. :-)

Favorite Forth definition:

    : ? @ . ;

You just can't write nice, clear code like that in Ruby!

Hmmmm ... I should run my line noise function over some Forth code to see what it gives.

:)

Forth uses white space for delimiters. All other printable characters can be the name of a word (e.g. function or subroutine) in Forth.

Forth words generally take their arguments from an implicit data stack and return the results to that same stack. For example ...

   1 2 + .

pushed a 1 onto the stack, then pushes a 2 onto the stack. It then executes the + word which adds the top two stack entries (and removes them), then pushes the result back on. The . word will print the top number in the stack.

To define a new word, use a colon, the new word name, a list of words and a semi-colon to terminate the definition... so

   : add1-and-print   1 + . ;   ( n -- )

will add a 1 to whatever is on the stack and print the result. The net change in the stack is that it is one element shorter and the stack comment in parenthesis expresses that. A stack comment is a before and after snapshot of the top of the stack.

Variables in Forth are implemented as addresses. "variable x" will create a word named "x" that leaves its address on the stack. Use

   @    ( addr -- n )    To fetch a value\n   !    ( n addr -- )    To store a value

Ok, here's our function written out long hand ...

   : ?     ( addr -- )   \\ Define a word named ?\n     @     \\ Fetch the value stored at the given address\n     .     \\ Print the value at the top of the stack\n     ;     \\ Terminate the definition\n\n   \\ Now we can write ...\n\n   variable x     10 x !     \\ Create a variable x and store a 10 there\n   x ?                       \\ Print the value of x

That's it. : ? @ . ; defines a function that prints the value of a variable.

There are a couple Forth books that really break the mold when it comes to technical manuals. I would recommend "Starting Forth" by Leo Brodie as a good introduction to the languages. Leo's style is casual and fun to read. The cutesy pictures are a bit over the top, but it works.

I also liked "Thinking Forth" by the same author. TF throws a splash of cold water on the traditional engineering approach to software development. It is a bit anti-structured, a bit anti-OO, but in a way that turns your way of thinking around. Its hard to describe. The absolute best part of the book are the captioned illustrations. Priceless.

Both books are out of print, but used copies are available on the net.