Retro - TechTinkering

A Quickstart Guide to Editing Paper Tape with the Symbolic Tape Editor on the DEC PDP-8

Tue, 16 Jun 2009 15:27:26 GMT

Before re-writable storage devices, such as tape drives, become popular for the DEC PDP-8, owners had to rely on paper tape. This was fine for loading programs on pre-punched tape, but left the problem of how to put new data onto punched tape and how to edit existing data. This could be done off-line, but a better way was to use DEC's Symbolic Editor. This made life much easier as it allowed you to interactively edit a tape in a buffer, check the alterations and then output a new tape. This editor was used for quite a few years by those wanting to edit Assembly or FORTRAN source code. What follows is a brief introduction to using this editor.

Obtaining the Symbolic Editor and Its Manual

The Symbolic Editor can be obtained from, the invaluable resource for retro software and documentation, Bitsavers. The paper-tape image is called: DEC-08-ESAB-PB.bin. This file is loadable by emulators such as SimH, but owners of a real PDP-8 will have to find a way to punch this image to paper-tape. The Symbolic Editor Programming Manual is also available from bitsavers in PDF format.

Theory of Operation

The editor works by containing the text you are editing in a buffer in memory referred to as a page. So when you read in a paper-tape, it will read as much as it can into the free memory and then ring a bell to indicate that you may begin editing. You can then edit this text and write it to a new paper tape.

The editor works a bit like the Unix editor, vi, in that it has two modes of operation: command mode and text mode. When in command mode all text typed via the teletype is interpreted as text editing commands. When in text mode all text typed in via the teletype is either adding to or altering the text in the buffer.

When the editor is first loaded it starts off in command mode, you can then type your desired command followed by RETURN to action it. Depending on the command, the editor may now switch to text mode and allow you to edit the buffer.

When in text mode you must press RETURN after each line that you enter to save it to the buffer. To return to command mode and to cancel the current line you are typing press CTRL+FORM (CTRL+L).

Starting the Editor

Instructions for Owners of a Real PDP-8

To load the editor from paper-tape on a real PDP-8 just load the Binary Loader first and then the editor from paper-tape in the normal way. The program can then be started at Octal address 200. If you have a high-speed punch or reader then you will want to set Switch Register bit 10 to high for a high-speed punch and bit 11 to high for a high-speed reader (See section 1.4 of Symbolic Editor Programming Manual).

Instructions for Those Using SimH to Emulate a PDP-8

If you are using SimH, then the following applies:

To load the editor's paper-tape image from the current directory in SimH:
sim> load DEC-08-ESAB-PB.bin

SimH emulates a high-speed punch and reader, so you will want to set Switch Register bits 10 and 11 to high to tell the editor that this is what you will be using:
sim> de sr 3

To run the editor (200 here is in Octal):
sim> run 200

Commands

The commands take the following form where E represents any command:

Command Structure	Purpose
E	Perform command E
nE	Perform command E on line n
m,nE	Perform command E on lines m to n, inclusive.

Below is a brief list of useful commands to get you started:

Command	Description
A	Appends the text from the teletype to the buffer, if the buffer is blank then this can be used to create a new paper-tape
C	Changes the specified line or range of lines
D	Deletes a line or range of lines from the buffer
I	Inserts text before line 1 or before the specified line
K	Kill the entire page buffer
L	Lists a page, line or range of lines from the buffer
P	Punches the contents of the buffer, line or range of lines to the paper-tape punch
R	Reads a page of text from the paper-tape reader and appends it to the buffer

Example

If we wanted to create a new paper-tape with source code for a FORTRAN program we could do the following:

Start the Editor as above, note that when it is started it doesn't come up with a prompt, so don't worry if it looks as if it isn't doing anything.
Owners of a real PDP-8, attach a blank piece of paper-tape to the punch.

If using SimH, then press CTRL+E to get to the sim prompt and attach a file to the paper-tape punch:
sim> attach ptp factorials.ft

To get back to the editor:
sim> cont

The editor starts with a blank buffer. To append the following source code to it, used the command: A, and then enter:

C;      THIS PROGRAM CALCULATES FACTORIALS
5;      TYPE 200
10;     ACCEPT 300,X
        FACT=Y=1.
        IF (X) 5,32,30
30;     IF (X-Y) 41,32,33
32;     TYPE 400,X,FACT
        GO TO 10
33;     FACT=FACT*(Y=Y+1.)
        GO TO 30
41;     PAUSE
        GO TO 5
200;    FORMAT (/, "PLEASE TYPE A POSITIVE NUMBER", /)
300;    FORMAT (E)
400;    FORMAT (/,E, "FACTORIAL IS",E)
        END

Remember to press RETURN after each line including the last line to make sure that it is saved to the buffer.

Press CTRL+FORM (CTRL+L) to go back to command mode.
Test some of the commands such as: 1,5L, to list the first 5 lines in the buffer.
Punch the buffer to paper-tape with the command: P

If you wanted to read an existing paper-tape into the editor:

If the editor isn't already started do so as above, otherwise use the command: K to clear the contents of the buffer.
Owners of a real PDP-8, attach the paper-tape that you want to edit to the paper-tape reader.

If using SimH, then press CTRL+E to get to the sim prompt.

If you haven't already detached the file above from the paper-tape punch then:
sim> detach ptp

To attach the file we made previously to the paper-tape reader:
sim> attach ptr factorials.ft

To get back to the editor:
sim> cont
Read the paper-tape into the buffer with the command: R
List its contents with the command: L

Where Now?

This editor can be really quite flexible and you can even create separate tape editing tapes which will automatically run the tape editors commands over a tape to be edited. More information can be found by reading the Symbolic Editor Programming Manual. In addition if you haven't used SimH before, take a look at my article: Emulating a DEC PDP-8 with SimH. I intend to follow this article with some further articles on programming the PDP-8 and will be using this editor to do this shortly.

A Quickstart Guide to Editing Paper Tape with the Symbolic Tape Editor on the DEC PDP-8
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Book Review: Electronic Brains: Stories from the Dawn of the Computer Age by Mike Hally

Wed, 03 Jun 2009 12:40:11 GMT

Amazon

This is an interesting history of computer development around the world during the 1940s and 50s. The book grew out of a radio series on BBS Radio 4 and contains lots of original material gained from interviews in 2001 and 2004. It is very accessible as it focuses slightly more on the events and people involved than the technical details, although it has enough of the latter to show how the technology evolved.

	Electronic Brains: Stories from the Dawn of the Computer Age
Author	Mike Hally
Pages	304
Edition	Second Edition (2006)
Publisher	Granta Books
ISBN	1-86207-839-4

While reading this I came across quite a few surprises, such as the early successes in Australia. There is also a chapter on Remington Rand's Rand 409, another early computer which I don't think has been covered much elsewhere. Finally it tries to explain how IBM became the market leader despite its late entry into the field.

Throughout the book the author tries to show how each team and country may have influenced each other and where they may have innovated in isolation. He also tries to tackle the often debated question: Which was the first computer? His answer essentially comes down to what you call a computer, and therefore there are a number of firsts depending on how you define this.

I highly recommend this book to anyone interested in how the first computers came into being and particularly to those who want to look beyond Britain and America.

Book Review: Electronic Brains: Stories from the Dawn of the Computer Age by Mike Hally
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Emulating a DEC PDP-8 with SimH

Tue, 26 May 2009 15:00:33 GMT

The DEC PDP-8 mini-computer was launched on 22 March 1965 and was a great success. It was fairly cheap for the day and could easily be expanded. What attracts me most to the PDP-8 is its simple design. I therefore decided to experiment with the SimH emulation of this machine, but found that the documentation wasn't always straightforward. This article intends to show how easy SimH is and how powerful it can be.

Obtaining SimH

SimH can be obtained from The Computer History Simulation Project. It is available as a Windows executable or as source code which can be compiled on many different systems. In addition it is included with most Linux distributions. SimH actually emulates a number of computer systems, and all are included.

Starting the PDP-8 SimH Emulator

SimH is very easy to use once you get the hang of the way that it works. The PDP-8 emulator is started with the command: pdp8. The first thing that you generally see is the version of the simulator followed by the sim> prompt. At this prompt you can control the simulated hardware of the machine, configure various options and once you start a program it will be taken over by the Console Input/Output of the emulated computer.

SimH will allow you to run a PDP-8 just using the front panel switches, or you can use simulated paper tape and a teletype, as well as a number of other devices. Some programs run directly on the PDP-8 and there are a few operating systems available with their associated software.

Once you have had enough, you can exit the emulator with the following command at the sim> prompt:

exit                         Returns to host Operating System

Configuring the Emulator

SimH is highly configurable and has a number of options which can be set from the sim> command prompt. Below are the most useful to start with.

Controlling the Emulation Speed

On some host machines, the emulator can be made more realistic by slowing down the speed of execution. This is done using one of the following commands:

set throttle xM              Set execution rate to x mips
set throttle xK              Set execution rate to x kips
set throttle x%              Limit simulator to x% of host time
set nothrottle               Turn off throttling

Reducing Resource Use on the Host Machine

Some host machines support the following command to control how resources are used.

set cpu idle                 Reduces drain on host machine when emulated cpu is idle
set cpu noidle               Constant drain on host machine

Connecting the Console to a Telnet Port

If you wish to connect the output of the console to a telnet port, this can be done with the following:

set console telnet=<port>    Connect console terminal to Telnet session on port
set console notelnet         Disable console Telnet

Automating the Configuration

The above configuration options can be stored in a file so that each time the PDP-8 emulator is started, they will take effect. To do this put any of the options above into a file called pdp8.ini. Now when the PDP-8 emulator is started, it will look to see if the file pdp8.ini is in the current directory, if it is then the lines from it will be read in just as if you had typed them at the sim> prompt.

Example pdp8.ini file

If the following lines are put in a file called pdp8.ini, the emulator will not hog so many resources on the host system, will emulate at 500,000 Instructions Per Second and the console will be reachable through telnet on port 18977. However, not all of these settings will work on all machines.

set cpu idle
set throttling 500k 
set console telnet=18977

Devices

SimH can emulate a large number of the devices that were attached to the PDP-8. Each of these devices can be connected to a file on the host system, e.g. The line Printer (LPT) could be connected to a file called print.out and then if anything was printed from the PDP-8, it would go to that file. The most important devices for the purpose of this article and up-coming ones are:

Unit	Description
PTR	High-Speed Paper Tape Reader
PTP	High-Speed Paper Tape Punch
LPT	Line Printer
RX	Floppy Disk (RX01 and RX02)
RF	Fixed Head Disk
DT	DECtape (DT00 to DT07)

Devices can be connected to files or disconnected with the following commands:

attach <unit> <filename>
detach <unit>

Octal Addressing

The natural way of abbreviating binary numbers on the PDP-8 is in octal. This is a base 8 number system where each octal digit represents 3 bits. The machine uses 12-bit addressing and hence 4 octal digits represent these 12 bits. When these bits are referred to it must be remembered that the PDP-8 uses big-endian bit numbering (that is, bit 0, the left most bit, is the most significant).

Low-level Access to the Machine

The PDP-8 often required you to access registers and memory addresses directly and it was particularly common for software to require you to configure certain option by setting the front panel switches. Below are the most important registers that can be set through SimH:

Name	Size in bits	Description
PC	15	Program Counter, including IF as high 3 bits
AC	12	Accumulator
L	1	Link
MQ	12	Multiplier Quotient
IF	3	Instruction Field
DF	3	Date Field
SR	12	Switch Register (Front Panel Switches)

Commands to Change/Examine Memory/Registers

There are two main commands that can be used to change or examine memory locations and registers:

examine <Register|Memory Location>              Examine a Register|Memory Location
deposit <Register|Memory Location> <Value>      Deposit Value in the Register|Memory Location

To make this easier, examine can be abbreviated to e and depost can be abbreviated to d.

Controlling Programs

There are a number of commands to start a program running and control its execution:

run [<address>]              Resets all devices and starts execution at address 
                             or PC if address not specified
go [<address>]               As above, but doesn't reset devices
cont                         Does not reset devices and continues execution at PC
boot <unit>                  Resets all devices and bootstraps the device and unit given by its argument. 
                             If no unit is supplied, unit 0 is bootstrapped

On a real PDP-8 to load a program the first step is often to enter a short program via the front-panel switches that loads paper tape in RIM format. This is then generally used to load a Binary Loader program via paper tape. This Binary Loader can then load programs via paper tape in BIN format. The BIN format is normally used for programs as it is more compact. You could follow this process with SimH, but there are some shortcuts to make things easier:

load -r <filename>            Loads a file from the host system in RIM format
load <filename>               Loads a file from the host system in BIN format

You can use CTRL+E to get back to the sim> prompt when talking to the emulated PDP-8 via the Console Input/Output. This is defined by the WRU (Where are you) console option and is initially set to 005 (CTRL+E). To continue execution you would just use the cont command above.

FOCAL-69

To give a quick demonstration of SimH, I have chosen to use FOCAL-69. FOCAL-69 was an important version of the FOCAL (FOrmula CALculator) programming language, created by Richard Merrill. It would run even on systems with only 4K of memory but could use more if available. A copy of the FOCAL-69 Promotional Booklet is available from Douglas W. Jones's PDP-8 page and a FOCAL-69 binary paper tape image is available from the SimH Software Kits Page.

To try out FOCAL-69 in the PDP-8 emulator, first uncompress the file containing the FOCAL-69 binary paper tape image downloaded above. This will give you a file called focal69.bin. Now run, pdp8 in the directory in which focal69.bin is located.

To load the paper tape image into memory type:
sim> load focal69.bin

Programs loaded from paper tape in binary format often start at Octal address 200 and this is the case here. To start the program run:
sim> run 200

FOCAL-69 will now start and present you with the * prompt. To say hello to the world type the following excluding the * which is the prompt:
* _TYPE "HELLO, WORLD"

Where Now?

More information is available at the The Computer History Simulation Project, particularly on the Simulator Documentation page. There are several software kits available to run on the PDP-8 and documentation for these can be found on the Simulator Documentation page. Another good source of software and documentation is at bitsavers.org.

I will shortly be writing some more articles on the PDP-8, so stay tuned.

Emulating a DEC PDP-8 with SimH
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Connecting a Parallel Printer to a Modern Linux Machine Using a LogiLink USB to Parallel Cable, D-SUB 25pin

Wed, 06 May 2009 11:34:28 GMT

Amazon

I have a number of older printers that I would like to connect to my modern machine, but have been unable to do so because my computer doesn't have a parallel interface. After searching the internet for a review of a usb to parallel cable that works reliably with Linux, I pretty much drew a blank. I then decided to look on Amazon and just give one a go. Below is my brief review of the product that I found to work. I hope that it is of some help to others who are looking for a similar cable.

I decided to purchase the USB Parallel Printer Port Cable 25 pin female socket advertised on Amazon by Cablestar. I went for the version with a female 25pin D-SUB on the end, as not all my printers have a standard Centronics interface. My HP LaserJet 1100, for example, has a Mini-Centronics interface. When the package arrived two days later I found that it was a LogiLink USB to Parallel Cable, D-SUB 25pin. The package had the standard drivers for various flavours of Windows, but no drivers for Linux. This came as no surprise, indeed I really would have been surprised if there had been drivers for Linux.

Now it was time to see whether my kernel (2.6.26 on Debian Lenny 5.01) would recognise this cable. I plugged the cable into a free USB port on my computer and plugged my printer's parallel cable into the other end; straight away a printer port was created at /dev/usb/lp0. All I had to do then was configure CUPS to see this printer, which was easily achieved through the Printing configuration option in the Administration menu of Gnome.

Even now I can't get over how easy this was, I was expecting at least a few little difficulties, but it really couldn't have been easier. I therefore recommend this product unreservedly.

Connecting a Parallel Printer to a Modern Linux Machine Using a LogiLink USB to Parallel Cable‚ D-SUB 25pin
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

An Introduction to Corewar

Thu, 30 Apr 2009 13:03:07 GMT

I remember reading about Corewar roughly 20 years ago and thinking that I will have to have a go at that when I get the time. As often happens in life, things got in the way and I only recently managed to give it a go. I love the challenge of programming and the competitive aspect of this programming game really appeals to me. The object of the game is to write a battle program that will take over a virtual computer and kill the other battle programs running upon it. Since the game recently celebrated it's 25th birthday, I thought that I would write the following brief introduction to the game to whet peoples' appetite and encourage new interest.

History

The game was first described in Core War Guidelines by D. G. Jones and A. K. Dewdney in March 1984 and was introduced to the public in May 1984 via Dewdney's Computer Recreation column in Scientific American.

There have been several revisions to REDCODE (the form of assembly language in which the programs are written). The most used is currently The International Core Wars Society (ICWS) 1994 standard with the extensions introduced by pMARS 0.8. There is also some interest in the older ICWS '88 standard.

The MARS Environment

The programs are run in the MARS (Memory Array Redcode Simulator) environment. The object of the game is for the programs to take over the environment's memory (Core), and kill the other programs. The core is circular and memory addresses are relative to the current position. This is so that it does't matter where a program starts in the core. The biggest difference from a real processor is that each memory location consists of an instruction and its two operands.

As mentioned above, the programs are written in a form of assembly language called REDCODE. The most common version of this gives the following instructions:

DAT	Data	Kills the current process
MOV	Move	Copies data from one address to another
ADD	Add	Adds one number to another
SUB	Subtract	Subtracts one number from another
MUL	Multiply	Multiplies one number by another
DIV	Divide	Divides one number by another
MOD	Modulus	Divides one number by another and gives the remainder
JMP	Jump	Continues execution from another address
JMZ	Jump if zero	Tests a number and jumps to an address if it's 0
JMN	Jump if not zero	Tests a number and jumps if it isn't 0
DJN	Decrement and jump if not zero	Decrements a number by one, and jumps unless the result is 0
SPL	Split	Starts a second process at another address
CMP	Compare	Same as SEQ
SEQ	Skip if equal	Compares two locations, and skips the next instruction if they are equal
SNE	Skip if not equal	Compares two locations, and skips the next instruction if they aren't equal
SLT	Skip if less than	Compares two locations, and skips the next instruction if the first is less than the second
LDP	Load from p-space	Loads a number from private storage space
STP	Store to p-space	Stores a number to private storage space
NOP	No operation	Does nothing

In addition, there are a number of different addressing modes and instruction modifiers which change the way that they act. These combine to make REDCODE able to express a lot in very little code.

Example Programs

I have provided slightly altered versions of the standard example programs written by A. K. Dewdney to give you an idea of how the programs work.

IMP

This is one of the simplest program that can be written in REDCODE. It just replicates itself throughout the core and consists of only one instruction:

    mov.i 0, 1

This copies memory location 0 to memory location 1. The .i suffix is an instruction modifier which means that mov is to copy the whole of the memory location. Therefore, in this case the instruction copies the current instruction at location 0 (remember that the addressing is relative and a memory location contains an instruction and it's operands) to location 1 (the next location). Execution then continues at the next memory location, which now contains the same instruction as the last, so this program rapidly replicates itself throughout the core.

However, the program does not kill the other programs, so where it writes over another program, the other program will just execute this code instead. This is useful to make another program ineffective, but it still needs to be killed by getting it to execute a DAT instruction, otherwise the outcome is likely to be a tie.

DWARF

As mentioned above the IMP won't kill another process. To do this you need to get a process to execute a DAT instruction. This is therefore what the following program does:

    add.ab  #4, 3        
    mov.i   2, @2
    jmp    -2
    dat    #0, #0

The program starts by adding the literal number 4 to memory location 3, which contains the DAT instruction. This DAT instruction is known as the bomb as it is what will stop another process. The .ab suffix indicates that the A field (containing #4) of the source should be added to the B field (containing #0) of the destination. The bomb at memory location 2, is then copied to the memory location pointed to by the B field of the bomb. In-direct addressing via the B field is indicated by the @ symbol. Finally the program starts back again at the beginning. You can therefore see that this copies a bomb to every fourth memory location, and if the core is divisible by four, it will never bomb itself.

Strategies

Strategies range from the examples given above of code that replicates itself or bombs other programs, to code that scans for other programs before disabling them or killing them. Decoys can be used to fool the scanners and you can combine strategies to increase effectiveness. The latest developments are self-repairing code and battle programs that have been evolved. The possibilities really are endless.

Competing and Other Activities

There are a number of ways that you can compete and add interest to REDCODE programming:

You can run other peoples' programs against your own via a simulator on your computer.
Once you have created an effective battle program you could submit it to a hill such as King of the Hill, where it will compete against other battle programs.
Engage in The Mini Challenge, where specific programming challenges are set.
You can use the constraints placed upon the programmer by REDCODE as an interesting platform to experiment with. This is the focus of a lot of the posts on Thoughts on Corewar....

Where Now?

To begin you will need to download a simulator such as pMARS and a tutorial such as The beginners' guide to Redcode. Further information can be found at the excellent site: Corewar - the war of the programmers.

I must warn you before you try it yourselves; it is incredibly addictive as you will nearly always want to make just one more tweak to improve a battle program. Have fun, but remember it is only a game.

An Introduction to Corewar
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

The Smallest Communication Program in the World?

Thu, 23 Apr 2009 11:32:46 GMT

I was going through a backup of my dos machine, taken in 1998, and came across some source code which I haven't seen for a long time. It was great to see that old code, and I must set-up a machine so that I can run some of it again. In particular I came across an attempt at writing the world's smallest communication program for an x86 based PC running DOS. I used to love writing these sort of little programs to test different things. I know we get more done these days, but it was fun tinkering around at such a low-level. So here follows the program.

The Assembly Code

The following code was written, for Borland Turbo Assembler, when I was 17. It maybe that, with experience, I could now write a smaller version, so my boast of 15 years ago may no longer be true!

;----------------------------------------------------------------------------
; This is probably the smallest modem communication program in the world,
; and was written to make a smaller program than Doug Cox's comms program,
; which was claimed to be the smallest.
;
; Doug Cox's program : 72 bytes
; My program         : 50 bytes
;
; You use AT commands to control the modem.
;
; The following functions are also provided:
;       ALT + C    Clear the screen
;       ALT + X    Exit
;
;----------------------------------------------------------------------------
;   Program name : ljatcom
;   File name	 : ljatcom.asm
;   Author	 : Lawrence Woodman
;   Date         : 11 December 1994
;----------------------------------------------------------------------------
.model small
.code
org 100h

pregetstatus:
  mov  ax, 3
  int  10h

getstatus:
  mov  dx, 2FDh              ; Line status Register
  in   al, dx
  and  al,1
  jz   check_for_key         ; If nothing from modem
  mov  dx,2F8h               ; Receive/Transmit Date Register
  in   al,dx                 ; Receive it
  mov  ah,0Eh                ; Function to write char on screen
  int  10h
  jmp  short getstatus

check_for_key:
  mov  ah, 1                 ; Function to get keyboard status
  int  16h
  jz   getstatus             ; If no keyboard input
  dec  ah                    ; Function to get keyboard char
  int  16h
  cmp  ax,2E00h              ; ALT-C
  je   pregetstatus
  cmp  ax,2D00h              ; ALT-X
  je   exit
  mov  dx,2F8h               ; Receive/Transmit Data Register
  out  dx,al                 ; Send it
  jmp  short getstatus

exit:
  ret

end pregetstatus

Assembling

I used Borland Turbo Assembler to assemble this file and produce an executable .COM file:
C:\> tasm ljatcom.asm
C:\> tlink ljatcom /x /tdc

If you don't have this assembler, the source can easily be converted to the format of your favourite assembler.

Using Debug to Create the Executable

For those not able to assemble the above code, I created a script with HEXBUG which can be run through the DOS command, debug, which will create the executable .COM file.

Copy the following script into ljatcom.bug

 NLJATCOM.COM
 E100 B8 3 0 CD 10 BA FD 3 EC"$"1"t"A BA F8 3 EC B4 E CD 10 EB EE B4
 E118 1 CD 16"t"E8 B4 0 CD 16"="0".t"DA"="0"-t"6 BA F8 3 EE EB D4 C3
 RCX
 32
 W
 Q HEXBUG Version 1.02 by Chad Wagner

Run this script through debug:
C:\> debug < ljatcom.bug

Using the Program

This program is very simple, as you can see, and operates on COM1. It is so small because it relies on your ability to command the modem directly.

To run it just type:
C:\> ljatcom

Commanding a Hayes Compatible Modem

To reset the modem:
ATZ

To dial a number, where number is the number that you wish to dial:
ATDnumber

Operating Once the Connection Has Been Established

Once the number has been dialed, by using the above commands, the modem will establish the connection and you will be linked to the computer on the other end of the modem. Most dial-up systems, however, use a variety of terminal emulations to control how to display things on your screen, so you will have to use a basic plain text protocol.

File Transfer

I once had an old machine on which the 5¼" drive wasn't working, so I couldn't transfer anything to or from it. I had no other drive with me to replace it, so I connected the machine to another using a null-modem cable. I then entered a slightly altered version of the above program, using debug, into both machines. This allowed me to redirect it's output to a file on one end, and send a serial transfer program to it from the other end. To make this transfer reliable enough, all I had to do was slow the COM port down with the DOS command mode. For these sorts of transfers, if nothing else, the program could still be of some use to those operating older machines.

The Smallest Communication Program in the World?
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

xAce - A Jupiter Ace Emulator for Unix (Patched to correct garbled display)

Thu, 12 Feb 2009 16:24:46 GMT

I love the idea of the Jupiter Ace and think that the choice of the forth programming language was perfect for such a low-spec machine. It is a real shame that forth wasn't chosen for more computers of the period, instead of their using basic. I have not found many emulators for this machine and only one that I could run natively under Linux. This did, however, need patching, as without it the screen wasn't displaying properly. I will show how to patch it in this short post.

The only Jupiter Ace emulator that I found, which would work under Linux, was written by Edward Patel and is called xace. There is also a Windows version available, but I don't know anything more about that. The following instructions, taken partially from the site's help instructions, will show how to install it under Linux.

Download the tarball: xace-0.4.tar.gz.
Extracted the files:
$ tar -xvzf xace-0.4.tar.gz
Changed into the extracted directory:
$ cd xace-0.4
Ran xmkmf to create a makefile from an imake file
$ xmkmf
I have created a patch which is an amalgamation of several patches which I found on the internet. Each had problems, which I have fixed. The patch can be downloaded from here. Save it as xace-0.4.patch in the same directory as the xAce source files.
Patch xmain.c using the patch downloaded above:
$ patch xmain.c xace-0.4.patch
Make the project:
$ make
You can then run the emulator using:
$ ./xace

A Quick Test

When entering any of the following definitions, please make sure that you enter them exactly with the correct placement of spaces.

Try entering the following to create a word called star:
: star ." *" ;

Now when you type star and press return, a star is output.

You could also create a word called stars:
: stars 0 do star loop cr ;

When you enter stars preceded by a number it will printer that number of stars, e.g. the following will print 4 stars:
4 stars

There is a problem with the stars definition however. If you ask for 0 stars, you will still get one star. There are plenty of resources to learn forth out there, so you shouldn't find it difficult working out how to correct this one. Think of it as your first little forth programming test.

Where Now?

There aren't many Jupiter Ace websites around, but one that is particularly good is The Jupiter Ace Resource Site. Another useful source of information is Edward Patel's crash course in forth. This is particularly useful as it mentions Jupiter Ace specific words. I hope that you enjoy playing with this emulator and hopefully for those who haven't used forth, you will gain a new appreciation of it.

xAce - A Jupiter Ace Emulator for Unix (Patched to correct garbled display)
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Book Review: The Mythical Man-Month: Essays on Software Engineering by Frederick P. Brooks, Jr.

Mon, 26 Jan 2009 16:28:26 GMT

Amazon

This book, written in 1975, offers a fascinating insight into the software engineering process used at that time. The author draws from his experience as project manager for the IBM System/360 and OS/360, and in doing so also sheds light on how they were put together. The 1995 edition, reviewed here, is particularly good as it presents the same 1975 text with only typographical alterations, followed by a couple of extra essays and reflection on the previous essays after 20 years.

	The Mythical Man-Month: Essays on Software Engineering
Author	Frederick P. Brooks, Jr.
Pages	336
Edition	Second Edition (1995)
Publisher	Addison Wesley
ISBN	978-0-201-83595-3

The basic premise of the book is that Men and Months are not interchangeable on a software project, and that their design and management can be dramatically improved, but will still remain the most comples part of the process. The book demonstrates that this premise is true and then offers some advice on how to successfully improve the management of software projects. The advice provided is really helpful and well explained. Despite technology's rapid advance, the information in this book is still relevant.

The computer world had changed massively since that time. Throughout the essays you can see glimpses into that world as computers were moving from off-line preparation and batch processing towards a more interactive experience. So many things have changed, and it is fascinating to look back to when programmers had to make space and cost considerations which seem so different from today. As an example, the book mentions renting memory on an IBM Model 165 at $12 per kilobyte per month! At those prices you were sure to keep you code tight!

This work is well worth reading, whether for its retro value or for the insights that it can still offer today.

Book Review: The Mythical Man-Month: Essays on Software Engineering by Frederick P. Brooks‚ Jr.
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Bouncing Babies

Tue, 16 Dec 2008 11:02:51 GMT

Bouncing Babies is one of the first games I remember playing on an IBM PC Compatible. I recall looking at this funny game and thinking that it really was a strange concept. It was released as Shareware by Dave Baskin, but I believe that it is now Freeware.

Here you can see the CGA graphics as the game is played. You control the two men carrying a stretcher and have to bounce the babies into the ambulance as as they fall from the burning building. You gain points for each baby you rescue and have lives in the form of the number of babies that you lose. As the level increases you find that multiple babies are jumping at the same time, so you have to be very quick moving the stretcher back and forth to not drop any.

It is an unusual game and can be strangely addictive when you are in the mood for it. The only real problem with playing it today, on more modern hardware, is that it can be much too quick and needs a utility to slow the machine down. Alternatively if using an emulator then you should be able to slow it down via the emulator's controls. In the case of DOSBox use CTRL+F11 to reduce the speed.

How can I play this great game today?

The game can be downloaded from the Dos Games Archive site here. If you don't have a suitable machine to play it on then you could use the DOSBox emulator. For more information see my article: Using DOSBox to Run DOS Games and Applications.

Bouncing Babies
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

My Top 10 Commodore 64 Demos

Mon, 24 Nov 2008 16:44:27 GMT

There are so many great demos for the Commodore 64 and the demo scene is still thriving. Surprisingly there are even new effects being created for this machine. I have spent many hours going through a huge amount of demos to compile this list and I know that some of the entries are controversial, but they are my personal favourites. There are plenty of demos that people will wonder why they have been left out. This is mainly because the demos in this list already contain most of what they offer and I wanted to show a broad range of styles and effects.

10. Oxyron - Parts
This was released in 1995 and is really just a collection of cool routines without any overall theme tying it together, hence the name, Parts. That said, this demo has a truly superb effect where they wobble a picture which is really quick and smooth. I'm having trouble getting over how cool it is to see this effect done on the 64. I also like the spherical projection of a woman's face rotating about on a sphere. Truly short and sweet.
9. The Ancient Temple - Air dance IV
This is quite a controversial choice and I admit that I included it mainly for the singing chicks on side 2. The chicks use sampled audio throughout a song in quite a clever way that is well put together and works well. It was released in 1991 and this shows a little with some of the graphical effects but I do like the spinning globe. It does, however, have some nice music, particularly the softer more introspective pieces.
8. Byte Rapers - Follow the sign 3 / Unsound minds
Released at Assembly 1996, this is a wonderful example of what can be done with low resolution effects. There are also a couple of examples of good high resolution artwork. I particularly like the way the music is used to add tension and stimulate different feelings throughout the demo.
7. Chorus + Resource - Desert Dream
This is a remake of the original Amiga demo that was released at Breakpoint 2007. It starts with a short 3D movie including movie style credits, which is so well done that it really makes you sit up and pay attention. Accompanying the movie and throughout the demo is some highly charged pumping music perfectly suited to the action. After the movie is finished there is a fairly normal demo, but I do like the horizontal raster bars forming a rotating 3D box.
6. Reflex - Mathematica
This demo, which was released at The Party 1995, has been included mainly for the Wolfenstein 3D dungeon with rotating pictures on the wall. It does have, however, some other good low resolution effects such as a multi-coloured tunnel and a good rotating 3D torus. The music nicely matches the action and is used well to aid transitions.
5. Taboo - Altered States 50%
This was released in 1994 and has earned its place for a number of reasons. There is some brilliant high resolution artwork and some good graphical effects. The wormhole is truly excellent and provides a lovely smooth and quick effect. It is also features a section that has fast spinning 3D objects which smoothly transform from one shape to another.
4. Plush - +H2K
Now it gets really difficult to decide the order of the demos. This one, released at Mekka & Symposium 2000, begins with some beating music which I do find a bit annoying, but it is well synced with the display. This does improve, however, and there is some great high energy tunes later on. Of particular note in this demo is the cool wobbly text scroller, the glass ball moving over an image and the rotating chess board. People not used to seeing the c64 show animations will also be impressed by the Walker animation sequence.
3. Booze Design - Edge of Disgrace
A brand new title, released at X'2008, shows that original demos can still be produced. People have raved about this release and I found even the simpler effects, such as the disco light floor, to be very rewarding. I also like the zooming water effect on an image and the nicely done 3D spinning transforming objects.
2. Resource - Soiled Legacy
This was released at X'2001 and has wonderful music that integrates well with the action and I really liked the light and shade effect moving over a 3D face.
1. Crest and Oxyron - Dues ex machina
As soon as this demo begins you know you are in for a treat. The combination of superb high resolution artwork and brilliant atmospheric music is a winning combination. Partner this with some unbeaten effects such as a spinning and skewing cola can, and it is not hard to see why it won its place. I can't get over how quick and fluid the cola can effect is, especially considering that it moves while doing the effects. I also like the super fast zooming and moving over images and the rotating 3D boxes mapped with images. It was released at Mekka & Symposium 2000 and could well be in the top slot for quite some time to come.

Where can I obtain these great demos?

There are a number of sources for these demos, the best ones are:
The Commodore 64 Scene Database
The C64 Demo Portal
Pouet

I hope that you have enjoyed seeing my favourite demos and who knows, they may inspire you to have a go at writing your own!

My Top 10 Commodore 64 Demos
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Beneath a Steel Sky, My Favourite Graphical Adventure Game

Thu, 13 Nov 2008 15:42:18 GMT

Beneath a Steel Sky was released for the PC in 1994 by Revolution Software. It was received well and has gone on to be considered a cult classic. It uses the Virtual Theatre engine which was first used in Lure of the Temptress and among other things allows the non-player characters to have a basic level of artificial intelligence.

It is set in a dystopian future where man has damaged the earth. The action is confined to Australia within a totalitarian city state called Union City, and you play Robert Foster who has just been kidnapped from an area outside the city known as the Gap. Before Robert knows why he has been kidnapped his helicopter crashes in the city and he makes a bid for freedom. It is now your task to find out why he was kidnapped and keep him safe.

Despite the games dark storyline and brooding atmospheric graphics, the game is full of humour. The characters are warm and engaging and their speech completes their characterisation. Interacting with the characters is realistic and draws you further into this world.

The music is not the best you've ever heard, but it does work well to add to the tension and feel of the game. In particular it is clever how the musical score and sound effects make good use of low pitched sound to increase the sense of unease. In some rooms you directly feel the effects in the pit of your stomach, and this can put you quite on edge.

The easy to use interface means that you face little distraction during the game, and hence you feel more a part of it. You left mouse click to examine items, and right mouse click to trigger actions. The inventory is reached by moving your mouse to the top of the screen. It couldn't be easier and this saves you from having to go through lots of strange actions to see what works. I'm also happy to report that although there are a few places that you can die, there are no actions that can't be undone which stop you from progressing later on.

I have fond memories of playing this game and really feeling a part of the action. Once I had finished it, although I was happy to have completed the adventure, I did feel a little sad that I was no longer exploring that world. I can see myself playing this game again soon.

How Can I Play It Today?

In 2003, Revolution Software made the game available for free. It can now be run via the ScummVM emulator on most modern platforms. For more information about ScummVM, why not take a look at my article: Using ScummVM to Play Classic Adventure Games. Beneath a Steel Sky can be downloaded from the ScummVM site's download page. I hope you enjoy playing this game as much as I did.

Remember: Be Vigilant!

Beneath a Steel Sky‚ My Favourite Graphical Adventure Game
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Using ScummVM to Play Classic Adventure Games

Mon, 10 Nov 2008 11:13:16 GMT

ScummVM is Virtual Machine, that allows you to run adventure games created for a number of game creation engines. This is a great way of playing those classic adventure games that you loved so much, or never got a chance to play at the time. Some of them such as Beneath a Steel Sky have rarely been bettered and can provide hours of fun.

Supported Game Creation Engines

The virtual machine supports a number of game engines, but the most well known are:

SCUMM (Script Creation Utility for Maniac Mansion)
This, as the full name suggests, was written by Lucasfilm Games/LucasArts to make creating the game, Maniac Mansion, on the Commodore 64 easier. Because the game was created using the SCUMM engine, it made porting the game much simpler and hence found it's way to numerous platforms. This engine and later versions of it were used for other classic adventure games such as Zak McKracken and the Alien Mindbenders.
AGI (Adventure Game Interpreter)
This was developed by Sierra online to create their early adventure games. AGI was best known for its use in the Kings Quest and Space Quest series of games.
Virtual Theatre
This engine was developed by Revolution Software to create their new adventure games. Virtual Theatre was used in a number of games including my favourite, Beneath a Steel Sky.

Getting ScummVM

ScummVM comes included with most of the popular Linux distributions. It is also available for lots of other platforms such as AmigaOS, Wii, Mac OS X, Windows and many more. There are pre-compiled binaries available from the download page of their site together with clear installation instructions.

Getting Games to Play on ScummVM

There are a few games that have been made available for free, and can be downloaded from the ScummVM download page. Alternatively you can look at the documentation on which files are needed to use your game with ScummVM. A full list of compatible games can be found here. The games are regularly sold on Ebay and some of them are available in compilations from Amazon: Classic Collections: King's Quest Collection (PC), Classic Collections: Space Quest Collection (PC), Classic Collections: Police Quest Collection (PC)

Where Now?

I would begin by downloading Beneath a Steel Sky from the ScummVM download page. This is probably one of the best games available for it, and it is free. Hmm, have I mentioned Beneath a Steel Sky enough yet? No I don't think so, why not take a look at my article: Beneath a Steel Sky‚ My Favourite Graphical Adventure Game.

Using ScummVM to Play Classic Adventure Games
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Writing My First Program To Toggle In To The IMSAI 8080

Wed, 05 Nov 2008 10:21:23 GMT

I have long been fascinated with entering programs into computers by methods not involving a standard keyboard and monitor. This interest was peeked by my last article: Using the latest z80pack‚ version 1.17‚ to emulate an Altair 8800 or IMSAI 8080 using the new graphical FrontPanel. I have therefore chosen to design and write a program for the IMSAI 8080. In this article I will show you how I went about it, and how you could do the same. You may want to look at this article, if you don't own an IMSAI 8080 and don't already have an emulator for it.

Gathering Information

Having never programmed an IMSAI 8080 before, I needed to gather some information about it and the Intel 8080 CPU that it uses. I didn't find much out there, but what I did is listed below.

Armed with the above information and the knowledge that the PROGRAMMED INPUT/OUTPUT on the Front Panel is available via port 0xFF, I could now proceed.

Specification of Program

The main consideration in choosing what program to create, is that it has to be small as I want to toggle it in via the front panel switches. I would also like to be able to control it via the PROGRAMMED INPUT switches. After some deliberation, I have decided to write a program to bounce a light back and forth on the PROGRAMMED OUTPUT. The speed of the light's movement will be controlled by the PROGRAMMED INPUT, so that when set to 0x00 it will be fast and then get slower as the PROGRAMMED INPUT is increased to 0xFF. This may not be the most exciting program ever, but with all that switch flipping, I don't want to attempt anything too ambitious.

Designing the Program

The program needs to be well designed before it is entered into the computer due to the difficulty of making changes once it has been entered. I am therefore going to use a form of Top-Down, Stepwise Refinement to ensure that the program is correct before entering.

High Level Pseudo Code

Initialise variables
do {
    Change direction of light if at either end
    Move position of light
    Output position of light to PROGRAMMED_OUTPUT display
    Delay for a period of time controlled by the PROGRAMMED_INPUT
} while(true)

Refined Pseudo Code

// Initialise variables
direction = right   
position = 1

// Block of code that is repeated indefinitely
do {

    // Change direction of light if at either end
    if( position == 128 || position == 1 )
        direction = ~direction
	
    // Move position of light
    if( direction == left )
        rotateLeft position
    else
        rotateRight position


    // Output light to PROGRAMMED_OUTPUT display
    output PROGRAMMED_OUTPUT, position

    // Delay for a period of time controlled by the PROGRAMMED_INPUT
    for( userDelay = (input PROGRAMMED_INPUT)+1; userDelay > 0; userDelay-- ) {
        for( i = 2; i > 0; i-- ) {
            for( j = 255; j > 0; j-- ) {}
        }
    }
	
} while(true)	// Loop indefinitely

I have chosen to store the position of the light as the value of the bit set in that position‚ so that I can then easily output it to the PROGRAMMED OUTPUT.

Testing the Design

Before I implement the design in Machine Code, I want to test that it is correct. This is particularly important due to the difficulty in toggling programs in to the IMSAI. To do this I want to look at several points in the code when they are presented with certain values. I will run through the design in the following table:

Direction	Position	Code	Comment
?	?	direction = right	Start of program
right	?	position = 1
right	1	if( position == 128 \|\| position == 1 )	true
right	1	direction = ~direction
left	1	if( direction == left )	true
left	1	rotateLeft position
left	2	: : :	Output and delay
left	2	if( position == 128 \|\| position == 1 )	false
left	2	if( direction == left )	true
left	1	rotateLeft position
left	4	: : :	Output and delay
left	128	: : :	After a few iterations
left	128	if( position == 128 \|\| position == 1 )	true
left	128	direction = ~direction
right	128	if( direction == left )	false
right	128	rotateRight position
right	64	: : :	Output and delay

I am happy that the design is correct from looking at this table. The first light to be turned on will be light 2, which is fine as the light is moving anyway. It is easy to alter this if you are so inclined. You can also use this method to check that the machine code implementation below is correct.

Implementing the Design in Machine Code

To make the implementation easier I am going to store the Direction and Position variables in registers. I will use the following process to convert the design into machine code:

Write the program out in assembler using labels to record program locations.
Put the hex equivalents to the assembler next to the appropriate lines, leaving unknown addresses marked with ????.
Put the address of each line at the start of it.
Go back and fill in the addresses marked with ????.
Convert the hex into binary next to each line.

This gives me the following code:

      //-----------------------------------
      // Initialise the register variables
      //-----------------------------------
0000  mvi c,FF            // Set direction = right                0EFF   = 0000 1110
                          // 0 is left, 0xFF is right                      1111 1111
0002  mvi d,0             // Set position = 1                     1601   = 0001 0110
                                                                           0000 0001

:loop
      //-----------------------------------------
      // Move the recorded position of the light
      //-----------------------------------------
0004  mov a,d             // Load Position into Accumulator       7A     = 0111 1010
0005  cpi 128                                                     FE80   = 1111 1110
                                                                           1000 0000
0007  jz switchDirection  // Position = 128?                      CA0F00 = 1100 1010
                                                                           0000 1111
                                                                           0000 0000
000A  cpi 1                                                       FE01   = 1111 1110
                                                                           0000 0001
000C  jnz movePosition    // Position != 1?                       C21200 = 1100 0010
                                                                           0001 0010
                                                                           0000 0000

      // Switch the direction of the light
:switchDirection
000F  mov a,c             // Load Direction into Accumulator      79     = 0111 1001
0010  cma                 // Compliment the accumulator           2F     = 0010 1111
0011  mov c,a             // Store result back in the Direction   4F     = 0100 1111

:movePosition
0012  mov a,c             // Load Direction into Accumulator      79     = 0111 1001
0013  cpi 0               // Direction != left?                   FE00   = 1111 1110
                                                                           0000 0000
0015  jnz moveRight                                               C21E00 = 1100 0010
                                                                           0001 1110
                                                                           0000 0000
      // Move position Left
0018  mov a,d             // Load Position into Accumulator       7A     = 0111 1010
0019  ral                 // Rotate left                          17     = 0001 0111
001A  mov d,a             // Store result back in the Position    57     = 0101 0111
001B  jmp outputLight                                             C32100 = 1100 0011
                                                                           0010 0001
                                                                           0000 0000
      // Move position Right
:moveRight
001E  mov a,d             // Load Position into Accumulator      7A      = 0111 1010
001F  rar                 // Rotate right                        1F      = 0001 1111
0020  mov d,a             // Store result back in Position       57      = 0101 0111
		
      //-----------------------------------------------
      // Output the light to PROGRAMMED OUTPUT display
      //-----------------------------------------------
:outputLight
0021  mov a,d             // Load Position into Accumulator      7A      = 0111 1010
0022  cma                 // Compliment Accumulator due          2F      = 0010 1111
                          // to way PROGRAMMED OUTPUT works
0023  out FF              // Output to PROGRAMMED OUTPUT         D3FF    = 1101 0011
                                                                           1111 1111

      //-----------------------
      // User controlled Delay
      //-----------------------
0025  in FF               // User delay from PROGRAMMED INPUT    DBFF    = 1101 1011
                          // port 0xFF                                     1111 1111
0027  inr a               // Make sure 0 is minimum delay        3C      = 0011 1100

:delayOuter
0028  mvi b, 02           // Set register B loop delay to 2      0602    = 0000 0110
                                                                           0000 0010

:delayInner1
002A  mvi e, FF           // Set register E loop delay to 255    1EFF    = 0001 1110
                                                                           1111 1111

:delayInner2
002C  dcr e               // Decrement Register E                1D      = 0001 1101
002D  jnz delayInner2     // Loop until Register E = 0           C22C00  = 1100 0010
                                                                           0010 1100
                                                                           0000 0000

0030  dcr b               // Decrement Register B                05      = 0000 0101
0031  jnz delayInner1     // Loop until Register B = 0           C22A00  = 1100 0010
                                                                           0010 1010
                                                                           0000 0000

0034  dcr a               // Decrement Accumulator               3D      = 0011 1101
0035  jnz delayOuter      // Loop until Register A = 0           C22800  = 1100 0010
                                                                           0010 1000
                                                                           0000 0000
      //-------------------
      // Loop indefinitely
      //-------------------
0038  jmp loop                                                   C30400  = 1100 0011
                                                                           0000 0100
                                                                           0000 0000

Entering the program into the IMSAI 8080

The next bit is a little nerve racking and quite laborious. There are 0x40 bytes of code here, which is 512 bits. 512 ones and zeros that have to be entered exactly. 512 ones and zeros that if not entered correctly mean either re-entering the whole program again‚ or going back through them to check which were entered incorrectly. As well as this; if the program doesn't work‚ is it because the program is wrong‚ or because I entered it in wrong? But now is not the time to worry, I have tested the program on paper, the design is sound, I need to grab the bull by the horns and enter this program.

To enter the program follow these instructions:

Turn the machine on by moving the PWR ON / PWR OFF switch to PWR ON. This switch is located at the far-right of the unit.
The machine is now at address 0. To input the first line of the program move the middle set of switches so that positions 3,2,1 are down. This corresponds to binary: 0000 1110 from Address 0 of the program.
Press the DEPOSIT / DEPOSIT NEXT switch into the DEPOST position. This puts the data from the switches set above into memory at the current address, which is currently 0.
Set the middle group of switches so that it corresponds to the binary in the next group of 8 bits of the program.
Press the DEPOST / DEPOSIT NEXT switch into the DEPOSIT NEXT position. This increments the current address, and there it puts the data from the switches just set.
Repeat lines 4 and 5 until the program has been entered.

The program can now be run by moving the RUN / STOP switch into the RUN position. You should now see the light bouncing back and forth in the PROGRAMMED OUTPUT at the top left of the unit. If you now move any of the PROGRAMMED INPUT switches, you will see that the light's movement changes speed.

Debugging the Program

There are three main methods to help debug a program on the IMSAI:

Step through the program
Do this by moving the RUN / STOP switch into the STOP position. Now press the SINGLE STEP switch for each step you want to see. The current address will be displayed in the bottom middle lights, and it's contents in the top middle lights. To run or step from a certain point, just examine that address first.
Examine the contents of an address in memory
Do this by setting the left and middle group of switches to the address you want to examine, then move the EXAMINE / EXAMINE NEXT switch into the EXAMINE position. You will now see it's contents in the middle top group of lights. To see the contents of the next address just press EXAMINE NEXT.
Change the contents of an address in memory
Do this by first examining the contents of the address using the EXAMINE switch as above. Then set the middle group of switches to the data you want to put there, and press DEPOSIT. To continue entering data just set the middle switches to the next byte you want to enter and press DEPOSIT NEXT.

The program listing I have given works fine. However when I first wrote it, I had line 0x0028 read:

0028  mvi b, FF           // Set register B loop delay to 255    06FF    = 0000 0110
                                                                           1111 1111

This made the program much too slow, and at first I didn't think the program was working at all. Using the above debugging methods it was easy to step through the program and work out what was happening. I just changed the byte at 0x0029 to 02, then examined address 0x0000, and pressed the RUN switch to run the program from 0x0000 (The start). I then felt waves of euphoria as my program worked correctly. I had done it with only one small hitch.

The Program Running on a Real IMSAI 8080

Since writing this article I have been contacted by Mike Loewen, who has a real IMSAI and has kindly allowed me to upload this footage of my program running on his machine. Mike has an interesting site about his Old Technology Collection which features his Restoration of an IMSAI 8080. I must say it was really good to see my program running on a real machine. If only I could lay my hands on one.

Where Now?

Now is the time to get really creative. To do this though, you need to really understand the machine, so the links at the start of the article should help you understand more about the machine and the Intel 8080 chip that powers it. If you remember the importance of designing and testing the program properly before you enter it, you should be fine. Good luck and have fun.

Writing My First Program To Toggle In To The IMSAI 8080
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Using the latest z80pack, version 1.17, to emulate an Altair 8800 or IMSAI 8080 using the new graphical FrontPanel

Wed, 29 Oct 2008 04:13:54 GMT

Udo Munk has just released the latest version of his z80pack emulator, version 1.17, which now includes John Kichury's FrontPanel library. As well as being a superb emulator to run CP/M on, it now gives you a great graphical representation of the Altair 8800 and IMSAI 8080 with fully functional switches and flashing lights. If you've ever wondered what it would be like to use one of these machines, why not give it a try?

Installing z80pack

The following installation instructions are only for the Altair 8800 and IMSAI 8080 systems. For installation instructions of the complete system, why not have a look at my previous article: Setting up z80pack to create an emulated CP/M system.

First download the source (z80pack-x.y.tgz, currently z80pack-1.17.tgz) for z80pack from its ftp site. The following installation instructions are taken from the z80pack site. More information can be found there, in particular, information on installing z80pack on non Linux/Unix systems.
Unpack the source archive in your home directory:
$ tar xzvf z80pack-x.y.tgz
Change the directory it is extracted to, to make this article easier to explain. There is no need for you to do this.
$ mv z80pack-1.17 z80pack
Compile the FrontPanel library:
$ cd ~/z80pack/frontpanel
$ make
Copy the front panel library to /usr/lib
$ cp libfrontpanel.so /usr/lib/
Compile the Altair 8800 emulator:
$ cd ~/z80pack/altairsim/srcsim
$ make
$ make clean
Compile the IMSAI 8080 emulator:
$ cd ~/z80pack/imsaisim/srcsim
$ make
$ make clean
I don't like the 3D version of the IMSAI, so I changed it to 2D:
$ cd ~/z80pack/imsaisim
$ rm conf
$ ln -s conf_2d conf

Getting Altair and IMSAI documentation

The z80pack ftp site has some documentation for the Altair and IMSAI machines which has been scanned in from the originals. For the Altair there is the Altair 8800 Operator's Manual and for the IMSAI there is the IMSAI 8080 User's Manual. There is also some other relevant documentation and files in the altair and imsai ftp directories.

Running a test program on the IMSAI 8080

To start the IMSAI 8080 emulator:
$ cd ~/z80pack/imsaisim
$ imsaisim

The IMSAI 8080 front panel:

The example program we are going to use is taken from the IMSAI 8080 User's Manual mentioned above and can be found from page 19. The program takes input from the PROGRAMMED INPUT switches at the bottom left of the unit and outputs it to the PROGRAMMED OUTPUT at the top left.

Address	Hex	Binary
0	DB	1101 1011	IN - Input into Accumulator
1	FF	1111 1111	Address of Programmed I/O Port to get input from
2	2F	0010 1111	CMA - Complement Data in Accumulator
3	D3	1101 0011	OUT - Output Data from Accumulator
4	FF	1111 1111	Address of Programmed I/O Port to put output to
5	C3	1100 0011	JMP - Jump
6	00	0000 0000	Low Address of beginning of program
7	00	0000 0000	High Address of beginning of program

To enter the program follow these instructions:

Turn the machine on by moving the PWR ON / PWR OFF switch to PWR ON. This switch is located at the far-right of the unit.
The machine is now at address 0. To input the first line of the program move the middle set of switches so that positions 7,6,4,3,1,0 are down. This corresponds to binary: 1101 1011 from Address 0 of the program.
Press the DEPOSIT / DEPOSIT NEXT switch into the DEPOST position. This puts the data from the switches set above into memory at the current address, which is currently 0.
Set the middle group of switches so that it corresponds to the binary in the next line of the program.
Press the DEPOST / DEPOSIT NEXT switch into the DEPOSIT NEXT position. This increments the current address, and there it puts the data from the switches just set.
Repeat lines 4 and 5 until the program has been entered.

The program can now be run by moving the RUN / STOP switch into the RUN position. If you now move any of the PROGRAMMED INPUT switches, you will see them represented in the lights of the PROGRAMMED OUTPUT. Congratulations, you may have just run your first program on the IMSAI 8080.

Where Now?

There is plenty of information in the manuals I have mentioned, and these should be your first port of call. The Altair 8800 Operator's Manual has a similar example to the one given for the IMSAI, and begins on page 33. You may also be interested in my next article: Writing My First Program To Toggle In To The IMSAI 8080. Have fun, and I hope your mouse finger doesn't get sore clicking all those switches!

Using the latest z80pack‚ version 1.17‚ to emulate an Altair 8800 or IMSAI 8080 using the new graphical FrontPanel
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Using DOSBox to Run DOS Games and Applications

Fri, 24 Oct 2008 11:55:53 GMT

There were some brilliant games and applications released for DOS, and some of the games such as Command and Conquer are still very playable. There are a number of options to play these games today, from using a Virtual Machine such as QEMU, to DOSBox which is a dedicated DOS emulator. Both of these are included in most Linux distributions. I have chosen DOSBox as it is quick and very easy to use, you don't need to install a DOS compatible operating system on it, and it uses your native file system for storage.

Configuring DOSBox

If DOSBox isn't included with your Linux distribution then it can be obtained from the download section of their site. Below is a quick example of how to configure DOSBox once you have it installed. More information can be found by looking at the Installation Instructions on the emulator's site.

First create a directory to store you DOS files in:
$ mkdir ~/dos_c

Now run DOSBox from your home directory:
$ dosbox

You should see a screen similar to the following:

From within the DOSBox emulation window create a dosbox.conf file in the current native directory:
Z:\> CONFIG -writeconf dosbox.conf

Leave DOSBox:
Z:> exit

To get DOSBox to automatically mount the ~/dos_c directory as drive C:, add the following lines to dosbox.conf:
mount c ~/dos_c
c:

Installing Software on DOSBox

Now comes the real beauty of DOSBox. All you have to do is put your games or applications in ~/dos_c, start DOSBox, and they will be on the C: drive.

An Example Using Command and Conquer

As an example I have chosen to use Command and Conquer. This is available from the Abandonia website here. It is available free, and the site says that it is Freeware. Please be aware that some of the software on the site is termed Abandonware, which has disputed legality. If you want to be sure, just pick software marked as Freeware or Shareware.

To start, it would be useful to create a subdirectory in ~/dos_c/ called cnc. In it, unzip the file, Command & Conquer.zip, that you obtained from the Abandonia website. Now start DOSBox from your home directory:
$ dosbox

Within the emulation window change to the cnc directory:
C:\> cd\cnc

To run the English version (cnc_de for German version, cnc_fr for French version):
C:\CNC> cnc_en

The splash screen should come up, and then present you with a menu:

If you click on the emulation window with your mouse, then the emulation window will grab your mouse and you can use it to move the mouse in the DOS window. CTRL+F10 will release the mouse. ALT+ENTER will toggle between full screen and normal screen mode.

If you haven't got any sound, try installing the alsa-oss module to have the OSS sound system routed to your ALSA sound system.

Where Now?

Now you can load your old DOS software onto your new machine and remember the good old days. Alternatively you can download DOS software from a number of websites on the internet for free. It is worth checking the legality of some of the software before downloading, but there is still plenty of free legal software to download, as well as some to buy. For more information about DOS, have a look at the Resources section under DOS.

Using DOSBox to Run DOS Games and Applications
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Installing the HI-TECH Z80 C Compiler for CP/M

Wed, 22 Oct 2008 11:24:44 GMT

My language of choice is C and I am currently getting more involved with the CP/M operating system. I have therefore decided that it would be nice to have a C compiler working under CP/M. There are a number of options available in the archives, but I have found that HI-TECH are allowing their CP/M C compiler to be downloaded for free. This is a very good product, has good documentation, is almost ANSI C compliant and can be used for commercial and non-commercial use. This, therefore, is the one I have chosen.

Downloading the HI-TECH Z80 CP/M C Compiler

This can be downloaded from their site, here. You do need to register, but it is a simple process and doesn't take long.

The files are self-extracting lharc'ed archives so I installed lha, which is part of my Debian distro. To extract the contents of the main compiler archive, I created a subdirectory called z80v309. I entered it and ran:
$ lha e ../z80v309.exe

The extracted contents comes to 413k which is too large for the 8" SD disks that my emulator supports, so I used Cpmtools to create a 4Mb HDD image to put the files on. Hopefully however, this should fit on your disks.

Using the C compiler

To test the C compiler I went to the B: drive, where I'm storing my development work, and created a file called hello.c containing the classic "hello, world" source code:

void main(void)
{
   printf("hello, world\n");
}

To compile the source (hello.c on my B: drive) in verbose mode, using the compiler on my I: drive, I run the following:
I> c -v b:hello.c

This leaves the executable hello.com on the I: drive. Now all we need to do is run it to ensure that it has compiled properly:
I> hello

Which gives the correct output as below:

I>hello
hello, world

Where Now?

The next step, if you haven't already done it, is to extract the documentation file, z80doc.exe. This is an extensive document that should really help you get to grips with using the compiler. Now all you have to do is start tinkering and see what you can create.

Installing the HI-TECH Z80 C Compiler for CP/M
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Installing ZDE 1.6, a programmers editor for CP/M

Tue, 21 Oct 2008 10:39:21 GMT

To do any serious programming under CP/M, the first thing you need is a good programmers editor. There aren't many in the archives, but I have tried most of them and found ZDE to be the best. It is small, has lots of features, and uses Wordstar commands which are familiar to me and easy to learn.

Downloading files for ZDE

The ZDE 1.6 editor can be downloaded from Bo Zimmerman's CP/M archive here. This file is in a .PMA archive, so we also need the utility, pmautoae.com, to uncompress it, again from Bo Zimmerman' site. These two files should be copied onto a floppy disk or disk image if using an emulator.

Unpacking ZDE

I am currently using an emulator which only has 8" SD disks which are not big enough to unpack ZDE onto and contain the compressed file. Therefore I will have the files pmautoae.com and zde16.pma on a disk in my C: drive and will uncompress them to a blank disk in my B: drive.

pmautoae.com is a self-expanding archive so to expand it onto my B: drive from the archive on my C: drive, I run:
B> c:pmautoae

Then to extract the contents of the zde16.pma archive held on my C: drive to the B: drive, I run:
B> pmext c:zde16.pma b:

If your disks are big enough, then you can do the above all on one disk, say the B: drive; in which case do the above, but change references to c: to b:

Configuring ZDE

Before the editor can be used, it needs to be configured. The most important thing to configure is the Terminal type, which is done as follows:
B> zdenst16 zde16
Select t to configure the terminal, then l to list the terminals. Press return until your terminal is shown, then press y next to it. I am using z80pack so therefore choose ANSI standard. Now press ESC then s to save the changes. If you are unsure which terminal to select, try each in turn, then start ZDE to see if it works, pressing ESC q to quit.

ZDE should be ready to go at this point. To read the ZDE documentation, type the following:
B> zde16 zde10.doc

Using ZDE

The editor is started with the command zde16 and can be run with a filename as an argument. If a filename is supplied, the editor will try to open it, if it doesn't exist then it will start a new file with the name supplied.

ZDE uses the Wordstar key combinations which are explained in the ZDE documentation. On some machines the main command key CTRL+k is used as a cursor key, in which case ESC can be used instead. The most important commands are listed below:

Command	Purpose
ESC h	Bring up the command key help
CTRL+k q / ESC q	Quit editor without saving
CTRL+k x / ESC x	Exist and Save
CTRL+k l / ESC l	Load a new file
CTRL+k s / ESC s	Save the current file
CTRL+r	Page up
CTRL+c	Page down
CTRL+e / cursor	Line up
CTRL+x / cursor	Line down
CTRL+s / cursor	Cursor left
CTRL+d / cursor	Cursor right

ZDE is a great editor and well worth the time to learn. It has many facilities to make life easier for the programmer and will definitely help make your retro programming more productive.

Installing ZDE 1.6‚ a programmers editor for CP/M
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Setting up z80pack to create an emulated CP/M system

Fri, 17 Oct 2008 06:22:45 GMT

I have decided to try out some old CP/M software, but need something to run it on. I could either do this on my Commodore 128 or through emulation. Unfortunately the 1571 disk drive for my Commodore is currently out of action, so that leaves me with emulation. I was going to use vice to emulate a C128, but have always found it a pain to get CP/M files onto .D64/71 disk images. After looking around for the best emulator to run CP/M on, I came up with either YAZE-AG or z80pack. z80pack seems to be better supported, has more documentation and is being actively developed, so that's the one I have chosen for this article.

Installing z80pack

First download the source (z80pack-x.y.tgz, currently z80pack-1.16.tgz) for z80pack from its ftp site. The following installation instructions are taken from the z80pack site. More information can be found there, in particular, information on installing z80pack on non Linux/Unix systems.
Unpack the source archive in your home directory:
$ tar xzvf z80pack-x.y.tgz
Change the directory it is extracted to, to make this article easier to explain. There is no need for you to do this.
$ mv z80pack-1.16 z80pack
Compile the emulator:
$ cd ~/z80pack/cpmsim/srcsim
$ make
$ make clean
Compile the support programs:
$ cd ~/z80pack/cpmsim/srctools
$ make
$ make clean

This is leaves, on Linux, a few bash scripts in the ~/z80pack/cpmsim/ directory, cpm2, cpm3, mpm, which automatically start the emulator by booting into CP/M 2.2, CP/M 3.0, MP/M, etc.

Creating disk images

We now needed to create some disk images; to do this I recommend Cpmtools which is a part of many Linux distros. If you don't have this as part of your distro, the source can be downloaded from here. Cpmtools is a great collection of tools used to manipulate CP/M images and file systems in a variety of formats and works well with z80pack.

Create a 4Mb Hard Disk Image

It would be useful to create a 4Mb Hard Disk Image, as this may be needed if we want to use any bigger applications such as a C compiler. To create this we can use Cpmtools, but first we need to make sure that it has the correct disk definition by editing /etc/cpmtools/diskdefs and adding the following lines:

# 4mb HDD for z80pack
diskdef hd
  seclen 128
  tracks 255
  sectrk 128
  blocksize 2048
  maxdir 1024
  skew 0
  boottrk 0
  os 3.0
end

CP/M has 16 'user areas' which can be used to organize data on a disk. They are effectively like a crude directory system. User area 0 is the default and the only one we will work with in this article.

To create a blank 4Mb Hard Disk image called main.hd4.cpm, run:
$ mkfs.cpm -fhd main.hd4.cpm

Then to copy all the .COM files from the current directory into the image in user area 0, run:
$ cpmcp -fhd hd4.cpm *.COM 0:

Create a Floppy Diskette Image

To create a floppy diskette image called, work.dsk.cpm, run:
$ mkfs.cpm work.dsk.cpm

Then to copy all the .DOC files from the current directory into the image in user area 0: run:
$ cpmcp work.dsk.cpm *.DOC 0:

Configuring z80pack

We now have a 4mb disk image and a floppy disk image. We can connect them to the emulator by creating a script in the ~/z80pack/cpmsim/ directory called work. First copy main.hd4.cpm and work.dsk.cpm to the ~z80pack/cpmsim/disks/library/ directory. It is also worth copying them to the backups directory as well: ~/z80pack/cpmsim/disks/backups/

Now create a script in ~/z80pack/cpmsim/ called work to start z80pack with our disk image files attached:

#!/bin/sh

rm -f disks/drive[abci].cpm
ln disks/library/cpm3-1.dsk disks/drivea.cpm
ln disks/library/cpm3-2.dsk disks/driveb.cpm
ln disks/library/work.dsk.cpm disks/drivec.cpm
ln disks/library/main.hd4.cpm disks/drivei.cpm
./cpmsim -f4

This attaches the two CP/M disks on drive A and B, our work.dsk.cpm image on drive C, and our main.hd4.cpm image on I:
The line ./cpmsim -f4 tells the emulator to run at 4Mhz, which makes it a bit more realistic.

Starting the emulator

From the ~/z80pack/cpmsim/ directory, run the script we created:
$ ./work

The CP/M operating system will now boot up and leave you at the A> prompt.

To leave the emulator type:
A> a:bye

Where Now?

For more information on CP/M take a look at the Resources section under CP/M.

Setting up z80pack to create an emulated CP/M system
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

PDP 8 in 'Three Days of the Condor'

Tue, 14 Oct 2008 01:08:49 GMT

I watched 'Three Days of the Condor' the other night and loved seeing what I believe is a Dec PDP 8/E being used. Also featured in connection with this machine was a DecWriter, paper tape reader and possibly a VT-52 video terminal.

The film revolves around a CIA researcher, Robert Redford, finding out about a secret section within the CIA, and their attempts to silence him.

While the film itself is great, I was really pleased to spot the PDP 8, and was interested to see it doing OCR scanning. I am told that it was indeed used for OCR scanning sometimes and there were even add on cards to improve the speed of this. The computer isn't in the film for long, but it does show a computer operator unloading a Dectape, although things don't turn out well for her, as you can see from the final picture.

Book Review: Fundamentals of Operating Systems by A.M. Lister - Second Edition

Tue, 07 Oct 2008 17:06:00 GMT

Amazon

It was fascinating to read this book from 1979 and see how operating system design was viewed then, compared to now. The biggest change being the shift in importance from batch processing to the interactive use of computers. Despite the advances since this book was written, it is surprising how many themes are just as relevant.

	Fundamentals of Operating Systems
Author	A.M. Lister
Pages	176
Edition	Second Edition (1979)
Publisher	The Macmillan Press Ltd
ISBN	0 333 27287 0

I loved the comparisons between the different mainframes and minis of the day, such as the PDP-11 and IBM 370 series, and how various functions were implemented in their operating systems. This book gives you a really good insight into the relatively early days of operating systems, so that you can better understand how we got to where we are now.

While covering issues such as Virtual Memory, Memory Management, Concurrent Processing, File Systems and Resource Allocation the author discusses differing approaches which makes for interesting reading as there was no agreed consensus, as to the best strategy, at that time.

This book is still useful if you want to understand the basics of operating systems design, but is of real interest to the computer historian, who will find a wealth of information in an easy to understand format.

Book Review: Fundamentals of Operating Systems by A.M. Lister - Second Edition
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.

Is COBOL really understandable after 14 years?

Fri, 08 Aug 2008 15:36:00 GMT

COBOL has been in the news quite a lot recently and I have been reading that there are still huge amounts of COBOL code running and being written. This led me to wonder why this language was still being used. I therefore decided to look at a few sites about COBOL and see what they said was good about the language. The main benefits appeared to be that it is portable and self-documenting. Indeed, I often read about how COBOL programmers say that they can go to code written 10-15 years ago and still easily understand what is happening.

In 1994, while at college, I did a year of COBOL. I haven't touched it since that time, and have barely even thought about it. I therefore thought that this would be a good test. I admit that the premise above, about the ease of understanding code written a long time ago, refers to people with more COBOL experience than I. However, I was curious to see how much I would understand.

The code I have chosen was originally written to run under MS-DOS, but unfortunately I can't remember which compiler was used. It probably isn't the best COBOL code ever written, but I hope that it will help me to explore how easy it is to return to old code. At times throughout this article I may well refer to things by the wrong name, please bear in mind that the purpose of the article is to test the premise "Is COBOL really understandable after 14 years?", not to teach COBOL.

I have put the full code, associated data file, example output and instructions on how to compile and run the program at the bottom of this article.

Analysis of the code

After taking a quick look at the code I remember that COBOL is split into DIVISIONs, SECTIONs and paragraphs. I will go through each DIVISION in turn and try to explain what is happening. I have purposely not looked up anything while doing this to try and test the premise fully.

The IDENTIFICATION DIVISION

This is fairly unremarkable and is just used to identify what the code is and who wrote it.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. ASSIGN1.
       AUTHOR. xxxxxxxxxx
      * Assignment 1 for COBOL.

The ENVIRONMENT DIVISION

This DIVISION is used to specify the environment in which the code will run. The power of this DIVISION is that you can easily change the environment in which the program is running just by making alterations here.

       ENVIRONMENT DIVISION.
       INPUT-OUTPUT SECTION.
       FILE-CONTROL.
       SELECT TAG2-FILE ASSIGN TO "TAG2.DAT".
       SELECT REP-FILE ASSIGN TO "PRN".

Within the above DIVISION we can see the INPUT-OUTPUT SECTION and within that we can see the FILE-CONTROL paragraph. This is telling the program what names to use to refer to the files and what those files are called. I can see from this that we have a file called TAG2.DAT and another called PRN. Under MS-DOS, PRN referred to the printer. However when this is run under Linux it will just create a file called PRN.

The DATA DIVISION

This DIVISION specifies how data is stored and structured.

       DATA DIVISION.
       FILE SECTION.
       FD TAG2-FILE.
       01 TAG2-RCD.
          03 TAG2-ORD-NBR  PIC 9(4).
          03 TAG2-ACC-NBR  PIC A9(7)A.
          03 TAG2-COLOUR   PIC A(3).
          03 TAG2-PRN      PIC A(2).
          03 TAG2-QTY      PIC 9(2).
          03 TAG2-TAG      PIC A(20).
          03 TAG2-DATE     PIC X(6).

       FD REP-FILE.
       01 REP-RCD.
          03 REP-ACC-NBR   PIC A9(7)A.
          03 FILLER        PIC X(7)       VALUE SPACES.
          03 REP-TAG       PIC A(20).
          03 FILLER        PIC X(9)       VALUE SPACES.
          03 REP-PRN       PIC AA.
          03 FILLER        PIC X(6)       VALUE SPACES.
          03 REP-QTY       PIC Z9.
          03 FILLER        PIC X(6)       VALUE SPACES.

The first SECTION here is the FILE SECTION, which is specifying how the files assigned in the ENVIRONMENT DIVISION to TAG2-FILE and REP-FILE are structured.

If we take TAG2-FILE we can see that it's biggest structure is TAG2-RCD which is representing a record. This record is split into 7 fields. The PIC statements after the names of the field specify the format of the field. For TAG2-ORD-NBR this is 9(4) representing 4 numeric characters. For TAG2-ACC-NBR this is A9(7)A representing an alphabetical character then 7 numeric characters then an alphabetical character. Finally TAG2-DAT has X(6) representing 6 characters of any type.

        WORKING-STORAGE SECTION.
           01 WS1-AREA.
              03 WS1-LCNT  PIC 99 VALUE 70.

              03 WS1-DATE.
                 05 WS1-YR   PIC XX.
                 05 WS1-MT   PIC XX.
                 05 WS1-DY   PIC XX.

              03 WS1-HDR-AREA.
                 05 WS1-DAY       PIC XX.
                 05 FILLER        PIC X VALUE '/'.
                 05 WS1-MTH       PIC XX.
                 05 FILLER        PIC X VALUE '/'.
                 05 WS1-YER       PIC XX.
                 05 FILLER        PIC X(10) VALUE SPACES.
                 05 FILLER        PIC X(19) VALUE 'NAME TAG REPORT - 2'.
                 05 FILLER        PIC X(15) VALUE SPACES.
                 05 FILLER        PIC X(4)  VALUE 'PAGE'.
                 05 FILLER        PIC X(1)  VALUE SPACES.
                 05 WS1-PAGE-NBR  PIC Z9.

             03 WS1-PAGE-EDIT    PIC 99 VALUE 0.

             03 WS1-SUB-HDR.
                05 FILLER        PIC X(19) VALUE SPACES.
                05 FILLER        PIC X(9)  VALUE 'COLOUR - '.
                05 SUB-COLOUR    PIC X(5)  VALUE SPACES.

             03 WS1-SUB-HDR2.
                05 FILLER        PIC X(9)  VALUE 'Acct.Nbr.'.
                05 FILLER        PIC X(7)  VALUE SPACES.
                05 FILLER        PIC X(11) VALUE 'Name on Tag'.
                05 FILLER        PIC X(18) VALUE SPACES.
                05 FILLER        PIC X(4)  VALUE 'Type'.
                05 FILLER        PIC X(4)  VALUE SPACES.
                05 FILLER        PIC X(4)  VALUE 'Qty.'.

             03 WS1-COLOR-CHECK PIC A(3)   VALUE SPACES.

             03 WS1-RESULT1.
                05 FILLER        PIC X(5)  VALUE SPACES.
                05 FILLER        PIC X(23) VALUE
                                      'RED.........QUANTITY - '.
                05 WS1-RED-TOTAL PIC ZZZ9.
                05 FILLER        PIC X(7)  VALUE SPACES.
                05 FILLER        PIC X(4)  VALUE 'COST'.
                05 FILLER        PIC X     VALUE SPACE.
                05 WS1-RED-COST  PIC $$$$9.99.

             03 WS1-RESULT2.
                05 FILLER        PIC X(5)  VALUE SPACES.
                05 FILLER        PIC X(23) VALUE
                                      'BLUE........QUANTITY - '.
                05 WS1-BLU-TOTAL PIC ZZZ9.
                05 FILLER        PIC X(7)  VALUE SPACES.
                05 FILLER        PIC X(4)  VALUE 'COST'.
                05 FILLER        PIC X     VALUE SPACE.
                05 WS1-BLU-COST  PIC $$$$9.99.

             03 WS1-RESULT3.
                05 FILLER        PIC X(5)  VALUE SPACES.
                05 FILLER        PIC X(23) VALUE
                                      'BLACK.......QUANTITY - '.
                05 WS1-BLA-TOTAL PIC ZZZ9.
                05 FILLER        PIC X(7)  VALUE SPACES.
                05 FILLER        PIC X(4)  VALUE 'COST'.
                05 FILLER        PIC X     VALUE SPACE.
                05 WS1-BLA-COST  PIC $$$$9.99.

             03 RESULT-CALC.
                05 WS1-BLU-ADD   PIC 9999 VALUE 0.
                05 WS1-RED-ADD   PIC 9999 VALUE 0.
                05 WS1-BLA-ADD   PIC 9999 VALUE 0.
                05 WS1-BLU-TOT   PIC 9(5)V99 VALUE 0.
                05 WS1-RED-TOT   PIC 9(5)V99 VALUE 0.
                05 WS1-BLA-TOT   PIC 9(5)V99 VALUE 0.

             03 WS1-CONTROL-HDR.
                05 FILLER        PIC X(19) VALUE SPACES.
                05 FILLER        PIC X(9)  VALUE 'CONTROLS'.
                05 FILLER        PIC X(4)  VALUE SPACES.

The next section is the WORKING-STORAGE SECTION. This is where the variables are specified. The variables are set out in the same way as the files. If we look at RESULT-CALC we can see that it is made up of 6 fields each with an initial value of 0. The V used in the last 3 PIC statements represents a decimal point.

The variables can be referred to by any of the names specified above and will include each of the subdivisions of that name. So you can refer to RESULT-CALC and it will also automatically be referring to each of its fields as well, or you can just refer to the fields directly e.g. WS1-BLU-ADD. There is no need to refer to the fields by way of the record. Which does mean that you have to be careful about not reusing names.

The PROCEDURE DIVISION

This is the DIVISION where all the processing gets done. It can be split into SECTIONs so that you can have subroutines. However, this piece of code doesn't have any SECTIONs within the PROCEDURE DIVISION.

       PROCEDURE DIVISION.
           OPEN INPUT TAG2-FILE.
           OPEN OUTPUT REP-FILE.

      * Get the Date
           ACCEPT WS1-DATE FROM DATE.
           MOVE WS1-YR TO WS1-YER.
           MOVE WS1-MT TO WS1-MTH.
           MOVE WS1-DY TO WS1-DAY.

This is opening the files mentioned earlier for INPUT and OUTPUT. Then today's date is put into WS1-DATE. After that, the fields in WS1-DATE are specified directly, e.g. WS1-YR. These fields are moved into fields from WS1-HDR-AREA, e.g. WS1-YER. Note the Y2K problem here as it is only using a 6 byte date.

       A01-OP-LINE.
           READ TAG2-FILE AT END GO TO A90-END.

A01-OP-LINE is a paragraph label that is used to form a loop. The next line reads a record from TAG2-FILE and if the end of file is reached it jumps to the paragraph A90-END.

      * Put Correct Colour Name in Sub Heading
           IF TAG2-COLOUR = 'BLU'
           THEN MOVE SPACES TO SUB-COLOUR
                MOVE 'BLUE' TO SUB-COLOUR
           ELSE IF TAG2-COLOUR = 'RED'
                THEN MOVE SPACES TO SUB-COLOUR
                     MOVE 'RED' TO SUB-COLOUR
                ELSE MOVE SPACES TO SUB-COLOUR
                     MOVE 'BLACK' TO SUB-COLOUR.

This puts the colour of the tag record read in from the TAG2-FILE into SUB-COLOUR which is a field of WS1-SUB-HDR.

      * If the number of lines printed > 57 then put up the page heading
           IF WS1-LCNT > 57
           THEN ADD 1 TO WS1-PAGE-EDIT
                MOVE "  " TO WS1-PAGE-NBR
                MOVE WS1-PAGE-EDIT TO WS1-PAGE-NBR
                WRITE REP-RCD FROM WS1-HDR-AREA AFTER ADVANCING PAGE
                MOVE ZERO TO WS1-LCNT
      * Output Colour Sub Heading
                MOVE SPACES TO WS1-COLOR-CHECK
                MOVE TAG2-COLOUR TO WS1-COLOR-CHECK
                WRITE REP-RCD FROM WS1-SUB-HDR AFTER ADVANCING 3 LINES
                WRITE REP-RCD FROM WS1-SUB-HDR2 AFTER ADVANCING 1 LINE
                ADD 4 TO WS1-LCNT
                MOVE SPACES TO REP-RCD.

This prints a header for the page if more than 57 lines have been printed and also prints a heading for the current colour table. WS1-LCNT is initialised with the value of 70 in the WORKING-STORAGE SECTION, so a header is printed on the first page. The code if fairly self explanatory. The MOVE statements copy the literal or variable being referred to into the variable specified. SPACES represent a full field of space characters. ZERO is the numerical literal 0. WRITE REP-RCD... writes the record specified by FROM to the file REP-FILE which is associated with REP-RCD. The THEN statement will execute everything up to the period, this is called a sentence.

           IF WS1-COLOR-CHECK = TAG2-COLOUR
           THEN NEXT SENTENCE
           ELSE MOVE SPACES TO WS1-COLOR-CHECK
                MOVE TAG2-COLOUR TO WS1-COLOR-CHECK
                WRITE REP-RCD FROM WS1-SUB-HDR AFTER ADVANCING 3 LINES
                WRITE REP-RCD FROM WS1-SUB-HDR2 AFTER ADVANCING 1 LINE
                ADD 4 TO WS1-LCNT
                MOVE SPACES TO REP-RCD.

This checks if the record just read from TAG2-FILE is a different colour from the current table colour. If the colour is the same then it skips to the NEXT SENTENCE, i.e. after the period. Otherwise it prints a heading for the table. The AFTER ADVANCING 3 LINES outputs 3 newlines to the file before writing the record.

           MOVE TAG2-ACC-NBR TO REP-ACC-NBR.
           MOVE TAG2-TAG TO REP-TAG.
           MOVE TAG2-PRN TO REP-PRN.
           MOVE TAG2-QTY TO REP-QTY.
           WRITE REP-RCD AFTER ADVANCING 1 LINE.

This copies some of the fields of the record TAG2-RCD read in from TAG2-FILE to some of the fields of the record REP-RCD. The REP-RCD record is then written to the associated REP-FILE. If you look at REP-RCD in the FILE SECTION you will see that each field is seperated by FILLER spaces. This is so that a neat table can be built for output.

      * Add up Tag Quantity for each Colour
           IF TAG2-COLOUR = 'BLU'
           THEN ADD TAG2-QTY TO WS1-BLU-ADD
           ELSE IF TAG2-COLOUR = 'RED'
                THEN ADD TAG2-QTY TO WS1-RED-ADD
                ELSE ADD TAG2-QTY TO WS1-BLA-ADD.

This determines which colour the current record is from TAG2-COLOUR, then adds the quantity of the current record to the relevant variable. E.g. for the case of TAG2-COLOUR = 'BLU' the quantity TAG2-QTY is added to the variable WS1-BLU-ADD.

      * Add up Tag Cost for each Colour
           IF TAG2-COLOUR = 'BLU' AND TAG2-QTY = 24
           THEN ADD 2.25 TO WS1-BLU-TOT
           ELSE IF TAG2-COLOUR = 'BLU' AND TAG2-QTY = 36
                THEN ADD 3.00 TO WS1-BLU-TOT.

           IF TAG2-COLOUR = 'RED' AND TAG2-QTY = 24
           THEN ADD 2.25 TO WS1-RED-TOT
           ELSE IF TAG2-COLOUR = 'RED' AND TAG2-QTY = 36
                THEN ADD 3.00 TO WS1-RED-TOT.

           IF TAG2-COLOUR = 'BLA' AND TAG2-QTY = 24
           THEN ADD 2.25 TO WS1-BLA-TOT
           ELSE IF TAG2-COLOUR = 'BLA' AND TAG2-QTY = 36
                THEN ADD 3.00 TO WS1-BLA-TOT.

This determines the cost to add to each colour's total. There are a choice of two quantities than can be ordered. Either 24 or 36. It can be seen that here the code should be re-written to have the costs for each quantity stored as a variable for each colour.

           ADD 1 TO WS1-LCNT.
           GO TO A01-OP-LINE.
       A90-END.

This adds 1 to the line count (WS1-LCNT). Then jumps back to paragraph label A01-OP-LINE. A90-END is a paragraph label which is used near the start of the code to jump to when the end of the file TAG2-FILE is reached.

      * Print Control Report
           MOVE WS1-BLU-ADD TO WS1-BLU-TOTAL.
           MOVE WS1-RED-ADD TO WS1-RED-TOTAL.
           MOVE WS1-BLA-ADD TO WS1-BLA-TOTAL.
           MOVE WS1-BLU-TOT TO WS1-BLU-COST.
           MOVE WS1-RED-TOT TO WS1-RED-COST.
           MOVE WS1-BLA-TOT TO WS1-BLA-COST.
           WRITE REP-RCD FROM WS1-CONTROL-HDR AFTER ADVANCING 4 LINES.
           WRITE REP-RCD FROM WS1-RESULT1 AFTER ADVANCING 1 LINE.
           WRITE REP-RCD FROM WS1-RESULT2 AFTER ADVANCING 1 LINE.
           WRITE REP-RCD FROM WS1-RESULT3 AFTER ADVANCING 1 LINE.
           CLOSE TAG2-FILE REP-FILE.
           STOP RUN.

The code finishes by copying the running cost and quantity totals to the fields in the records WS1-RESULT1, WS1-RESULT2, WS1-RESULT3. Then writing a header to REP-FILE using WS-CONTROL-HDR, and writing the quantity and cost for each colour. The files are then closed and the program is stopped.

Summary of the program

The program reads in name tag records from TAG2.DAT and outputs a report to PRN.

Conclusion

Once I had remembered how COBOL is set out, I found this program easy to understand and believe that it would be easy to maintain and expand. I admit that this is only a trivial example, but then I haven't used COBOL for a long time, so I think it is a fair investigation. I can see from the code why COBOL is so good at processing transactions and in particular batch processing. A similar program written in Java, the new standard in the business world, would be considerably more complex and difficult to understand. That said, I do recognise that while most of the added complexity would be with the code to read in the structured input file, the output report writing would be considerably easier by just using formatted strings.

Afterwards

After writing this article I decided to look at COBOL in more depth. My main conclusion is that COBOL has advanced quite considerably since this code was written. In fact I think that the style of COBOL we were taught in 1994 was already quite dated. I have enjoyed this trip down memory lane, but now want to see if COBOL can offer anything for the present and into the future. The most recent advance in COBOL appear to be an object orientated standard, which offers some considerable improvements while maintaining backwards compatibility. Unfortunately the uptake on this seems to be slow. COBOL does have a bad press, and after looking at modern COBOL, most of the complaints refer to problems that have been fixed over 30 years ago. If COBOL is to halt its decline it needs more vocal advocates to show why it is so good and to help explain the COBOL mindset. One further problem COBOL has long had is the lack of free compilers. There are a couple of projects out there but they need support. The most advanced project for Linux appears to be OpenCOBOL. Another project which, though incomplete, should offer a great compiler in the long term is Cobol for GCC. I wish these projects well, and hope that COBOL can regain the respect it deserves.

The full code (ASSIGN1.CBL)

       IDENTIFICATION DIVISION.
       PROGRAM-ID. ASSIGN1.
       AUTHOR. Lawrence Woodman
      * Assignment 1 for COBOL.

       ENVIRONMENT DIVISION.
       INPUT-OUTPUT SECTION.
       FILE-CONTROL.
       SELECT TAG2-FILE ASSIGN TO "TAG2.DAT".
       SELECT REP-FILE ASSIGN TO "PRN".

       DATA DIVISION.
       FILE SECTION.
       FD TAG2-FILE.
       01 TAG2-RCD.
          03 TAG2-ORD-NBR  PIC 9(4).
          03 TAG2-ACC-NBR  PIC A9(7)A.
          03 TAG2-COLOUR   PIC A(3).
          03 TAG2-PRN      PIC A(2).
          03 TAG2-QTY      PIC 9(2).
          03 TAG2-TAG      PIC A(20).
          03 TAG2-DATE     PIC X(6).

       FD REP-FILE.
       01 REP-RCD.
          03 REP-ACC-NBR   PIC A9(7)A.
          03 FILLER        PIC X(7)       VALUE SPACES.
          03 REP-TAG       PIC A(20).
          03 FILLER        PIC X(9)       VALUE SPACES.
          03 REP-PRN       PIC AA.
          03 FILLER        PIC X(6)       VALUE SPACES.
          03 REP-QTY       PIC Z9.
          03 FILLER        PIC X(6)       VALUE SPACES.

        WORKING-STORAGE SECTION.
           01 WS1-AREA.
              03 WS1-LCNT  PIC 99 VALUE 70.

              03 WS1-DATE.
                 05 WS1-YR   PIC XX.
                 05 WS1-MT   PIC XX.
                 05 WS1-DY   PIC XX.

              03 WS1-HDR-AREA.
                 05 WS1-DAY       PIC XX.
                 05 FILLER        PIC X VALUE '/'.
                 05 WS1-MTH       PIC XX.
                 05 FILLER        PIC X VALUE '/'.
                 05 WS1-YER       PIC XX.
                 05 FILLER        PIC X(10) VALUE SPACES.
                 05 FILLER        PIC X(19) VALUE 'NAME TAG REPORT - 2'.
                 05 FILLER        PIC X(15) VALUE SPACES.
                 05 FILLER        PIC X(4)  VALUE 'PAGE'.
                 05 FILLER        PIC X(1)  VALUE SPACES.
                 05 WS1-PAGE-NBR  PIC Z9.

             03 WS1-PAGE-EDIT    PIC 99 VALUE 0.

             03 WS1-SUB-HDR.
                05 FILLER        PIC X(19) VALUE SPACES.
                05 FILLER        PIC X(9)  VALUE 'COLOUR - '.
                05 SUB-COLOUR    PIC X(5)  VALUE SPACES.

             03 WS1-SUB-HDR2.
                05 FILLER        PIC X(9)  VALUE 'Acct.Nbr.'.
                05 FILLER        PIC X(7)  VALUE SPACES.
                05 FILLER        PIC X(11) VALUE 'Name on Tag'.
                05 FILLER        PIC X(18) VALUE SPACES.
                05 FILLER        PIC X(4)  VALUE 'Type'.
                05 FILLER        PIC X(4)  VALUE SPACES.
                05 FILLER        PIC X(4)  VALUE 'Qty.'.

             03 WS1-COLOR-CHECK PIC A(3)   VALUE SPACES.

             03 WS1-RESULT1.
                05 FILLER        PIC X(5)  VALUE SPACES.
                05 FILLER        PIC X(23) VALUE
                                      'RED.........QUANTITY - '.
                05 WS1-RED-TOTAL PIC ZZZ9.
                05 FILLER        PIC X(7)  VALUE SPACES.
                05 FILLER        PIC X(4)  VALUE 'COST'.
                05 FILLER        PIC X     VALUE SPACE.
                05 WS1-RED-COST  PIC $$$$9.99.

             03 WS1-RESULT2.
                05 FILLER        PIC X(5)  VALUE SPACES.
                05 FILLER        PIC X(23) VALUE
                                      'BLUE........QUANTITY - '.
                05 WS1-BLU-TOTAL PIC ZZZ9.
                05 FILLER        PIC X(7)  VALUE SPACES.
                05 FILLER        PIC X(4)  VALUE 'COST'.
                05 FILLER        PIC X     VALUE SPACE.
                05 WS1-BLU-COST  PIC $$$$9.99.

             03 WS1-RESULT3.
                05 FILLER        PIC X(5)  VALUE SPACES.
                05 FILLER        PIC X(23) VALUE
                                      'BLACK.......QUANTITY - '.
                05 WS1-BLA-TOTAL PIC ZZZ9.
                05 FILLER        PIC X(7)  VALUE SPACES.
                05 FILLER        PIC X(4)  VALUE 'COST'.
                05 FILLER        PIC X     VALUE SPACE.
                05 WS1-BLA-COST  PIC $$$$9.99.

             03 RESULT-CALC.
                05 WS1-BLU-ADD   PIC 9999 VALUE 0.
                05 WS1-RED-ADD   PIC 9999 VALUE 0.
                05 WS1-BLA-ADD   PIC 9999 VALUE 0.
                05 WS1-BLU-TOT   PIC 9(5)V99 VALUE 0.
                05 WS1-RED-TOT   PIC 9(5)V99 VALUE 0.
                05 WS1-BLA-TOT   PIC 9(5)V99 VALUE 0.

             03 WS1-CONTROL-HDR.
                05 FILLER        PIC X(19) VALUE SPACES.
                05 FILLER        PIC X(9)  VALUE 'CONTROLS'.
                05 FILLER        PIC X(4)  VALUE SPACES.

       PROCEDURE DIVISION.
           OPEN INPUT TAG2-FILE.
           OPEN OUTPUT REP-FILE.

      * Get the Date
           ACCEPT WS1-DATE FROM DATE.
           MOVE WS1-YR TO WS1-YER.
           MOVE WS1-MT TO WS1-MTH.
           MOVE WS1-DY TO WS1-DAY.

       A01-OP-LINE.
           READ TAG2-FILE AT END GO TO A90-END.

      * Put Correct Colour Name in Sub Heading
           IF TAG2-COLOUR = 'BLU'
           THEN MOVE SPACES TO SUB-COLOUR
                MOVE 'BLUE' TO SUB-COLOUR
           ELSE IF TAG2-COLOUR = 'RED'
                THEN MOVE SPACES TO SUB-COLOUR
                     MOVE 'RED' TO SUB-COLOUR
                ELSE MOVE SPACES TO SUB-COLOUR
                     MOVE 'BLACK' TO SUB-COLOUR.

      * If the number of lines printed > 57 then put up the page heading
           IF WS1-LCNT > 57
           THEN ADD 1 TO WS1-PAGE-EDIT
                MOVE "  " TO WS1-PAGE-NBR
                MOVE WS1-PAGE-EDIT TO WS1-PAGE-NBR
                WRITE REP-RCD FROM WS1-HDR-AREA AFTER ADVANCING PAGE
                MOVE ZERO TO WS1-LCNT
      * Output Colour Sub Heading
                MOVE SPACES TO WS1-COLOR-CHECK
                MOVE TAG2-COLOUR TO WS1-COLOR-CHECK
                WRITE REP-RCD FROM WS1-SUB-HDR AFTER ADVANCING 3 LINES
                WRITE REP-RCD FROM WS1-SUB-HDR2 AFTER ADVANCING 1 LINE
                ADD 4 TO WS1-LCNT
                MOVE SPACES TO REP-RCD.

           IF WS1-COLOR-CHECK = TAG2-COLOUR
           THEN NEXT SENTENCE
           ELSE MOVE SPACES TO WS1-COLOR-CHECK
                MOVE TAG2-COLOUR TO WS1-COLOR-CHECK
                WRITE REP-RCD FROM WS1-SUB-HDR AFTER ADVANCING 3 LINES
                WRITE REP-RCD FROM WS1-SUB-HDR2 AFTER ADVANCING 1 LINE
                ADD 4 TO WS1-LCNT
                MOVE SPACES TO REP-RCD.

           MOVE TAG2-ACC-NBR TO REP-ACC-NBR.
           MOVE TAG2-TAG TO REP-TAG.
           MOVE TAG2-PRN TO REP-PRN.
           MOVE TAG2-QTY TO REP-QTY.
           WRITE REP-RCD AFTER ADVANCING 1 LINE.

      * Add up Tag Quantity for each Colour
           IF TAG2-COLOUR = 'BLU'
           THEN ADD TAG2-QTY TO WS1-BLU-ADD
           ELSE IF TAG2-COLOUR = 'RED'
                THEN ADD TAG2-QTY TO WS1-RED-ADD
                ELSE ADD TAG2-QTY TO WS1-BLA-ADD.

      * Add up Tag Cost for each Colour
           IF TAG2-COLOUR = 'BLU' AND TAG2-QTY = 24
           THEN ADD 2.25 TO WS1-BLU-TOT
           ELSE IF TAG2-COLOUR = 'BLU' AND TAG2-QTY = 36
                THEN ADD 3.00 TO WS1-BLU-TOT.

           IF TAG2-COLOUR = 'RED' AND TAG2-QTY = 24
           THEN ADD 2.25 TO WS1-RED-TOT
           ELSE IF TAG2-COLOUR = 'RED' AND TAG2-QTY = 36
                THEN ADD 3.00 TO WS1-RED-TOT.

           IF TAG2-COLOUR = 'BLA' AND TAG2-QTY = 24
           THEN ADD 2.25 TO WS1-BLA-TOT
           ELSE IF TAG2-COLOUR = 'BLA' AND TAG2-QTY = 36
                THEN ADD 3.00 TO WS1-BLA-TOT.

           ADD 1 TO WS1-LCNT.
           GO TO A01-OP-LINE.
       A90-END.
      * Print Control Report
           MOVE WS1-BLU-ADD TO WS1-BLU-TOTAL.
           MOVE WS1-RED-ADD TO WS1-RED-TOTAL.
           MOVE WS1-BLA-ADD TO WS1-BLA-TOTAL.
           MOVE WS1-BLU-TOT TO WS1-BLU-COST.
           MOVE WS1-RED-TOT TO WS1-RED-COST.
           MOVE WS1-BLA-TOT TO WS1-BLA-COST.
           WRITE REP-RCD FROM WS1-CONTROL-HDR AFTER ADVANCING 4 LINES.
           WRITE REP-RCD FROM WS1-RESULT1 AFTER ADVANCING 1 LINE.
           WRITE REP-RCD FROM WS1-RESULT2 AFTER ADVANCING 1 LINE.
           WRITE REP-RCD FROM WS1-RESULT3 AFTER ADVANCING 1 LINE.
           CLOSE TAG2-FILE REP-FILE.
           STOP RUN.

Uuencode data file (TAG2.DAT)

begin-base64 644 TAG2.DAT
MDAwMWEwMDAwMDAxYVJFRFNDMjRKaiAgICAgICAgICAgICAgICAgIDk0MTEy
MjAwMDJhMDAwMDAwMmFSRURTQzM2RC5Ccm93biAgICAgICAgICAgICA5NDEx
MjIwMDAzYTAwMDAwMDNhUkVEU1QyNFQuSm9uZXMgICAgICAgICAgICAgOTQx
MTIyMDAwNGEwMDAwMDA0YVJFRFNUMzZSLlRhbGJvdCAgICAgICAgICAgIDk0
MTEyMjAwMDVhMDAwMDAwNWFCTFVTQzI0Ui5KICAgICAgICAgICAgICAgICA5
NDExMjIwMDA2YTAwMDAwMDZhQkxVU0MzNkguTCAgICAgICAgICAgICAgICAg
OTQxMTIyMDAwN2EwMDAwMDA3YUJMVVNUMjRSLlAgICAgICAgICAgICAgICAg
IDk0MTEyMjAwMDhhMDAwMDAwOGFCTFVTVDM2Si5LICAgICAgICAgICAgICAg
ICA5NDExMjIwMDA5YTAwMDAwMDlhQkxBU0MyNFIuUCAgICAgICAgICAgICAg
ICAgOTQxMTIyMDAxMGEwMDAwMDEwYUJMQVNDMzZQLlAgICAgICAgICAgICAg
ICAgIDk0MTEyMjAwMTFhMDAwMDAxMWFCTEFTVDI0US5RICAgICAgICAgICAg
ICAgICA5NDExMjIwMDEyYTAwMDAwMTJhQkxBU1QzNk8uTyAgICAgICAgICAg
ICAgICAgOTQxMTIyCg==
====

Compiling and running the program

To compile this code I am using OpenCOBOL under Linux. I compile it to en executable using: cobc -x ASSIGN1.CBL
To create the TAG2.DAT file that is needed copy the uuencoded data above to a file, say tag2.uue. Then run: uudecode tag2.uue
To execute the program, make sure that TAG2.DAT is in the same directory as the executable ASSIGN1. Then run ./ASSIGN1

After running the program you should find a file called PRN has been created which contains the report.

Example report (PRN)

26/08/08          NAME TAG REPORT - 2               PAGE  1  


                   COLOUR - RED                              
Acct.Nbr.       Name on Tag                  Type    Qty.    
a0000001a       Jj                           SC      24      
a0000002a       D.Brown                      SC      36      
a0000003a       T.Jones                      ST      24      
a0000004a       R.Talbot                     ST      36      


                   COLOUR - BLUE                             
Acct.Nbr.       Name on Tag                  Type    Qty.    
a0000005a       R.J                          SC      24      
a0000006a       H.L                          SC      36      
a0000007a       R.P                          ST      24      
a0000008a       J.K                          ST      36      


                   COLOUR - BLACK                            
Acct.Nbr.       Name on Tag                  Type    Qty.    
a0000009a       R.P                          SC      24      
a0000010a       P.P                          SC      36      
a0000011a       Q.Q                          ST      24      
a0000012a       O.O                          ST      36      



                   CONTROLS                                  
     RED.........QUANTITY -  120       COST   $10.50         
     BLUE........QUANTITY -  120       COST   $10.50         
     BLACK.......QUANTITY -  120       COST   $10.50

Is COBOL really understandable after 14 years?
by TechTinkering is licensed under a Creative Commons Attribution 2.0 UK: England & Wales License.