For example with 6 darts and two regions with values 1 and 5, it’s possible to make any value from 1 to 18, but not 19.

Being a lazy programmer, I’ve coded a dumb brute force attack rather than taking the time to come up with a fancy algorithm. So far I’ve found the optimal solution for 1 to 6 regions and I’m reached rank 130 in the standings!

Here’s the program I’m using, written in BASIC. Unfortunately it’s incredibly slow Can you see any obvious improvements?:

10 regions=3
20 high=0
30 dim r(regions+1)
40 max=5000
50 dim s(max)

60 for a=1 to regions+1
70 r(a)=a-1
80 next a

90 for a=1 to max
100 s(a)=0
110 next a

120 for c=1 to regions+1
130 for d=c to regions+1
140 for e=d to regions+1
150 for f=e to regions+1
160 for g=f to regions+1
170 for h=g to regions+1
180 s(r(c)+r(d)+r(e)+r(f)+r(g)+r(h))=1
190 next h
200 next g
210 next f
220 next e
230 next d
240 next c

250 best=0
260 best=best+1
270 if s(best)=1 and best<max then goto 260
280 if best<high then goto 350

290 high=best
300 print best,
310 for a=2 to regions+1
320 print r(a);
330 next a
340 print

350 ptr=regions+1
360 r(ptr)=r(ptr)+1
370 if r(ptr)>best then goto 390
380 if r(ptr)<1000 then goto 90
390 r(ptr)=r(ptr-1)+2
400 ptr=ptr-1
410 if ptr<>2 then goto 360
420 stop

for(Leaf leaf:leafs)
{leaf.setColor(new Color(139,69,19));}
sky.setColor(Color.GRAY);

This is California Dreamin’ by the Mamas and Papas, “All the leaves are brown and the sky is gray”. If #songsincode is of interest, here are some of the best collections I’ve found:

• #songsincode - Lyrics for Programmers - a countdown of the finest #songsincode
• songs in code at wee doors banging - a selection of #songsincode by John Girvin
• Songs in Code at Juixe Techknow - an early collection of about 60 #songsincode
• #songsincode on redcode.nl - a selection of #songsincode by Roy van Rijn
• Songs in Code Database - automatically updated with the latest tweets

The OS will provide the following functionality, similar to a MicroKernel:

• memory management (done)
• preemptive task switching (done)
• process management (done)
• inter process communication

Memory Management

Memory is divided into variable size block, each preceded by a small memory control stucture. The structure contains the following:

• link to previous block
• link to next block
• link to owner of block
• length of block
• in use flag: is this block available?
• ready flag: is process ready to execute?
• stack pointer: sp saved when not active

Functions to allocate / free memory are provided. Have I missed anything important?

Task Switcher

The task switcher is called by the timer interrupt and switches to the next available task. Switching is disabled while memory is being allocated / freed.

Process Management

Functions are provided to create new processes, kill processes, mark a process as available or blocked. Switching is disabled while processes are being manipulated.

Inter Process Communication

Semaphores and message passing will be implemented. Unfortunately, I stumbled across a problem. How do I get two processes to agree which semaphore / message to use?

Should they be numbered, named or referred to by an address in memory? Should a semaphore / message buffer be allocated to each process or block of memory? If named, how should I handle name collisions?

Any advice on implementing IPC would be appreciated.

It’s got to stage where I need to tell myself the same thing most recreational programmers need to be told from time to time:

Stop reading about programming and get some actual programming done.

Here are the papers I’ve read, all unrelated to either of the projects I’m working on!

• On µ-Kernel Construction, Jochen Liedtke, 1995. On the design and implementation of micro kernels.
• The Nucleus of a Multiprogramming System, P Brinch Hansen, 1970. A early paper describing a micro kernel.
• Updating the Forth Virtual Machine, Stephen Pelc, 2008. Explores some changes to Forth, notably address registers.
• Bubble Sort: An Archaeological Algorithmic Analysis, Owen Astrachan, 2003. Investigates the history of Bubble Sort.
• Analysis of Sorting Algorithms by Kolmogorov Complexity (A Survey), Paul Vitányi, 2003. In depth.
• A Fast Easy Sort, Stephen Lacey and Richard Box, 1991. Describes Comb Sort (also known as Dobosiewicz Sort).

Even words with a trivial implementation can pose an interesting problem. For example which of the following is most efficient:

Jones Forth TUCK (Corrected)

: TUCK DUP -ROT ;

Alternative TUCK

: TUCK SWAP OVER ;

If DUP, -ROT, SWAP and OVER are all primative, the alternative implementation will execute two fewer instructions on an 80×86 Forth. However, -ROT is often implemented in Forth which would cause the Jones Forth TUCK to be substantially slower. Here’s a typical implementation of -ROT:

: -ROT SWAP >R SWAP R> ;

Note: there’s an error in Jones Forth. The implementation of ROT and -ROT are reversed.

If you can think of an alternative two word implementation of TUCK or four word implementation of -ROT, please let me know.

RobotWar by Silas Warner is the earliest example of a battle robot programming game, published by MUSE Software for the Apple II in 1981. Robots are programmed in a proprietary language. Apart from the RobotWar page on Wikipedia and the results from the first four tournament in Computer Gaming World, there’s no information online. If you remember RobotWar or the Postal RobotWar Club, I’d love to hear from you.

P-Robots by David Malmberg is another early example of a RobotWar style programming game, published as Shareware in 1988. Robots are written in a subset of Pascal. Later versions added features such as customizable robots. There’s very little information online, so I’d love to hear from you if you used to play P-Robots or have a copy of Robot Editor by BJ Gleason.

BF Joust by ais523 / Kerim Aydin is a capture the flag programming game designed in 2008. Programs are written in the Brainf*** esoteric programming language and an online King of the Hill tournament is available. For more information, see the BF Joust Wiki page.

There are still three early programming games I need to take a closer look at, Darwin (1960s), C-Robots (1985) and Omega (1989). If you’re aware of any I haven’t mentioned published before 1990, please let me know.

The last couple of weeks have been kind of hectic, but I’ve had the opportunity to look though a few of the programming games on Dennis Luehring’s list of programming games. I picked out CoreLife to experiment with. CoreLife is similar to Corewar, but played in 2 dimensions. Currently I’m attempting to write a replicator.

Speaking of Corewar, this month started off with some sad news. KOTH.org is to close at the end of May and will be missed by the everyone involved. KOTH has served the Corewar community for 15 years, providing a King of the Hill tournament, mailing list and IRC channel.

KOTH’s IRC channel has already moved to #COREWARS on irc.freenode.net and the KOTH webpage has been archive to ensure it won’t fall victim to bitrot. The fate of the hills and mailing list is still being discussed.

Programming Report

Most days I was up about an hour or so before everyone else, which proved to be my only chance to get any programming done. The only technology I had available was a Nintendo DS, with a R4 flash cartridge.

The R4 cartridge allows the DS to run downloaded homebrew software. DSOrganise is one of the best and includes an editor, IRC software and a simple web browser. Unfortunately, I never found a WiFi connection to use the Internet.

The DS turned out to be handy after all, since I downloaded the ANS 94 Forth Standard and eForth to the R4. I managed to implement a couple of dozen words in assembly over the week

Since I didn’t have time to order a book about Forth, there’s still some space available in my rucksack. There’s a few on my bookshelf I haven’t read. Which should I take for inspiration and what should I leave at home to avoid the distraction?

• The Emperor’s New Mind, Roger Penrose
• Zen and the Art of Motorcycle Maintenance, Robert M. Pirsig
• Unsolved Problems in Number Theory, Richard K. Guy
• For Whom the Bell Tolls, Ernest Hemingway
• my tiny life, Julian Dibbell
• Crypto, Steven Levy

Types of URISC

There are four common types of URISC - MOV, RSSB, SUBLEQ and SUBNEG.

MOV - Transport Triggered Architecture

In a MOV URISC machine there is just one instruction with two operands. When the instruction executes, it copies one location in memory to another, using the operands as pointers. Jumps, arithmetic and input / output are achieve with a memory mapped program counter, arithmetic unit and input / output ports.More information about MOV TTA:

• Transport Triggered Architecture

RSSB - Reverse Subtract and Skip if Borrow

The instruction in a RSSB URISC machine is Reverse Subtract and Skip if Borrow. Each instruction has one operand which is a pointer into memory. When the instruction executes, it subtracts the accumulator from a memory location and stores the result in both. If the value in memory was lower than the accumulator, the next instruction will be skipped. The program counter, accumulator and input / output are mapped to memory.More information about RSSB:

• The Ultimate RISC, One Instruction Computers
• Hello World for the RSSB Virtual Computer
• Redcode Interpreter for the RSSB Virtual Computer

SUBNEG - Subtract and Branch if Negative

Also abbreviated to SBN, a SUBNEG computer uses an instruction with three operands. When executed, SUBNEG subtracts the contents of the first memory location from a second location, storing the result in the second. If the first value was higher than the second, SUBNEG jumps to where the third operand points. Input / output are memory mapped.More information about SUBNEG:

• A SBN Computer Built from 74xx Gates

SUBLEQ - Subtract and Branch if Less than or Equal

SUBLEQ is similar to a SUBNEG computer, but also branches if the contents of the two memory locations is identical.More information about SUBLEQ:

• Hello‚ World! in SUBLEQ Assembly
• The SUBLEQ URISC / OISC Architecture
• SUBLEQ Interpreter in Redcode
• SUBLEQ Self Interpreter