Tag Archives: open-source

FRIBBLE, a SPITBOL program to play word games such as Word With Friends, now available

The FRIBBLE project is pleased to announce its first release V17.1.30, available at Fribble Project.

FRIBBLE is written in SPITBOL, and uses a brute-force approach, trying all possible moves, to play WWWF.

Fribble can be run in three ways: to play against itself, to play against you, or to help you play a game with a foe, with Fribble finding your moves.

The code speaks for itself. Speaking for my self, I can say that I have never had more fun writing a program than I have had writing FRIBBLE.

FRIBBLE is also my first program inspired by an election.

I was an obsessive follower of the recent presidential election, spending more time than I care to admit on Twitter, reading blogs, listening to podcasts, and so on.

After the election, looking for a more productive and entertaining form of amusement, I started playing Words With Friends, an online version of Scrabble. My foe was a fellow IBMer and friend who said he was quite good at WWF.

Indeed he is. We have played many games and I have yet to beat him. Often his score is 50% higher than mine.

Soon after I realized I was unlikely to ever win a game against him, I though of using my programming skills to see if I would write a program that could play WWF.

Fribble, representing just over two months of the most fun I have yet had writing a program, is the realization of that goal.

What has made the writing of Fribble such fun is the realization that it is as close to an ideal demonstration of SPITBOL as I have yet seen. Everyone knows about games such as Scrabble and WWF, and dealing with strings, words, lines of text, dictionaries, and all that such games involve, is the perfect grist for SPITBOL’s mill.

Though the program is largely done, I plan to continue work on it by using it as a way to teach SPITBOL as a first, or at least early, programming language.


SPITBOL for OSX is now available

The SPITBOL project is pleased to announce that an implementation for OSX is now available, and can be found at github.com/spitbol/spitbol.

SPITBOL now supports the use of the gas (GNU as) assembler to translate the MINIMAL source code. This is now the default translator used for Unix and OSX.

Executable binaries:

./bin/sbl_osx OSX SPITBOL (64 bits)

./bin/sbl_unix Unix version (64 bits)

./bin/sbl_unix_32 Unix version (32 bits)


./docs/green-book.pdf The SNOBOL4 Programming Language, Griswold, et. al.

./docs/spitbol-manual.pdf SPITBOL User Manual, Emmer and Quillen

./demos demonstration programs from the SPITBOL User Manual

SPITBOL is licensed under the GPL (v2 or later) license. All code needed to build the system is included in this repository.

To build spitbol (./sbl):


make osx

make test_osx

make unix

make test_unix
See readme.txt for instructions on interpreting the test output.

GCC: The First Compiler With Its Own Flag

While trying to look up some information about the gcc compiler, I did a search on ‘gcc flag -m’.

Here’s a picture of the results from Google:

Search results for 'gcc flag -m'.

Search results for ‘gcc flag -m’.

This is the first time I have ever searched for info about a compiler option (they are also called flags) and gotten a picture of a real flag.

Thing is, I can’t find the picture of RMS on the flag.

Go figure.

On the Merit of Transparent Console Windows in Ubuntu Linux

I use Linux Mint — a variant of Ubunbu Linux — for my day to day programming. Here’s a screen shot of what my screen usually looks like:

Usual mode - two console windows.

Usual mode – two opaque terminal windows.

Above you seen two terminal windows. I use the KDE Konsole program; this is my normal mode. I do edits in the right window. I use the left window to view output, search files,
and so forth.

Here’s another mode I’ve just started using:

Screenshot-transparentTwo opaque terminal windows with transparent window in middle

See the difference?

There’s a new terminal window in the middle, but it’s transparent — you can see through it to the windows below.

Now I had known about transparent terminal windows for some time, but I had never never gotten around to trying them. I was happy with my usual mode of just two opaque windows.

A couple of weeks ago I updated my desktop to use the latest version of Linux Mint. Though Mint comes with the Konsole program, you have to dig around in the menus to find it.
There’s always a quick link to a terminal program in easy view, but it’s not for Konsole.

It turns out this version of Mint configures that default terminal program to use a transparent screen. So I tried it, and finally appreciated the advantage of the

Though the transparency is a nuisance when just editing text, it’s great for other situations.

For example, if I need to do a small task, and don’t want to disturb my two normal windows, I just open up a transparent window.

The main advantage I’ve found is that if I’m looking at a web page with instructions on how to do something, then I can open a transparent window, view the instructions
through the window, and enter them directly with much less chance of error.

Unix SPITBOL 13.05 Released, With Support for Unicode

The SPITBOL project is pleased to announce that Unix SPITBOL 13.05 is now available.

It can be downloaded from http://spitbol.googlecode.com/files/spitbol-13.05.tar.gz.

This release includes versions of SPITBOL for both ASCII (8-bit characters) and Unicode (32-bit characters).

The Unicode version of SPITBOL (uspitbol) uses 32-bit characters internally. Character strings are converted from UTF-8 encoding to 32-bit characters when input from the command line, the operating system environment, a pipe, or a file opened in line mode. Character strings are converted from 32-bit characters to 8-bit characters in UTF-8 format when written to a file opened in line mode, a pipe, or when passed as an argument to an operating system procedure.

Program source files, which are read by SPITBOL in line mode, may thus contain UTF-8 format Unicode characters in strings and comments. Identifiers are still restricted to ASCII.

Unix SPITBOL 13.01 Released

The SPITBOL Project is pleased to announce that Unix SPITBOL 13.01 is available.

It can be downloaded from Github: HARDBOL/SPITBOL:

13.01 tar.gz

13.01 zip

This release supports floating-point arithmetic and save files. Load modules and the loading of external functions are still not supported.

Introduction to the Macro SPITBOL MINIMAL Reference Manual

The source code for MACRO SPITBOL contains extensive documentation. I have extracted the specification of the MINIMAL (Machine Independent Macro Assembly Language) and the specification of the OSINT (Operatint System INterface) and converted the plain text to HTML, resulting in what is now the “MINIMAL Reference Manual.

As part of this effort I wrote an introduction in order to give a sense of the flavor of the code. Here is that introduction:


The implementation of MACRO SPITBOL is written in three languages: MINIMAL, C, and assembler.

The SPITBOL compiler and runtime is written in MINIMAL, a machine-independent portable assembly language.

The runtime is augmented by procedures written in C that collectively comprise OSINT (Operating System INTerface). These procedures provides such functions as input and output, system initialization and termination, management of UNIX pipes, the loading of external functions, the writing and reading of save files and load modules, and so forth.

The implementation also includes assembly code. This size of this code varies according to the target machine. About 1500 lines are needed for the x86 architecture running UNIX.

This code provides such functions as macros that define the translation of MINIMAL instructions that take more than a few machine-level instructions, support for calling C procedures from MINIMAL, for calling MINIMAL procedures from C, for creating save files and load modules, and for resuming execution from save files or load modules.

To give some idea of the flavor of the code, consider the following simple SPITBOL program that copies standard input to standard output.

loop output = input :s(loop)

By default, the variable input is input-associated to standard input, so each attempt to get its value results in reading in a line from standard input and returning the line as a string. The read fails if there are no more lines, and succeeds otherwise.

Similarly, the variable output is output-associated with standard output, so each assignment to output causes the assigned value to be written to the standard output file.

The osint procedure for writing a line is SYSOU. It is called from within SPITBOL as part of assignment, as shown in the follwing excerpt from the MINIMAL source:

*      here for output association

asg10  bze  kvoup,asg07      ignore output assoc if output off
asg1b  mov  xl,xr            copy trblk pointer
       mov  xr,trnxt(xr)     point to next trblk
       beq  (xr),=b_trt,asg1b loop back if another trblk
       mov  xr,xl            else point back to last trblk
.if    .cnbf
       mov  -(xs),trval(xr)  stack value to output
       mov  xr,trval(xr)     get value to output
       beq  (xr),=b_bct,asg11 branch if buffer
       mov  -(xs),xr         stack value to output
       jsr  gtstg            convert to string
       ppm  asg12            get datatype name if unconvertible

*      merge with string or buffer to output in xr

asg11  mov  wa,trfpt(xl)     fcblk ptr
       bze  wa,asg13         jump if standard output file

*      here for output to file

asg1a  jsr  sysou            call system output routine
       err  206,output caused file overflow
       err  207,output caused non-recoverable error
       exi                   else all done, return to caller

From the OSINT C code (the C procedure name starts with ‘z’ since there is intermediate code (shown below) to call from MINIMAL to C at runtime):

    REGISTER struct fcblk *fcb = WA(struct fcblk *);
    REGISTER union block *blk = XR(union block *);
    int result;

    if (blk->scb.typ == type_scl) {
	/* called with string, get length from SCBLK */
    } else {
	/* called with buffer, get length from BCBLK, and treat BSBLK
	 * like an SCBLK

    if (fcb == (struct fcblk *) 0 || fcb == (struct fcblk *) 1) {
	if (!fcb)
	    result = zyspi();
	    result = zyspr();
	if (result == EXI_0) 
	    return EXI_0;
	    return EXI_2;

    /* ensure iob is open, fail if unsuccessful */
    if (!(MK_MP(fcb->iob, struct ioblk *)->flg1 & IO_OPN)) {
	 return EXI_1;

    /* write the data, fail if unsuccessful */
    if (oswrite
	(fcb->mode, fcb->rsz, WA(word), MK_MP(fcb->iob, struct ioblk *),
	 XR(struct scblk *)) != 0)
	 return EXI_2;

    /* normal return */
    return EXI_0;

Here is the assembly code that is used to call a C procedure from MINIMAL. The code is for 32-bit X86
and is written using NASM (Netwide Assembler) syntax.

	%macro	mtoc	1
	extern	%1
	; save minimal registers to make their values available to called procedure
	mov     dword [reg_wa],ecx     
        mov     dword [reg_wb],ebx
        mov     dword [reg_wc],edx	; (also reg_ia)
        mov     dword [reg_xr],edi
        mov     dword [reg_xl],esi
        mov     dword [reg_cp],ebp	; Needed in image saved by sysxi
        call    %1			; call c interface function
;       restore minimal registers since called procedure  may have changed them
        mov     ecx, dword [reg_wa]	; restore registers
        mov     ebx, dword [reg_wb]
        mov     edx, dword [reg_wc]	; (also reg_ia)
        mov     edi, dword [reg_xr]
        mov     esi, dword [reg_xl]
        mov     ebp, dword [reg_cp]
;	restore direction flag in (the unlikely) case that it was changed
;	note that the called procedure must return exi action in eax


	global	sysou			; output record
	mtoc	zysou

How to access, read, write, or mount a USB flash drive in Ubuntu Linux

My most viewed blog post is about how to access a flash drive on Ubuntu Linux. Written five years ago, it is my most-viewed post ever. For example, it now accounts for over a third of my views each day. [1]

This suggests that lots of folks are still having problems using flash drives on Ubuntu, and possibly other Linux distributions as well

The post is a bit dated. A lot has changed in the last five years, so here’s an update on how I currently access flash drives on my Ubuntu 12.04 desktop.

When you first put a flash drive into the computer all you will see is the light on the flash drive come on, if it has one.

If you do

$ ls /media

you won’t see any sign of the drive.

So what you do next is to open File Manager. It’s right there near the top of the main menu. It should show the flash drive. All the drives I have come with a built-in id, and File Manager will display it near the top of its page. Look for text that begins with /media/.

For example, I just plugged in a drive while writing this. It has the id 054A-FDA0.

Leave File Manager running, while you access the drive

If you again do

$ ls /media

you should see the drive. For example, I just did and found the file /media/054A-FDA0.

You can now do things like

$ cp /media/054A-FDA0/work.tar .

and so on.

It is good form to close the drive when you are done using it. This is not really needed if you are just reading the drive, but is important if you have written data to it. You want to know all the data has been written.

There are two ways to do what in Linux is called “unmounting” the flash drive.

One is

umount /media/054A-FDA0

Note the command is “umount” and not “unmount”. This is one case where Unix terseness, in this case saving a single letter, did more harm than good.

Another is to go back to File Manager, find the symbol for the drive in the left column, and right click your mouse on it. You will get a list of options, one of which is Eject Removable Medium. Then pick that, and remove the drive

Either will work. You make the call.

By the way, whenever you are typing a command that includes the flash drive id, as soon as you have typed the first letter or so, you should hit the Tab key. The shell will then complete the rest of the name for you.

(This is true whenever you are entering a file name. It’s one of the very nice features of Linux: thoughtful people have worked hard to make your work easier.)


1 The second most-viewed post is A Brief History of Operating Systems, based on a couple of days of writing done while I was at IBM. Steve Mills, then and now head of IBM’s Software Group, felt that his salesmen didn’t know enough about this topic, and asked that someone put something together. The request landed on my desk, and not having anyone else I could kick it down the road to, I had to do it myself. [2]

2. One of the sagest observations I have ever heard came from Ralph Griswold, in a conversation almost forty years ago:

I wish I had done it myself. In the long run I always do.

  • Pages

  • February 2017
    M T W T F S S
    « Jan    
  • RSS The Wayward Word Press

  • Recent Comments

    dave porter on On being the maintainer, sole…
    daveshields on On being the maintainer, sole…
    Paul Tallett on On being the maintainer, sole…
    mrrdev on On being the maintainer, sole…
    KT on On being the maintainer, sole…
  • Archives

  • Blog Stats

  • Top Posts

  • Top Rated

  • Recent Posts

  • Archives

  • Top Rated