BIT

Introduction

BIT is a programming language in which the programmer has full access to all data in its essential machine representation. This is a powerful programming tool, allowing manipulations of data that are convoluted in "higher-level" languages with various specialised functions that operate on more complicated and abstract data types.

Revised version 2017-09-16: The original specification has been revised to include clarifications for previously unspecified behaviour. Nothing fundamental has been changed, however previously there were some ambiguities, which some implementers may have chosen to implement in ways which now contradict this revision. All clarifications under this revision are clearly marked below.

Design Principles

• Extend the ease of string processing in C to other, more basic, data types such as integers.
• Extend the terseness of COBOL to more fundamental code constructs, such as numeric literals.

Language Concepts

Data

Data values are stored in memory as contiguous arrays of bits. This is actually true of all programming languages, but most hide this fundamental representation and make it difficult to operate on the data!

Data Types

BIT is a strongly typed language. There are two data types:

• bit - A bit variable can hold one bit of data.
• address-of-a-bit - An address-of-a-bit variable holds the memory address of one bit of data.

Jump Register

One bit of memory is reserved as a jump register. It can be written to, and controls program flow via the GOTO ... IF THE JUMP REGISTER IS statement. It is a bit variable and cannot store an address-of-a-bit. The value stored in the jump register can be referenced in arithmetical expressions using the name THE JUMP REGISTER.

Utility Functions

These just make a language harder to understand, so BIT has none.

Free Structure

Rather than requiring a rigid syntactical structure, BIT supports any amount of whitespace, including line breaks, between syntax elements or inside syntax elements [2017-09-16 clarification]. This includes no whitespace at all, if it is important to write source code with the smallest possible file size.

[2017-09-16 clarification:] For example: ONE ZERO and ONEZERO and ON EZE RO are all treated the same.

[2017-09-16 clarification:] BIT is case sensitive, and all code must be in UPPER CASE for ease of legibility. Use of lower case characters is a syntax error.

Syntax Elements

Bit Constants

To make the language easily writable and readable by humans, the abstract binary digit representations "0" and "1" are not supported. Instead there are two easily-legible constant values defined as follows:

• ZERO - this represents a binary digit with a value of zero.
• ONE - this represents a binary digit with a value of one.

Line Numbers

Program flow is controlled by line numbers. Lines are numbered in binary, using the bit constants, prefixed by the keyword LINE NUMBER. Each line number must be unique. To indicate the end of a line number and the beginning of the code for that line, use the keyword CODE.

[2017-09-16 clarification:] Lines of BIT source code do not need to be listed in order of line number. They may be listed in any order.

Flow Control

Program flow is controlled by GOTO statements. If a line contains no GOTO statement that applies to indicate what statement to execute next, program execution terminates. There are two types of GOTO:

• GOTO line-number - causes the next line of code to be executed to be the line with the given number.
• GOTO line-number IF THE JUMP REGISTER IS bit-constant - causes the next line of code to be executed to be the line number after the GOTO if the jump register is equal to the given bit constant. The bit constant must be ONE or ZERO, it cannot be a variable expression.

The first type may not be combined with another GOTO on the same line. The second type may appear twice on one line of code, once with the bit constant ZERO and once with the bit constant ONE.

Variables

Variables are identified with names, which must be sequences of bit constants (of course). Variable names begin with the VARIABLE keyword and are followed by an identifying sequence of bit constants:

• VARIABLE bit-constants

Variables may hold either a bit value, or an address-of-a-bit value. The jump register is effectively a special variable with the predefined name THE JUMP REGISTER; it may hold a bit value.

[2017-09-16 clarification:] Variables cannot be defined within assigning them a value, using the assignment command EQUALS (see below).

Operators

The following operators are available. These are, in order of precedence:

• THE VALUE AT - unary operator returning the bit value at the address-of-a-bit held by the variable on the right. This only makes sense for address-of-a-bit variables; attempting to take THE VALUE AT a bit variable is an error.
• THE VALUE BEYOND - unary operator returning the bit value in the next memory address beyond the address-of-a-bit held by the variable on the right. This only makes sense for address-of-a-bit variables; attempting to take THE VALUE BEYOND a bit variable is an error.
• THE ADDRESS OF - unary operator returning the address-of-a-bit of the bit variable on the right. This only makes sense for bit variables; attempting to take THE ADDRESS OF an address-of-a-bit variable is an error. Attempting to take THE ADDRESS OF THE JUMP REGISTER is also an error.
• NAND - binary operator returning ZERO if both bit operands are ONE, returning ONE if either is ZERO. If either operand is an address-of-a-bit, this is an error.

[2017-09-16 clarification:] Previously EQUALS was defined as an operator. It is now defined as a command (see below).

There are also grouping operators to allow changing the default precedence of the operators:

• OPEN PARENTHESIS
• CLOSE PARENTHESIS

These work like the standard arithmetic grouping operators "(" and ")", respectively.

Commands

[2017-09-16 clarification:] Commands are the instructions which tell BIT to perform some operation. Each line of code must contain exactly one command. There are three commands:

• EQUALS - the assignment command. Sets the variable on the left to the value of the expression on the right. The variable on the left may be THE JUMP REGISTER. Bit values may only be assigned to bit variables, and address-of-a-bit values may only be assigned to address-of-a-bit variables; anything else is an error.
• PRINT bit-constant - this prints the bit constant to standard output. This command can only print one bit; to print several bits you need to use several PRINT statements in a row (noting that only one PRINT statement can appear per line of code). Attempting to print a variable (of either type) is an error.
  BIT can only print bit values. Many other languages abstract this binary data into decimal numbers and strings, thus hiding the underlying data. To avoid any possibility of confusion by this abstraction process, BIT does not support printing non-binary numbers or character strings, or even digits or characters.
  If you wish to represent character data, you can print a sequence of bits that can be interpreted as an ASCII or Unicode code for a character (see clarification below). You should make it clear to whoever runs the code that they will need an ASCII or Unicode reference table as appropriate to interpret the output in this way.
• READ - this reads a bit from the standard input and sets the jump register equal to that bit.
  Only a single bit is read per READ statement, and a bit sequence that may represent an ASCII or Unicode character needs to be read in one bit at a time. Further, the value of the jump register may not be assigned to a variable using the EQUALS operator - to achieve this the program needs to branch and then assign ONE or ZERO, based on the value of the jump register.

[2017-09-16 clarification:] Previously it was specified that PRINT and READ commands could have their output/input interpreted externally by the user as ASCII codes. This is not a limitation of BIT; the output/input may also be interpreted as binary representations of numerical data, as Unicode, or any other coding scheme the external user desires. Any such interpretations should be explained in the program documentation. In triplicate.

[2017-09-16 clarification:] The PRINT command prints either the easily-legible token ONE or ZERO to standard output, followed by a newline. It does not print literal 1s or 0s, or bytes, or Unicode characters, or anything else. Similarly, the READ command reads tokens of the form ONE or ZERO from standard input, ignoring whitespace (but not other intervening characters). Anything which does not form a valid ONE or ZERO token is ignored and skipped over until the next valid token is found. For example, the sequence ON EONExgZE ROZbbERO ONfEONE would parse as ONE ONE xg ZERO ZbbEROONfE ONE.

Resources

• Itty, a BIT interpreter, by Declan Hoare: on GitHub.

Sample Programs

Bit Addition

This program reads any two bits and prints the result of adding them together. The power of BIT is self-evident here.

LINE NUMBER ONE CODE READ GOTO ONE ZERO
LINE NUMBER ONE ZERO CODE VARIABLE ZERO EQUALS THE JUMP REGISTER GOTO ONE ONE
LINE NUMBER ONE ONE CODE READ GOTO ONE ZERO ZERO
LINE NUMBER ONE ZERO ZERO CODE VARIABLE ONE EQUALS THE JUMP REGISTER GOTO ONE ZERO ONE
LINE NUMBER ONE ZERO ONE CODE THE JUMP REGISTER EQUALS OPEN PARENTHESIS VARIABLE ZERO NAND VARIABLE ONE CLOSE PARENTHESIS NAND OPEN PARENTHESIS VARIABLE ZERO NAND VARIABLE ONE CLOSE PARENTHESIS GOTO ONE ONE ZERO IF THE JUMP REGISTER IS EQUAL TO ONE GOTO ONE ZERO ZERO ZERO IF THE JUMP REGISTER IS EQUAL TO ZERO
LINE NUMBER ONE ONE ZERO CODE PRINT ONE GOTO ONE ONE ONE
LINE NUMBER ONE ONE ONE CODE PRINT ZERO
LINE NUMBER ONE ZERO ZERO ZERO CODE THE JUMP REGISTER EQUALS OPEN PARENTHESIS VARIABLE ZERO NAND VARIABLE ZERO CLOSE PARENTHESIS NAND OPEN PARENTHESIS VARIABLE ONE NAND VARIABLE ONE CLOSE PARENTHESIS GOTO ONE ZERO ZERO ONE IF THE JUMP REGISTER IS EQUAL TO ZERO GOTO ONE ZERO ONE ZERO IF THE JUMP REGISTER IS EQUAL TO ONE
LINE NUMBER ONE ZERO ZERO ONE CODE PRINT ZERO
LINE NUMBER ONE ZERO ONE ZERO CODE PRINT ONE

Note that this code is formatted rather verbosely with whitespace. The following version is just as valid, and possesses considerable advantages in file size savings:

LINENUMBERONECODEREADGOTOONEZEROLINENUMBERONEZEROCODEVARIABLEZEROEQUALSTHEJUMPR
EGISTERGOTOONEONELINENUMBERONEONECODEREADGOTOONEZEROZEROLINENUMBERONEZEROZEROCO
DEVARIABLEONEEQUALSTHEJUMPREGISTERGOTOONEZEROONELINENUMBERONEZEROONECODETHEJUMP
REGISTEREQUALSOPENPARENTHESISVARIABLEZERONANDVARIABLEONECLOSEPARENTHESISNANDOPE
NPARENTHESISVARIABLEZERONANDVARIABLEONECLOSEPARENTHESISGOTOONEONEZEROIFTHEJUMPR
EGISTERISEQUALTOONEGOTOONEZEROZEROZEROIFTHEJUMPREGISTERISEQUALTOZEROLINENUMBERO
NEONEZEROCODEPRINTONEGOTOONEONEONELINENUMBERONEONEONECODEPRINTZEROLINENUMBERONE
ZEROZEROZEROCODETHEJUMPREGISTEREQUALSOPENPARENTHESISVARIABLEZERONANDVARIABLEZER
OCLOSEPARENTHESISNANDOPENPARENTHESISVARIABLEONENANDVARIABLEONECLOSEPARENTHESISG
OTOONEZEROZEROONEIFTHEJUMPREGISTERISEQUALTOZEROGOTOONEZEROONEZEROIFTHEJUMPREGIS
TERISEQUALTOONELINENUMBERONEZEROZEROONECODEPRINTZEROLINENUMBERONEZEROONEZEROCOD
EPRINTONE

Hello World

This program prints a binary representation of the string "Hello world!". Basically, it is just the print statements necessary to print the ASCII bits. I challenge anyone to use other language features to write a shorter "Hello world!" program in BIT.

LINENUMBERZEROCODEPRINTZEROGOTOONELINENUMBERONECODEPRINTONEGOTOONEZEROLINENUMBE
RONEZEROCODEPRINTZEROGOTOONEONELINENUMBERONEONECODEPRINTZEROGOTOONEZEROZEROLINE
NUMBERONEZEROZEROCODEPRINTONEGOTOONEZEROONELINENUMBERONEZEROONECODEPRINTZEROGOT
OONEONEZEROLINENUMBERONEONEZEROCODEPRINTZEROGOTOONEONEONELINENUMBERONEONEONECOD
EPRINTZEROGOTOONEZEROZEROZEROLINENUMBERONEZEROZEROZEROCODEPRINTZEROGOTOONEZEROZ
EROONELINENUMBERONEZEROZEROONECODEPRINTONEGOTOONEZEROONEZEROLINENUMBERONEZEROON
EZEROCODEPRINTONEGOTOONEZEROONEONELINENUMBERONEZEROONEONECODEPRINTZEROGOTOONEON
EZEROZEROLINENUMBERONEONEZEROZEROCODEPRINTZEROGOTOONEONEZEROONELINENUMBERONEONE
ZEROONECODEPRINTONEGOTOONEONEONEZEROLINENUMBERONEONEONEZEROCODEPRINTZEROGOTOONE
ONEONEONELINENUMBERONEONEONEONECODEPRINTONEGOTOONEZEROZEROZEROZEROLINENUMBERONE
ZEROZEROZEROZEROCODEPRINTZEROGOTOONEZEROZEROZEROONELINENUMBERONEZEROZEROZEROONE
CODEPRINTONEGOTOONEZEROZEROONEZEROLINENUMBERONEZEROZEROONEZEROCODEPRINTONEGOTOO
NEZEROZEROONEONELINENUMBERONEZEROZEROONEONECODEPRINTZEROGOTOONEZEROONEZEROZEROL
INENUMBERONEZEROONEZEROZEROCODEPRINTONEGOTOONEZEROONEZEROONELINENUMBERONEZEROON
EZEROONECODEPRINTONEGOTOONEZEROONEONEZEROLINENUMBERONEZEROONEONEZEROCODEPRINTZE
ROGOTOONEZEROONEONEONELINENUMBERONEZEROONEONEONECODEPRINTZEROGOTOONEONEZEROZERO
ZEROLINENUMBERONEONEZEROZEROZEROCODEPRINTZEROGOTOONEONEZEROZEROONELINENUMBERONE
ONEZEROZEROONECODEPRINTONEGOTOONEONEZEROONEZEROLINENUMBERONEONEZEROONEZEROCODEP
RINTONEGOTOONEONEZEROONEONELINENUMBERONEONEZEROONEONECODEPRINTZEROGOTOONEONEONE
ZEROZEROLINENUMBERONEONEONEZEROZEROCODEPRINTONEGOTOONEONEONEZEROONELINENUMBERON
EONEONEZEROONECODEPRINTONEGOTOONEONEONEONEZEROLINENUMBERONEONEONEONEZEROCODEPRI
NTZEROGOTOONEONEONEONEONELINENUMBERONEONEONEONEONECODEPRINTZEROGOTOONEZEROZEROZ
EROZEROZEROLINENUMBERONEZEROZEROZEROZEROZEROCODEPRINTZEROGOTOONEZEROZEROZEROZER
OONELINENUMBERONEZEROZEROZEROZEROONECODEPRINTONEGOTOONEZEROZEROZEROONEZEROLINEN
UMBERONEZEROZEROZEROONEZEROCODEPRINTONEGOTOONEZEROZEROZEROONEONELINENUMBERONEZE
ROZEROZEROONEONECODEPRINTZEROGOTOONEZEROZEROONEZEROZEROLINENUMBERONEZEROZEROONE
ZEROZEROCODEPRINTONEGOTOONEZEROZEROONEZEROONELINENUMBERONEZEROZEROONEZEROONECOD
EPRINTONEGOTOONEZEROZEROONEONEZEROLINENUMBERONEZEROZEROONEONEZEROCODEPRINTONEGO
TOONEZEROZEROONEONEONELINENUMBERONEZEROZEROONEONEONECODEPRINTONEGOTOONEZEROONEZ
EROZEROZEROLINENUMBERONEZEROONEZEROZEROZEROCODEPRINTZEROGOTOONEZEROONEZEROZEROO
NELINENUMBERONEZEROONEZEROZEROONECODEPRINTZEROGOTOONEZEROONEZEROONEZEROLINENUMB
ERONEZEROONEZEROONEZEROCODEPRINTONEGOTOONEZEROONEZEROONEONELINENUMBERONEZEROONE
ZEROONEONECODEPRINTZEROGOTOONEZEROONEONEZEROZEROLINENUMBERONEZEROONEONEZEROZERO
CODEPRINTZEROGOTOONEZEROONEONEZEROONELINENUMBERONEZEROONEONEZEROONECODEPRINTZER
OGOTOONEZEROONEONEONEZEROLINENUMBERONEZEROONEONEONEZEROCODEPRINTZEROGOTOONEZERO
ONEONEONEONELINENUMBERONEZEROONEONEONEONECODEPRINTZEROGOTOONEONEZEROZEROZEROZER
OLINENUMBERONEONEZEROZEROZEROZEROCODEPRINTZEROGOTOONEONEZEROZEROZEROONELINENUMB
ERONEONEZEROZEROZEROONECODEPRINTONEGOTOONEONEZEROZEROONEZEROLINENUMBERONEONEZER
OZEROONEZEROCODEPRINTONEGOTOONEONEZEROZEROONEONELINENUMBERONEONEZEROZEROONEONEC
ODEPRINTONEGOTOONEONEZEROONEZEROZEROLINENUMBERONEONEZEROONEZEROZEROCODEPRINTZER
OGOTOONEONEZEROONEZEROONELINENUMBERONEONEZEROONEZEROONECODEPRINTONEGOTOONEONEZE
ROONEONEZEROLINENUMBERONEONEZEROONEONEZEROCODEPRINTONEGOTOONEONEZEROONEONEONELI
NENUMBERONEONEZEROONEONEONECODEPRINTONEGOTOONEONEONEZEROZEROZEROLINENUMBERONEON
EONEZEROZEROZEROCODEPRINTZEROGOTOONEONEONEZEROZEROONELINENUMBERONEONEONEZEROZER
OONECODEPRINTONEGOTOONEONEONEZEROONEZEROLINENUMBERONEONEONEZEROONEZEROCODEPRINT
ONEGOTOONEONEONEZEROONEONELINENUMBERONEONEONEZEROONEONECODEPRINTZEROGOTOONEONEO
NEONEZEROZEROLINENUMBERONEONEONEONEZEROZEROCODEPRINTONEGOTOONEONEONEONEZEROONEL
INENUMBERONEONEONEONEZEROONECODEPRINTONEGOTOONEONEONEONEONEZEROLINENUMBERONEONE
ONEONEONEZEROCODEPRINTONEGOTOONEONEONEONEONEONELINENUMBERONEONEONEONEONEONECODE
PRINTONEGOTOONEZEROZEROZEROZEROZEROZEROLINENUMBERONEZEROZEROZEROZEROZEROZEROCOD
EPRINTZEROGOTOONEZEROZEROZEROZEROZEROONELINENUMBERONEZEROZEROZEROZEROZEROONECOD
EPRINTONEGOTOONEZEROZEROZEROZEROONEZEROLINENUMBERONEZEROZEROZEROZEROONEZEROCODE
PRINTONEGOTOONEZEROZEROZEROZEROONEONELINENUMBERONEZEROZEROZEROZEROONEONECODEPRI
NTONEGOTOONEZEROZEROZEROONEZEROZEROLINENUMBERONEZEROZEROZEROONEZEROZEROCODEPRIN
TZEROGOTOONEZEROZEROZEROONEZEROONELINENUMBERONEZEROZEROZEROONEZEROONECODEPRINTZ
EROGOTOONEZEROZEROZEROONEONEZEROLINENUMBERONEZEROZEROZEROONEONEZEROCODEPRINTONE
GOTOONEZEROZEROZEROONEONEONELINENUMBERONEZEROZEROZEROONEONEONECODEPRINTZEROGOTO
ONEZEROZEROONEZEROZEROZEROLINENUMBERONEZEROZEROONEZEROZEROZEROCODEPRINTZEROGOTO
ONEZEROZEROONEZEROZEROONELINENUMBERONEZEROZEROONEZEROZEROONECODEPRINTONEGOTOONE
ZEROZEROONEZEROONEZEROLINENUMBERONEZEROZEROONEZEROONEZEROCODEPRINTONEGOTOONEZER
OZEROONEZEROONEONELINENUMBERONEZEROZEROONEZEROONEONECODEPRINTZEROGOTOONEZEROZER
OONEONEZEROZEROLINENUMBERONEZEROZEROONEONEZEROZEROCODEPRINTONEGOTOONEZEROZEROON
EONEZEROONELINENUMBERONEZEROZEROONEONEZEROONECODEPRINTONEGOTOONEZEROZEROONEONEO
NEZEROLINENUMBERONEZEROZEROONEONEONEZEROCODEPRINTZEROGOTOONEZEROZEROONEONEONEON
ELINENUMBERONEZEROZEROONEONEONEONECODEPRINTZEROGOTOONEZEROONEZEROZEROZEROZEROLI
NENUMBERONEZEROONEZEROZEROZEROZEROCODEPRINTZEROGOTOONEZEROONEZEROZEROZEROONELIN
ENUMBERONEZEROONEZEROZEROZEROONECODEPRINTONEGOTOONEZEROONEZEROZEROONEZEROLINENU
MBERONEZEROONEZEROZEROONEZEROCODEPRINTONEGOTOONEZEROONEZEROZEROONEONELINENUMBER
ONEZEROONEZEROZEROONEONECODEPRINTZEROGOTOONEZEROONEZEROONEZEROZEROLINENUMBERONE
ZEROONEZEROONEZEROZEROCODEPRINTZEROGOTOONEZEROONEZEROONEZEROONELINENUMBERONEZER
OONEZEROONEZEROONECODEPRINTONEGOTOONEZEROONEZEROONEONEZEROLINENUMBERONEZEROONEZ
EROONEONEZEROCODEPRINTZEROGOTOONEZEROONEZEROONEONEONELINENUMBERONEZEROONEZEROON
EONEONECODEPRINTZEROGOTOONEZEROONEONEZEROZEROZEROLINENUMBERONEZEROONEONEZEROZER
OZEROCODEPRINTZEROGOTOONEZEROONEONEZEROZEROONELINENUMBERONEZEROONEONEZEROZEROON
ECODEPRINTZEROGOTOONEZEROONEONEZEROONEZEROLINENUMBERONEZEROONEONEZEROONEZEROCOD
EPRINTONEGOTOONEZEROONEONEZEROONEONELINENUMBERONEZEROONEONEZEROONEONECODEPRINTZ
EROGOTOONEZEROONEONEONEZEROZEROLINENUMBERONEZEROONEONEONEZEROZEROCODEPRINTZEROG
OTOONEZEROONEONEONEZEROONELINENUMBERONEZEROONEONEONEZEROONECODEPRINTZEROGOTOONE
ZEROONEONEONEONEZEROLINENUMBERONEZEROONEONEONEONEZEROCODEPRINTZEROGOTOONEZEROON
EONEONEONEONELINENUMBERONEZEROONEONEONEONEONECODEPRINTONE

Repeat Arbitrary Number of Ones

This program demonstrates the use of address-of-a-bit variables to store arbitrarily large amounts of data and access it again. It reads any number of bits from the input until a zero is read, then prints out the sequence of bits read in.

LINE NUMBER ZERO CODE VARIABLE ONE EQUALS THE ADDRESS OF VARIABLE ZERO GOTO ONE
LINE NUMBER ONE CODE READ GOTO ONE ZERO
LINE NUMBER ONE ZERO CODE THE VALUE AT VARIABLE ONE EQUALS THE JUMP REGISTER GOTO ONE ONE IF THE JUMP REGISTER IS ONE GOTO ONE ZERO ZERO IF THE JUMP REGISTER IS ZERO
LINE NUMBER ONE ONE CODE VARIABLE ONE EQUALS THE ADDRESS OF THE VALUE BEYOND VARIABLE ONE GOTO ONE
LINE NUMBER ONE ZERO ZERO CODE VARIABLE ONE EQUALS THE ADDRESS OF VARIABLE ZERO GOTO ONE ZERO ONE
LINE NUMBER ONE ZERO ONE CODE THE JUMP REGISTER EQUALS THE VALUE AT VARIABLE ONE GOTO ONE ONE ZERO IF THE JUMP REGISTER IS ONE GOTO ONE ZERO ZERO ZERO IF THE JUMP REGISTER IS ZERO
LINE NUMBER ONE ONE ZERO CODE PRINT ONE GOTO ONE ONE ONE
LINE NUMBER ONE ONE ONE CODE VARIABLE ONE EQUALS THE ADDRESS OF THE VALUE BEYOND VARIABLE ONE GOTO ONE ZERO ONE
LINE NUMBER ONE ZERO ZERO ZERO CODE PRINT ZERO

Shorter Hello World

Mark Whybird has risen to the challenge! First he reduced my 6298-character version to a mere 5216 characters. He writes:

• My line numbers are both gappy and in one case not in order, purely because it was easier to use your hello world as a template and mostly leave the letters in their existing line number locations.
• A few valuable source-code bytes could be saved by placing the 'Print l' (most common), and then "Print 0" subroutines on lower-numbered lines, thus making their addresses shorter. You could save even more bytes by also placing their return lines on lower-numbered lines. Fortunately, the feature (at least, it's not ruled out by the spec) of not having to have the lines sequentially in the code means that readability is not impaired.
• Note that I used variable ONE, not ZERO, because it saves a byte of source code every time I use it.
• Generally, when numbering things (lines, variables), I should order then in terms of length of written name and use the shortest as the most frequently used item, etc.

He then wrote again, saying:

Okay, so to complete the challenge, I implemented my thoughts and brought it down to 4997 characters.

The line numbers are now neither contiguous nor sequential. For my convenience, I have listed them in order of length of line number reference. Reorder them if your BIT compiler requires it.

I think the fact that only an hour or so's work can save a massive 1.38K of source code really shows the power of your approach of combining the power of C-style string handling and the terseness of COBOL! Since I saw a 1TB disk drive at OfficeWorks the other day for $99, I calculate my work has saved $0.0000001404 worth of storage space, every single time the file is stored - not to mention savings in transmission costs and time!

Without further ado, his massively efficient Hello World:

LINE NUMBER ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ONE
LINE NUMBER ONE CODE PRINT ZERO GOTO ONE ZERO
LINE NUMBER ONE ONE CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ZERO
LINE NUMBER ONE ZERO CODE PRINT ONE GOTO ONE ONE
LINE NUMBER ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE
LINE NUMBER ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ZERO
LINE NUMBER ONE ONE ZERO CODE PRINT ONE GOTO ONE ZERO ZERO
LINE NUMBER ONE ZERO ZERO CODE PRINT ONE GOTO ONE ONE ONE ONE
LINE NUMBER ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE
LINE NUMBER ONE ZERO ONE ONE CODE PRINT ZERO GOTO VARIABLE ONE
LINE NUMBER ONE ONE ZERO ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO
LINE NUMBER ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ONE
LINE NUMBER ONE ZERO ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ONE ZERO
LINE NUMBER ONE ZERO ONE ZERO CODE PRINT ONE GOTO ONE ONE ZERO ZERO
LINE NUMBER ONE ONE ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO
LINE NUMBER ONE ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE
LINE NUMBER ONE ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE
LINE NUMBER ONE ZERO ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ONE
LINE NUMBER ONE ONE ZERO ONE ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO ONE
LINE NUMBER ONE ONE ONE ZERO ONE CODE PRINT ONE GOTO ONE ONE ONE ONE ZERO
LINE NUMBER ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ONE
LINE NUMBER ONE ZERO ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ZERO ONE
LINE NUMBER ONE ZERO ONE ZERO ONE CODE PRINT ONE GOTO ONE ZERO ONE ONE ZERO
LINE NUMBER ONE ZERO ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ONE
LINE NUMBER ONE ONE ZERO ZERO ONE CODE PRINT ONE GOTO ONE ONE ZERO ONE ZERO
LINE NUMBER ONE ONE ZERO ONE ZERO CODE VARIABLE ONE EQUALS ONE ONE ONE ZERO ZERO GOTO ONE
LINE NUMBER ONE ONE ONE ZERO ZERO CODE VARIABLE ONE EQUALS ONE ZERO ZERO ZERO ONE GOTO ONE
LINE NUMBER ONE ZERO ZERO ZERO ONE CODE VARIABLE ONE EQUALS ONE ONE ONE ONE ZERO ONE GOTO ONE ONE
LINE NUMBER ONE ZERO ZERO ONE ZERO CODE PRINT ONE GOTO ONE ZERO ONE ZERO ZERO
LINE NUMBER ONE ZERO ONE ZERO ZERO CODE PRINT ONE GOTO ONE ONE ZERO ZERO ZERO
LINE NUMBER ONE ONE ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO ZERO
LINE NUMBER ONE ZERO ZERO ZERO ZERO CODE PRINT ONE GOTO ONE ONE ONE ONE ONE ONE
LINE NUMBER ONE ONE ONE ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE ONE ONE ONE
LINE NUMBER ONE ZERO ONE ONE ONE ONE CODE PRINT ONE GOTO ONE ONE ZERO ONE ONE ONE
LINE NUMBER ONE ONE ZERO ONE ONE ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO ONE ONE
LINE NUMBER ONE ONE ONE ZERO ONE ONE CODE PRINT ZERO GOTO VARIABLE ONE
LINE NUMBER ONE ONE ONE ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE ZERO
LINE NUMBER ONE ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZEROZERO ONE ONE ONE
LINE NUMBER ONE ZERO ZERO ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE ZERO ONE ONE
LINE NUMBER ONE ZERO ONE ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ZERO ONE
LINE NUMBER ONE ZERO ONE ONE ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE ZERO
LINE NUMBER ONE ZERO ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ONE ONE
LINE NUMBER ONE ONE ZERO ZERO ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ZERO ONE
LINE NUMBER ONE ONE ZERO ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ONE ZERO
LINE NUMBER ONE ONE ZERO ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ONE ZERO ZERO ONE
LINE NUMBER ONE ONE ONE ZERO ZERO ONE CODE PRINT ONE GOTO ONE ONE ONE ZERO ONE ZERO
LINE NUMBER ONE ONE ONE ZERO ONE ZERO CODE PRINT ONE GOTO ONE ONE ONE ONE ZERO ZERO
LINE NUMBER ONE ONE ONE ONE ZERO ZERO CODE PRINT ONE GOTO ONE ZERO ZERO ZERO ONE ONE
LINE NUMBER ONE ZERO ZERO ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ZERO ONE
LINE NUMBER ONE ZERO ZERO ONE ZERO ONE CODE PRINT ONE GOTO ONE ZERO ZERO ONE ONE ZERO
LINE NUMBER ONE ZERO ZERO ONE ONE ZERO CODE PRINT ONE GOTO ONE ZERO ONE ZERO ZERO ONE
LINE NUMBER ONE ZERO ONE ZERO ZERO ONE CODE PRINT ONE GOTO ONE ZERO ONE ZERO ONE ZERO
LINE NUMBER ONE ZERO ONE ZERO ONE ZERO CODE VARIABLE ONE EQUALS ONE ZERO ONE ONE ZERO ZERO GOTO ONE ONE
LINE NUMBER ONE ZERO ONE ONE ZERO ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ZERO ONE
LINE NUMBER ONE ONE ZERO ZERO ZERO ONE CODE PRINT ONE GOTO ONE ONE ZERO ZERO ONE ZERO
LINE NUMBER ONE ONE ZERO ZERO ONE ZERO CODE PRINT ONE GOTO ONE ONE ZERO ONE ZERO ZERO
LINE NUMBER ONE ONE ZERO ONE ZERO ZERO CODE PRINT ONE GOTO ONE ONE ONE ZERO ZERO ZERO
LINE NUMBER ONE ONE ONE ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO ZERO ONE
LINE NUMBER ONE ZERO ZERO ZERO ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ZERO ZERO ONE ZERO
LINE NUMBER ONE ZERO ZERO ZERO ONE ZERO CODE PRINT ONE GOTO ONE ZERO ZERO ONE ZERO ZERO
LINE NUMBER ONE ZERO ZERO ONE ZERO ZERO CODE PRINT ZERO GOTO ONE ZERO ONE ZERO ZERO ZERO
LINE NUMBER ONE ZERO ONE ZERO ZERO ZERO CODE VARIABLE ONE EQUALS ONE ONE ZERO ZERO ZERO ZERO GOTO ONE
LINE NUMBER ONE ONE ZERO ZERO ZERO ZERO CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE ONE ONE
LINE NUMBER ONE ONE ONE ONE ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ZERO ZERO ZERO ZERO
LINE NUMBER ONE ZERO ZERO ZERO ZERO ZERO CODE PRINT ONE GOTO ONE ZERO ONE ONE ONE ONE ONE
LINE NUMBER ONE ZERO ONE ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ONE ONE ONE
LINE NUMBER ONE ONE ZERO ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ONE ZERO ONE ONE ONE
LINE NUMBER ONE ONE ONE ZERO ONE ONE ONE CODE PRINT ONE GOTO ONE ONE ONE ONE ZERO ONE ONE
LINE NUMBER ONE ONE ONE ONE ZERO ONE ONE CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE ZERO ONE
LINE NUMBER ONE ONE ONE ONE ONE ZERO ONE CODE PRINT ZERO GOTO ONE ONE ONE ONE ONE ONE ZERO
LINE NUMBER ONE ONE ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ZERO ZERO ONE ONE ONE ONE
LINE NUMBER ONE ZERO ZERO ONE ONE ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ZERO ONE ONE ONE
LINE NUMBER ONE ZERO ONE ZERO ONE ONE ONE CODE PRINT ONE GOTO ONE ZERO ONE ONE ZERO ONE ONE
LINE NUMBER ONE ZERO ONE ONE ZERO ONE ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE ZERO ONE
LINE NUMBER ONE ZERO ONE ONE ONE ZERO ONE CODE PRINT ZERO GOTO ONE ZERO ONE ONE ONE ONE ZERO
LINE NUMBER ONE ZERO ONE ONE ONE ONE ZERO CODE PRINT ZERO GOTO ONE ONE ZERO ZERO ONE ONE ONE
LINE NUMBER ONE ONE ZERO ZERO ONE ONE ONE CODE PRINT ZERO GOTO ONE ONE ZERO ONE ZERO ONE ONE
LINE NUMBER ONE ONE ZERO ONE ZERO ONE ONE CODE PRINT ONE