That’s a very good question. I used to wonder how to construct non-trivial Turing Machine programs myself, as it is very difficult to do it directly, although it can be done.

I think the easiest way is to write the program in an easier-to-use language that can be automatically translated into a Turing Machine program. For example, it should be possible, and not too difficult, to translate programs in Bare Bones (or a similar language) into equivalent Turing Machine programs. Going one step further, it would be possible to translate programs in an even easier-to-use language into Bare Bones, which could then be translated into Turing Machine programs.

In general the way to write complex programs for a Turing Machine, or to compile other languages into Turing Machine programs, is to use a multiple tape Turing Machine. This seems a bit like cheating, until one learns that any multiple-tape Turing Machine program can fairly easily be transformed into a single-tape Turing Machine program. However, this translation (as with the others proposed above) results in a considerable loss of runtime efficiency. (Of course, the point of a Turing Machine has never been efficiency.)

I found _Theory of Computation: Formal Languages, Automata, and Complexity_ by J. Glenn Brookshear to have better coverage of Turing Machines than I’ve seen elsewhere. It is the book in which Brookshear originally introduced the Bare Bones programming language. In chapter 4 Brookshear presents the proofs that all Bare Bones programs are partial recursive, and that Bare Bones can compute all partial recursive functions, thereby showing that Bare Bones is equivalent to a Turing machine.

I hadn’t seen Brookshear’s proofs when I started my little project to transform Turing machine programs into Bare Bones programs; while Brookshear gives a more elegant proof of the equivalence, I give an existence proof.

Brookshear’s book is out of print, but it’s not too hard to find it in libraries, or used copies (e.g., on Amazon).

Best regards,
Eric

I hear the Turing Machine is “universal” – and it may be.

But have you ever seen useful programs like BCD to Binary, addition, move, etc. More specifically, can I construct a family of commands at a little higher level? If so, is there a construction procedure, a strategy or a compiler of sorts? Or is the generation of programs for a TM something like a Rubik’s cube with trial and errors or just even intuition?

Thanks, and regards

Hanno