Sinclair Special Interest Group

This program is a promotional demo for the Chicago Sinclair Special Interest Group, displaying an animated introduction screen with scrolling ticker text. It makes extensive use of machine code routines called via RAND USR at addresses in the 30000–31000+ range to handle graphics drawing, screen effects, and hardware control, with parameters passed by POKEing values into fixed RAM locations just before each call. The program builds a long inverse-video text string in C$ that scrolls smoothly across row 22 in three phases: an entry scroll from the right, a middle pan, and an exit scroll to the left. A subroutine at line 2000 displays a sequence of inverse-video advertising messages (“LOOKING FOR INEXPENSIVE COMPUTING?”) and then draws what appears to be a logo using ZX81 block graphics characters. The program loops indefinitely via GOTO 10 at line 1220.

---

Program Analysis

Program Structure

The program is organized into a main sequence and two subroutines, executing in a continuous loop:

1. Lines 10–200: Machine code initialization and startup animation sequence, including screen setup, palette cycling, and display effects via repeated RAND USR calls inside FOR loops.
2. Lines 210–490: Further animation phases, culminating in a CLS and transition to the main content.
3. Lines 498–499: GOSUB to the advertisement subroutine (2000) and then to a screen-fill subroutine (4000).
4. Lines 500–510: Draws a decorative border on rows 21–23 using block graphic characters.
5. Lines 520–570: Builds the scrolling ticker string C$ (and B$) from concatenated inverse-video text fragments.
6. Lines 1060–1200: Three-phase horizontal scroll of B$ across row 22.
7. Line 1210–1220: CLS and GOTO 10 for an infinite loop.
8. Lines 2000–2660: Advertisement subroutine — displays inverse-video promotional messages with delay loops, then draws a block-graphic logo using PLOT and machine code line-draw routines.
9. Lines 4000–4130: Screen animation subroutine using machine code loops for rows and columns.

Machine Code Usage

The program relies heavily on external machine code routines loaded elsewhere in RAM. Parameters are passed by POKEing values into fixed addresses immediately before each RAND USR call. The following addresses are used:

Address	Usage
30646 / 30656	Row/column animation routine (scroll down?)
30696 / 30699	Row/column animation routine (scroll up?)
30946	Called once after POKE 31738,50 — likely sets display mode or speed
30962	Called after delay loop — display effect
30968	Called at startup
31017	Called in subroutines; may clear or initialize screen region
31028	Called at program start and in subroutine 2000 — likely hardware init
31152	Called after POKEing 31737,0 and 31736,21
31179	Called once after startup
31329	Called after POKEing coordinates into 31733/31732 — likely a line-draw routine
31351	Called with parameter in 31741 — likely a colour/attribute cycle routine
31465	Called at start of subroutine 4000
31666	Column animation routine

The parameter-passing convention is consistent: POKE the target address with a value, then immediately call RAND USR. For example, lines 2300–2320 POKE X and Y into addresses 31733 and 31732 before calling the line-draw routine at 31329. The PLOT call preceding each line-draw likely sets the start point.

The REM Line as Data

Line 50 is a REM statement containing a long sequence of block graphic characters (%, >, <, V, etc. rendered as block graphics in the ZX81 character set). This is a classic technique for embedding machine code or sprite data within a BASIC program — the REM body is never executed by BASIC but sits at a known address in memory where machine code can read or use it as a data table. The characters in the REM are almost certainly the machine code payload itself, encoded as BASIC token bytes.

Scrolling Ticker Implementation

The scrolling marquee is implemented in three FOR loops across lines 1060–1200, all printing to row 22:

• Entry phase (lines 1060–1100): F runs 0 to 30; prints B$(1 TO F+1) at column 31-F, sliding text in from the right.
• Middle phase (lines 1110–1150): E runs 1 to LEN B$-33; prints a 32-character window B$(E+1 TO E+32) at column 0, panning through the string.
• Exit phase (lines 1160–1200): C runs 0 to 31; prints a shrinking tail of the string at column 0, sliding text off to the left.

Each phase includes a short delay loop (FOR D=1 TO 3: NEXT D) and a POKE 16418,0 before each print. Address 16418 is the ZX81 system variable MARGIN, and zeroing it suppresses the automatic scroll so the display stays stable during animation.

Inverse Video Text

All displayed text uses the %X inverse video escape throughout, giving the entire presentation a reverse-video aesthetic. The ticker string C$ is built in three concatenation steps (lines 520, 560, 565) to stay within BASIC line-length limits. The content credits club officers by name and role, including the chair and contacts for beginners, BASIC programming, machine/assembly language, and hardware.

Block Graphics Logo

Subroutine 2000 draws a multi-row logo at lines 2490–2650 using ZX81 block graphic characters (▌, ▘, ▝, ▄, ▟, etc.) arranged carefully across rows 1–18. The logo appears to spell out “SINCLAIR” or a related acronym in chunky pixel art. Three PLOT+POKE+RAND USR 31329 sequences before the logo draw lines connecting elements of the graphic.

Notable Techniques

• POKE 16418,0 before each PRINT in the scroll loop suppresses auto-scroll (zeroes the MARGIN system variable).
• Parameters for machine code routines are passed via fixed POKE addresses rather than registers, allowing clean BASIC-to-ML interfacing.
• String concatenation across multiple LET statements works around the ZX81’s line-length restriction for long ticker messages.
• Delay loops (FOR I=1 TO N: NEXT I) are used for timing throughout, since no PAUSE command with fine granularity is available.
• The program restarts via GOTO 10 (line 1220) rather than GOTO 1 or RUN, skipping re-execution of the very first machine code init calls if any state persists — though in practice the ML routines at line 10 and 20 are called again each loop.

Potential Anomalies

Line 40 sets up FOR B=1 TO 1, which executes its body exactly once. The corresponding NEXT B at line 200 closes this single-iteration loop. This appears to be a structural leftover — perhaps the loop count was once larger for repeated animation passes during the intro sequence.

The exit-scroll phase (lines 1160–1200) prints a string slice B$(C+LEN B$-31 TO LEN B$) which shrinks from 32 characters down to 1 as C increases, but the AT column stays at 0. This means the text does not actually slide off to the left — it truncates from the left edge while the right end stays fixed. Whether this is intentional or a minor bug depends on the desired visual effect.