Annotated Bibliography

Jim Butterfield

This is a bibliographic list of all articles by Jim Butterfield currently catalogued by the Commodore 8-Bit Magazine Index and readable on archive.org. There are currently 242 articles attributed to this author in the index; this list is incomplete.

Summary of Cassette Data File "Patches": The Transactor, Volume 1, No. 7, December 1978, p. 8.
Tips for improving datasette reliability in BASIC.
UNLIST Revisited: The Transactor, Volume 1, No. 7, December 1978, p. 9.
Instructions for merging two BASIC programs on tape using Larry Tessler's UNLIST utility. (Reprinted from PET User Notes, September 1978, p. 5).
Commercial Confusion: The Transactor, Volume 1, No. 9, February 1979, p. 20.
Prevent floating-point rounding errors from distorting financial calculations by treating pennies as the unit. This technique is illustrated with a 1978 Ontario income tax calculator program written in BASIC.
A Little Exercise in Machine Language: The Transactor, Volume 1, No. 10, March 1979, p. 1.
Example program demonstrates embedding a small machine-language routine in a single BASIC line.
View: The Transactor, Volume 1, No. 10, March 1979, p. 3.
Short machine language displays a single "page" of 6502-addressed memory at the top of screen RAM.
Non-Stop: The Transactor, Volume 1, No. 10, March 1979, p. 3.
Short machine-language program disables the STOP key in BASIC.
Watching a Cassette Load: The Transactor, Volume 2, No. 1, May 1979, p. 1.
Outlines a technique for routing a program loaded from datasette to screen RAM.
Decimal/Hex Conversion: A Few Techniques: The Transactor, Volume 2, No. 1, May 1979, p. 2.
Techniques for converting decimal values to hexadecimal in immediate mode.
Review: BASIC for Home Computers: The Transactor, Volume 2, No. 1, May 1979, p. 9.
Review of BASIC for Home Computers by Bob Albrecht, LeRoy Finkel, and Jerald R. Brown (John Wiley & Sons, 1978).
Merging PET Programs: A Final Report: The Transactor, Volume 2, No. 2, June 1979, p. 5.
BASIC snippets for merging programs and data files on tape.
Memory Locations for ROM Upgrade on PET Computers: The Transactor, Volume 2, No. 2, June 1979, p. 14.
Memory map for PETs with upgraded ROM.
A Few Routines from PET BASIC: The Transactor, Volume 2, No. 3, July 1979, p. 21.
Memory maps of BASIC routines in original and upgrade ROM PETs.
Disabling the STOP Key: The Transactor, Volume 2, No. 4, August 1979, p. 7.
Two methods for disabling the STOP key in BASIC.
A Fast Sort: The Transactor, Volume 2, No. 4, August 1979, p. 8.
A "selective replacement" sort routine written in BASIC.
PET in Transition: Compute!, Issue 1, Volume 1, No. 1, September 1979, p. 68.
Memory map for the PET ROM upgrade.
Un-Crashing on Upgrade ROM Computers: Compute!, Issue 1, Volume 1, No. 1, September 1979, p. 89.
Hardware methods to reset the PET when machine-language programs crash.
Memory Map: Original ROM to Upgrade ROM: The Transactor, Volume 2, No. 5, October 1979, p. 3.
Conversion table to cross-reference ROM locations between original and upgrade ROM PETs.
Cassette File END Markers: The Transactor, Volume 2, No. 5, October 1979, p. 7.
Writing an END marker to tape in BASIC.
Screen Print Routine: The Transactor, Volume 2, No. 5, October 1979, p. 13.
Machine language routine that prints the screen on a 2022 or 2023 printer. Includes source code.
The IEEE-488 Bus: The Transactor, Volume 2, No. 5, October 1979, p. 15.
Technical description of the IEEE-488 bus; communicating with devices in BASIC.
Technical Comment on FOR/NEXT Loop Structures: The Transactor, Volume 2, No. 5, October 1979, p. 22.
Technique for jumping out of nested FOR loops in BASIC without overflowing the stack.
Inside the 2040 Disk Drive: The Transactor, Volume 2, No. 6, November 1979, p. 1.
Explanation of the 2040's dual processors and the way they map the disk drive's internal RAM. Includes a DISK MEMORY DISPLAY program written in BASIC. Corrections to the BASIC program listing appear in The Transactor, December 1979, p. 3.
A Few Entry Points: Original/Upgrade ROM: The Transactor, Volume 2, No. 6, November 1979, p. 11.
Cross-reference table of entry points of BASIC ROM and Kernal routines on the original and upgrade ROMs for the PET/CBM.
Book Review: 6502 Assembly Language Programming: Compute!, Issue 2, Volume 2, No. 1, January 1980, p. 36.
Review of 6502 Assembly Language Programming by Lance A. Leventhal (Osborne & Associates, 1979).
BASIC Memory Map (Page 0): Compute!, Issue 2, Volume 2, No. 1, January 1980, p. 41.
Memory map comparing BASIC zero-page usage in the single-board KIM, AIM, and SYM computers alongside the PET (Microsoft BASIC) and Apple II (Applesoft BASIC).
A Few Entry Points: Original/Upgrade ROM: Compute!, Issue 2, Volume 2, No. 1, January 1980, p. 93.
Address cross-reference table comparing entry points for useful routines in both BASIC and Kernal ROM revisions for the PET.
Inside the 2040 Disk Drive: Compute!, Issue 2, Volume 2, No. 1, January 1980, p. 94.
A memory-dump program for looking at the ROMs inside the 2040 disk drive.
Machine Language: Compute!, Issue 3, Volume 2, No. 2, March 1980, p. 26.
Broad comparison of machine language and BASIC.
Memo to Machine Language Programmers: Compute!, Issue 3, Volume 2, No. 2, March 1980, p. 96.
Finding free bytes in zero-page RAM.
Review: PET and the IEEE-4888 Bus (GPIB): Compute!, Issue 4, Volume 2, No. 3, May 1980, p. 37.
Review of PET and the IEEE-4888 Bus (GPIB) by Eugene Fisher and C. W. Jensen (Osborne/McGraw Hill, 1980).
Review: 6502 Software Design: Compute!, Issue 4, Volume 2, No. 3, May 1980, p. 40.
Review of 6502 Software Design by Leo J. Scanlon (Howard W. Sams & Co., 1980).
Machine Language Tools: Compute!, Issue 4, Volume 2, No. 3, May 1980, p. 57.
Introductory article about machine language resources, monitors, and assemblers.
Cross-Reference for the PET: Compute!, Issue 4, Volume 2, No. 3, May 1980, p. 63.
Program reads a BASIC listing from disk and compiles lists of variable and line-number references.
Some Routines from Microsoft BASIC: Compute II, June/July 1980, p. 13.
Memory maps of Microsoft BASIC for the KIM-1, SYM, AIM, and OSI versions.
Programming & Interfacing the 6502, with Experiments: Compute II, June/July 1980, p. 21.
Review of Programming & Interfacing the 6502, with Experiments (Howard W. Sams & Co., 1980).
BASIC Memory Map (Page 0): Compute II, June/July 1980, p. 33.
Memory map comparing BASIC zero-page usage in the single-board KIM, AIM, SYM, and OSI computers.
Butterfield Reports: The 8032: Compute!, Issue 5, Volume 2, No. 4, July 1980, p. 69.
Preview of the CBM 8016 and 8032.
Shift Work: Compute!, Issue 5, Volume 2, No. 4, July 1980, p. 85.
Idiosyncrasies of the SHIFT key on the PET/CBM: shifted spaces, SHIFT-RETURN, and "pseudo-shifted" characters.
Mixing BASIC and Machine Language: Compute!, Issue 5, Volume 2, No. 4, July 1980, p. 89.
Technique for appending machine-language subroutines to the end of BASIC programs using a machine-language monitor.
Fitting Machine Language into the PET: Compute!, Issue 5, Volume 2, No. 4, July 1980, p. 94.
Placing machine language programs in memory to coexist with BASIC. Advantages and drawbacks of different strategies.
TelePET: Compute!, Issue 6, Volume 2, No. 5, September 1980, p. 86.
Overview of telecommunications on the PET.
ROM-antic Thoughts: Compute!, Issue 6, Volume 2, No. 5, September 1980, p. 100.
Observations on the different BASIC ROM and DOS versions available for the PET/CBM.
A Few Entry Points, Orignal/Upgrade/4.0 ROM: Compute!, Issue 6, Volume 2, No. 5, September 1980, p. 110.
Address cross-reference table comparing entry points for useful routines in BASIC and Kernal ROM revisions (1.0, 2.0, and 4.0) for the PET.
BASIC CBM 8010 Modem Routines: Compute!, Issue 7, Volume 2, No. 6, November 1980, p. 78.
A short BASIC program enables chat-link communication over modem modem connection to an ASCII system or another PET.
PET 4.0 ROM Routines: Compute!, Issue 7, Volume 2, No. 6, November 1980, p. 88.
Memory locations of PET/CBM 4.0 ROM routines.
BASIC 4.0 Memory Map: Compute!, Issue 7, Volume 2, No. 6, November 1980, p. 92.
Memory map of the PET/CBM BASIC 4.0 ROM, including detailed map of zero page.
Machine Language Addressing Modes: Compute!, Issue 7, Volume 2, No. 6, November 1980, p. 98.
Tutorial on the memory scope of each of the 6502's addressing modes.
Interfacing KIM/SYM/AIM/OSI with BASIC: Compute!, Issue 7, Volume 2, No. 6, November 1980, p. 128.
Writing BASIC/ML hybrid programs on the KIM-1.
Basically Useful BASIC: Financial Fuzzies: Compute!, Issue 8, Volume 3, No. 1, January 1981, p. 22.
Correcting floating-point rounding errors in BASIC.
Machine Language: Scanning the Stack: Compute!, Issue 8, Volume 3, No. 1, January 1981, p. 102.
Advanced uses for the 6502 stack in machine language. Includes source code examples.
Review: Disk-O-Pro: Compute!, Issue 8, Volume 3, No. 1, January 1981, p. 112.
Review of Disk-O-Pro, an upgrade ROM from Skyles Electric Works.
The IEEE Bus – Standing Room Only?: Compute!, Issue 8, Volume 3, No. 1, January 1981, p. 123.
An examination of some shortcomings of the IEEE I/O bus on the PET/CBM.
Simulated PRINT USING: Compute!, Issue 9, Volume 3, No. 2, February 1981, p. 30.
Formatted PRINT routine that pads numbers with leading spaces and trailing zeros.
Mixing and Matching Commodore Disk Systems: Compute!, Issue 9, Volume 3, No. 2, February 1981, p. 104.
Compatibility notes on the 2040 and 8050 disk drives and various PET ROM revisions.
Odds & Ends on PET/CBM Files: Compute!, Issue 9, Volume 3, No. 2, February 1981, p. 118.
Miscellaneous notes on working with tape and disk files on the PET/CBM.
Learning About Garbage Collection: Compute!, Issue 10, Volume 3, No. 3, March 1981, p. 96.
Directed experiments for observing garbage collection and techniques for reducing collection time on PETs with 1.0 or 2.0 ROM revisions.
Programmer's Tips: The IEEE-488 Bus: Commodore Interface, May 1981, p. 20.
Programming the IEEE-488 bus on the PET/CBM. Reprinted from The Transactor, October 1979, p. 15.
Butterfield Box: Booleans, or How to Put Off a Decision: The TORPET, Issue #6, June 1981, p. 6.
Working with boolean expressions in BASIC to clean up the design of complicated condtionals.
Butterfield on Commodore: What Hardware Do I Have? What Software Do I Have?: Commodore Interface, July 1981, p. 8.
Criteria for identifying PET/CBM hardware configurations and BASIC ROM revisions.
Butterfield Box: The Lazy Programmer: The TORPET, Issue #7, October 1981, p. 6.
Article about the virtue of "laziness" in programming.
Supermon Instructions: The TORPET, Issue #7, October 1981, p. 33.
Documentation for the Supermon machine-language monitor by Jim Butterfield.
Two Points of View on the 'Fat Forty': The Fat 40: A New Generation 40 Column PET: Commodore Microcomputers, Volume 2, No. 4, October 1981, p. 49.
Butterfield notes similarities and differences between the "FAT 40" 4032 and the 8032.
PET 4.0 ROM Routines: Commodore Microcomputers, Volume 2, No. 4, October 1981, p. 66.
A memory map of the BASIC 4.0 machines.
Butterfield on Commodore: Everybody Knows...: Commodore Microcomputers, Volume 2, No. 4, October 1981, p. 89.
Commodore BASIC facts that "everybody knows". Topics: changing character sets, TI and TI$, BASIC command abbreviations, the keyboard buffer, programmed cursor controls in PRINT statements, CB2 sound, the built-in machine language monitor, and reading the keyboard with PEEK(151).
The BASIC Box: Feelin' Good: The TORPET, Issue #8, January 1982, p. 7.
A list of some of the things Butterfield likes about the Commodore line of computers.
Butterfield on Commodore: Half a Dialogue—Reading Keys: Commodore Microcomputers, Volume 3, No. 1, February 1982, p. 85.
Using GET and PEEK() to read the keyboard in BASIC.
Butterfield Box: Compiler Comments: The TORPET, Issue #9, April 1982, p. 15.
Comments about compilers and challenges with compiling BASIC.
Butterfield on Commodore: The Print Mint: Commodore Microcomputers, Volume 3, No. 2, April/May 1982, p. 101.
Some observations about the PRINT command in BASIC and printing in columns on the screen and other devices.
VIC Memory Map: The TORPET, Issue #10, May 1982, p. 24.
Detailed memory maps for the VIC-20, including register charts for 6560 and 6522 chips.
Butterfield Box: ASCII Me No Questions: The TORPET, Issue #11, June 1982, p. 4.
PETSCII to ASCII history and case conversions.
Butterfield on Commodore: Commodore Microcomputers, Volume 3, No. 3, June/July 1982, p. 81.
Topics: thoughts on compiler design and automatic relocation of machine language programs. Includes source code.
The PET Family Tree: The TORPET, Issue #12, August 1982, p. 24.
Diagram of the the evolutionary relationships between various Commodore and non-Commodore 6502-based 8-bit machines.
Butterfield on Commodore: Filing It: Commodore Microcomputers, Volume 3, No. 4, August/September 1982, p. 98.
Writing to and reading from data files in BASIC.
The Commodore 64 Maps: The TORPET, Issue #14, October 1982, p. 31.
Detailed memory maps for the Commodore 64, including a register chart for the SID chip.
Butterfield on Commodore: Comments on the Commodore 64 Memory Maps: Commodore Microcomputers, Volume 3, No. 5, October/November 1982, p. 81.
Preliminary memory maps for the 64.
Sweet Sixteen: The TORPET, Issue #15, November 1982, p. 20.
Topics: trade-offs in cost and performance between 8- and 16-bit systems, "blind spots" in programming, and topics Butterfield prefers not to discuss.
A Little Exercise in Machine Language: Commodore Power/Play, Volume 1, No. 3, Winter 1982, p. 50.
Outlines a technique for embedding short machine-language routines in a BASIC REM statement.
A Little VIC Music: Commodore Power/Play, Volume 1, No. 1 – Premier Issue, p. 18.
BASIC program plays a short "mystery" tune on the VIC-20.
Too Clever for Words: The TORPET, Issue #16, January 1983, p. 18.
Butterfield writes about programming style, and how "clever" code can obfuscate its function.
Butterfield Box: Some Serious Math: The TORPET, Issue #17, February 1983, p. 38.
Topics: linear programming and simulation.
The 64 Skiffle Band: Commodore Power/Play, Volume 2, No. 1, Spring 1983, p. 21.
Two 3-voice songs programmed in BASIC, with explanations of the SID registers used in the program.
Butterfield Box: Computers and Show Biz: The TORPET, Issue #18, March 1983, p. 47.
Butterfield writes about writing and filming the educational programs Bits and Bytes and The Academy for TVOntario (TVO).
Butterfield Box: Poor Man's Petunia: The TORPET, Issue #19, May 1983, p. 10.
Schematics for building a "poor man's" digital-to-analog converter.
Butterfield: Foolin' with Boolean: Commodore Power/Play, Volume 2, No. 2, Summer 1983, p. 15.
Topics: assigning the value of boolean expressions to variables, and BASIC AND and OR operators. Includes a BASIC version of the guessing game Bagels.
Butterfield Box: You Can't Get Away from It...: The TORPET, Issue #20, June 1983, p. 28.
Jim Butterfield tells a story about the World's Fair of Trade in Plovdiv, Bulgaria.
Butterfield Box: String Along with Me!: The TORPET, Issue #21, July 1983, p. 27.
Topics: empty strings, conversions between strings and numeric variables, and substring functions.
Butterfield Box: Input Idiosyncracies: The TORPET, Issue #22, August 1983, p. 46.
BASIC's INPUT and INPUT# cannot handle commas and colons. Gives a technique for stuffing a double-quote character into the keyboard buffer before calling INPUT.
Butterfield: Everybody Knows....: Commodore Power/Play, Volume 2, No. 3, Fall 1983, p. 16.
Commodore BASIC facts that "everybody knows". Topics: rounding errors in floating-point numbers, SHIFT-RETURN to make a carriage return without triggering the interpreter, and garbage collection.
Butterfield Box: Swapping and Sharing: The TORPET, Issue #23, September 1983, p. 22.
Jim Butterfield advocates sharing programs freely when copyrights and commercial interests are not violated.
Butterfield Box: Cats and Computers: The TORPET, Issue #24, October 1983, p. 4.
Jim Butterfield talks about his three cats. Sasha is the Siamese who photobombed the cover of this issue.
Butterfield Box: Hard Times: The TORPET, Issue #25, November 1983, p. 15.
Butterfield writes that numerous computer companies are struggling financially.
Disks, Compatibility, and Inner Secrets: TPUG Magazine, Issue #1, February 1984, p. 10.
A look at the differences between various 5.25-inch Commodore drives, including the 2031, 2040, 4040, 1540, 1541, 8050, and 8250.
Las Vegas and the 264: TPUG Magazine, Issue #2, March 1984, p. 29.
Preview of the 264 and 364 (eventually released as the Plus/4), presented at the January, 1984 Consumer Electronics Show (CES) in Las Vegas, Nevada.
Early Notes on the Commodore 264: The TORPET, Issue #27, May 1984, p. 5.
Preview of the improved BASIC on the Commodore 264 (later known as the Plus/4).
Robots: TPUG Magazine, Issue #3, May 1984, p. 14.
Jim Butterfield writes about robots and relays an anecdote about a misbehaving robot during filming of an episode of The Academy on Microcomputers.
The Assembler Maze: TPUG Magazine, Issue #4, June 1984, p. 14.
List of assemblers available for 64, with brief personal reactions.
The Great 25-Cent Experiment: TPUG Magazine, Issue #5, July 1984, p. 15.
Jim Butterfield placed a request for quarters in 18 programs in 1977 to see how many users would respond.
A Commercial Note: TPUG Magazine, Issue #6, September 1984, p. 28.
Jim Butterfield writes about his commercial activities: consulting for Commodore, Bits & Bytes and The Academy on Microcomputers, the Commodore 64 Training Tape, the upcoming Machine language for the Commodore 64 (and other Commodore computers), and SpellPro from Pro-Line Software.
The Commodore B-128 Computer: TPUG Magazine, Issue #7, October 1984, p. 26.
Review of the Commodore B-128 computer.
Software Theft: A Case History: TPUG Magazine, Issue #8, November 1984, p. 19.
Butterfield writes about the case of FBACKUP (Fast Backup) by Thomas Tempelmann, a program widely pirated in North America that has only sold 70 copies worldwide.
Packed with Power: Introducing the Plus/4 and C-16: RUN, Volume 1, No. 11, November 1984, p. 30.
Preview of the Plus/4 and 16.
User Group Presentations: TPUG Magazine, Issue #9, December 1984, p. 38.
Butterfield writes about tailoring user group content to various experience levels to avoid completely shutting out beginners and boring more advanced users.
Secrets in Software: TPUG Magazine, Issue #10, January 1985, p. 44.
Butterfield writes that Easter eggs can act like a programmer's "signature".
Program Piracy and Personal Ethics: TPUG Magazine, Issue #11, February 1985, p. 12.
Butterfield writes about software piracy. Of note: an Ontario group distributes a bootleg version of Flight Simulator II from SubLOGIC, including box, manuals, and counterfeit warranty card.
Computer Comfort: TPUG Magazine, Issue #12, March 1985, p. 14.
Butterfield writes that software needs good documentation and support for users to feel secure in their purchases.
Versatile Mortgage Calculator: TPUG Magazine, Issue #12, March 1985, p. 29.
Mortgage calculator with flexible payment schedule written in BASIC.
Memory Mapping: TPUG Magazine, Issue #13, April 1985, p. 16.
A comparison of memory map documentation styles.
VIC-20 Custom Characters: TPUG Magazine, Issue #13, April 1985, p. 27.
Getting started with user-defined characters in BASIC on a VIC-20 with 8K RAM expansion.
In Praise of VIC-20: TPUG Magazine, Issue #14, May 1985, p. 14.
An argument in favour of the VIC-20 as a computer for beginners.
Adventure and Other Adventures: TPUG Magazine, Issue #15, June 1985, p. 13.
General comments on the history and characteristics of the text adventure game genre.
Inside Inner Space: TPUG Magazine, Issue #15, June 1985, p. 16.
A review of The Complete Commodore Inner Space Anthology (Transactor Publishing, 1985).
The Joy (and Pain) of Spaghetti: TPUG Magazine, Issue #16, August 1985, p. 10.
Butterfield argues that although improvistaional programming can be fun, there are benefits to thinking about programs and planning ahead.
Sound Advice: TPUG Magazine, Issue #17, October 1985, p. 14.
Advanced sound features in BASIC 7.0 on the 128, and comments about using advanced language features vs. writing more 'generic' BASIC code.
Synth Sample: Some Sources: TPUG Magazine, Issue #17, October 1985, p. 14.
A list of the songs in the Synth Sample demo by George Feil.
Commodore 128: New Things: TPUG Magazine, Issue #18, November 1985, p. 16.
New features that differentiate the 128 from the 64.
Commodore 128 – Keywords and Tokens: The Transactor, Volume 6, No. 3, November 1985, p. 32.
BASIC keywords and tokens in BASIC 7.0.
C-64 Video from $41 to $5A: TPUG Magazine, Issue #19, December 1985, p. 4.
Detailed documentation of the registers on the VIC-II video chip.
Graphs Without Math?: TPUG Magazine, Issue #19, December 1985, p. 8.
Graphics commands in BASIC 3.5 and BASIC 7.0.
Artificial (Fake?) Intelligence: TPUG Magazine, Issue #20, January 1986, p. 14.
A critique of the popular view of artificial intelligence.
Commodore 128 Memory Map: Important Locations: Compute!'s Gazette, Issue 32, Volume 4, No. 2, February 1986, p. 80.
A partial memory map of the 128.
C-128 Book Flawed But Useful: TPUG Magazine, Issue #21, March 1986, p. 14.
Review of Commodore 128 Internals by K. Gerits, J. Schieb, and F. Thrun (Abacus Software, 1985).
Machine Language: Maxims for the Commodore 128: The Transactor, Volume 6, No. 5, March 1986, p. 26.
Some machine-language programming guidelines for users new to the 128.
Commodore 128 Memory Maps: Important Locations: The Transactor, Volume 6, No. 5, March 1986, p. 27.
A partial memory map of the 128.
Loading and Linking Commodore Programs: Part 1: Compute!, Issue 70, Volume 8, No. 3, March 1986, p. 82.
Topics: overview of the LOAD command, linking lines in BASIC, tokenization, and loading incompatibilities among Commodore machines.
Education and the Feedback Loop: TPUG Magazine, Issue #22, April 1986, p. 13.
Techniques for responding to user input with meaningful feedback when developing educational programs.
Loading and Linking Commodore Programs: Part 2: Compute!, Issue 71, Volume 8, No. 4, April 1986, p. 68.
Outlines the technique of chain-loading BASIC programs in segments.
Language Arts: TPUG Magazine, Issue #23, May 1986, p. 13.
Musings about the way users and programmers communicate with their computers through language.
Loading and Linking Commodore Programs: Part 3: Compute!, Issue 72, Volume 8, No. 5, May 1986, p. 73.
Two methods of chain-loading BASIC programs: dynamic keyboard buffer stuffing and post-LOAD pointer cleanup.
Orphans: TPUG Magazine, Issue #24, June 1986, p. 6.
Survey of Commodore's orphaned machines: the PET, SuperPET, VIC-20, 16, Plus/4, and B-series.
Loading and Linking Commodore Programs: Part 4: Overlaying: Compute!, Issue 73, Volume 8, No. 6, June 1986, p. 74.
Outlines an overlay technique, where modules or data are loaded from within a running BASIC program.
Jim Butterfield's Complete C128 Memory Map: The Transactor, Volume 7, No. 1, July 1986, p. 29.
Detailed memory maps for the 128, including register diagrams for custom chips.
The C128 – You Can Bank on It: The Transactor, Volume 7, No. 1, July 1986, p. 34.
Introduction to the memory configurations available on the 128 via BASIC 7.0's BANK command. Includes a short BASIC/ML hybrid program that tests the architectural results of various BANK configurations. Does not include ML source code.
Loading and Linking Commodore Programs Part 5: The Commodore 128: Compute!, Issue 74, Volume 8, No. 7, July 1986, p. 94.
Breaking a BASIC program into multiple files: chain loading, linking modules, and program overlays on the 128.
Flying Pleasure: TPUG Magazine, Issue #25, August 1986, p. 6.
Review of Flight Simulator II from SubLOGIC.
Coming Home on FS II: TPUG Magazine, Issue #25, August 1986, p. 10.
Tips for safe landings in SubLOGIC's Flight Simulator II.
Reviews: 40 Great Flight Simulator Adventures and 40 More Great Flight Simulator Adventures: TPUG Magazine, Issue #25, August 1986, p. 37.
Reviews of 40 Great Flight Simulator Adventures (COMPUTE! Books, 1985) and 40 More Great Flight Simulator Adventures (COMPUTE! Books, 1986) by Charles Gulick.
Reviews: Microflyte Joystick System for Flight Simulator II: TPUG Magazine, Issue #25, August 1986, p. 38.
Review of the Microflyte Joystick System from Microcube.
Commodore 128 Machine Language: Part 1: Compute!, Issue 75, Volume 8, No. 8, August 1986, p. 85.
Topics: memory banking on the 128, new machine-language support commands in BASIC 7.0, and passing parameters through SYS.
Commodore 128 Disk Boot Basics: The Transactor, Volume 7, No. 2, September 1986, p. 28.
Explanation of the 128's autoboot feature, with source code examples from three different boot disks.
New Loops: The Commodore 128 BASIC Stack: The Transactor, Volume 7, No. 2, September 1986, p. 30.
Explanation of the 128's BASIC stack, and its interactions with BASIC 7.0's DO/LOOP structure.
Commodore 128 Machine Language: Part 2: Compute!, Issue 76, Volume 8, No. 9, September 1986, p. 96.
Topics: working with the 128's built-in machine-language monitor and integrating machine-language routines with BASIC. Includes source code examples.
Commodore 128 Machine Language: Part 3: Compute!, Issue 77, Volume 8, No. 10, October 1986, p. 94.
Integrating machine-language overlays with BASIC. Includes source code.
Commodore 128 Machine Language: Part 4: Compute!, Issue 78, Volume 8, No. 11, November 1986, p. 78.
Bank switching on the 128.
Video Setup: Part 1: Compute!'s Gazette, Issue 42, Volume 4, No. 12, December 1986, p. 66.
Video Setup is a tool to assist memory allocation for graphics modes on the 64. Includes an explanation of the program's workings and VIC II registers.
Commodore 128 Machine Language: Part 5: Compute!, Issue 79, Volume 8, No. 12, December 1986, p. 72.
Planning memory configurations on the 128. Includes source code.
The Commodore 128 – Banking on the Turns: The Transactor, Volume 7, No. 4, January 1987, p. 56.
A follow-up to The C128 – You Can Bank on It by Jim Butterfield (The Transactor, July 1986, p. 32). There are 16 different memory configurations on the 128 that a machine-language programmer can take advantage of by placing an appropriate value in address $ff00. Includes examples with source code.
Commodore 128 Machine Language: Part 6: Compute!, Issue 80, Volume 9, No. 1, January 1987, p. 59.
Configuring banked memory on the 128.
Video Setup: Part 2: Compute!'s Gazette, Issue 43, Volume 5, No. 1, January 1987, p. 78.
Video Setup 128 is a tool to assist memory allocation for graphics modes on the 128. Includes an explanation of the program's workings and the 128's memory banking.
RAM Expansion for the Commodore 128: Compute!'s Gazette, Issue 45, Volume 5, No. 3, March 1987, p. 74.
BASIC programming techniques that take advantage of the 1750 RAM expansion.
North of the Border: Compute!, Issue 83, Volume 9, No. 4, April 1987, p. 100.
Demonstration of switching off the top and bottom borders so that sprites can be visible outside of the normal screen display area.
Gameports: Joystick, Paddle, and Mouse: Compute!'s Gazette, Issue 47, Volume 5, No. 5, May 1987, p. 90.
Tutorial on reading the joystick ports and signals from joysticks, paddles, trackballs, graphics tablets, and mouses.
Solving Alphanumeric Puzzles on Your Home Computer: Compute!, Issue 84, Volume 9, No. 5, May 1987, p. 101.
Walks through the construction of a BASIC program to assist in solving arithmetic puzzles.
RAMtest 128: Compute!, Issue 85, Volume 9, No. 6, June 1987, p. 96.
RAMtest utility for the 128.
Secondary Address Bits: The Transactor, Volume 8, No. 1, July 1987, p. 44.
When a logical file is OPENed from BASIC, the stored representation of the secondary address exhibits some poorly-documented behaviour.
The 128's CHAR Statement: Compute!, Issue 87, Volume 9, No. 8, August 1987, p. 108.
Thorough explanation of the CHAR command in BASIC 7.0 in both text and graphics modes.
Amiga and 64 Ramdisk Files: Compute!, Issue 88, Volume 9, No. 9, September 1987, p. 93.
Outlines a technique for using expansion RAM as temporary file storage, with a short example program in BASIC.
Nim: The Ultimate Binary Game: Compute!, Issue 89, Volume 9, No. 10, October 1987, p. 87.
Butterfield shows how understanding the bit patterns of binary numbers can lead to a winning strategy in the game of Nim. Includes an implementation of Nim in BASIC, featuring a computer opponent with adaptive difficulty.
Square Roots in ML: The Transactor, Volume 8, No. 4, January 1988, p. 52.
A machine language implementation of calculating square roots by the "long division" method.
The New, Improved Bubble Sort: Compute!, Issue 95, Volume 10, No. 4, April 1988, p. 84.
An improved bubble sort in BASIC.
10 GOTO PROGRAMMING: RUN, Volume 5, No. 5, May 1988, p. 36.
Tips for a novice getting into programming for the first time, with book recommendations.
I Do Windows (on the C128): The Transactor, Volume 9, No. 2, December 1988, p. 49.
The sample program window128 illustrates a technique for using escape sequences to place windows with finer control than BASIC 7.0's WINDOW command allows.
What's Really Inside the Commodore 64?: The Transactor, Volume 9, No. 4, April 1989, p. 69.
Review of What's Really Inside the Commodore 64? by Milton Bathurst (DataCap, 1984). Disassembly of ROM.
Capitals: A Quiz-Based Program: The Transactor, Volume 9, No. 5, June 1989, p. 46.
A simple "state capitals" drill program serves as an illustration of implementing linked lists in BASIC.
Colour Coordination: The Transactor, Volume 9, No. 6, August 1989, p. 76.
Describes how to select colours that will always allow text to be readable by making sure that the foreground luminance level is different from that of the background.
Machine Language: The Curious BIT Command: Compute!'s Gazette Special Section, Volume 12, No. 10, October 1990, p. 16.
Explains some uses for the 6502's BIT opcode. Includes source code.
Machine Language: More BIT Analysis: Compute!'s Gazette Special Section, Volume 12, No. 11, November 1990, p. 20.
Accompanying program uses BIT masks to determine the operand length of 6502 opcodes. Includes source code.
Machine Language: The 128 MLM: BANK on It.: Compute!'s Gazette Special Section, Volume 12, No. 12, December 1990, p. 18.
Tutorial on the 128's memory architecture and bank-switching. Includes source code examples.
Machine Language: Scheduling Multiple Tasks: Compute!'s Gazette Special Section, Volume 13, No. 2, February 1991, p. 22.
Implementing a jiffy-clock scheduler to cause periodic events to fire at different rates. Includes source code.
Machine Language: Everything Means Less than Zero: Compute!'s Gazette Special Section, Volume 13, No. 3, March 1991, p. 22.
The interaction of ADC, SBC, and the carry flag. Includes source code.
Machine Language: Spring the Trap After the Quarry Runs: Compute!'s Gazette Special Section, Volume 13, No. 4, April 1991, p. 20.
How to set up a post-interrupt routine. Includes source code.
Machine Language: A Day at the Races: Compute!'s Gazette Special Section, Volume 13, No. 5, May 1991, p. 18.
A simple horse race simulation in machine language. Includes source code.
Machine Language: Putting It All Together: Compute!'s Gazette Special Section, Volume 13, No. 6, June 1991, p. 21.
Butterfield writes about the benefits of developing with a good symbolic assembler.
Machine Language: Calculating Hi-Res Screens: It All Adds Up: Compute!'s Gazette Special Section, Volume 13, No. 7, July 1991, p. 20.
Converting pixel coordinates to memory locations in machine language. Includes source code.
Machine Language: Back to Basics: Compute!'s Gazette Special Section, Volume 13, No. 8, August 1991, p. 20.
Walks through entering a simple program into a machine-language monitor. Includes source code.
Machine Language: Give It a Nudge with Binary Fractions: Compute!'s Gazette Special Section, Volume 13, No. 9, September 1991, p. 20.
Incrementing values by fractional amounts in binary. Includes source code.
Machine Language: Six Commands are Keys to Input/Output: Compute!'s Gazette Special Section, Volume 13, No. 10, October 1991, p. 19.
Explanations of Kernal routines CHROUT, GETIN, STOP, CHKIN, CHKOUT, and CLRCHN. Includes a short machine-language routine with source code that reads keys and transforms their values before outputting to screen.
Machine Language: Fixed Point Numbers: Compute!'s Gazette Special Section, Volume 13, No. 11, November 1991, p. 19.
Topics: fixed-point numbers in machine language and binary-to-decimal conversions.
Machine Language: Programs, Constants, Variables: Compute!'s Gazette Special Section, Volume 13, No. 12, December 1991, p. 19.
Thoughts on machine-language program design, with a simple example program that echos user input. Includes source code.
Machine Language: Smooth Operators: Compute!'s Gazette Special Section, Volume 14, No. 1, January 1992, p. 19.
Explanation of the 6502 opcodes AND, ORA, and EOR, illustrated with a simple BASIC screen demo incorporating self-modifying code. Includes source code.
Machine Language: Bagels: A Machine Language Game: Compute!'s Gazette Special Section, February/March 1992 – Volume 14, No. 2, p. 18.
Implementation of the classic Bagels guessing game. Includes source code.
Machine Language: Putting a Hex on Your Output: Compute!'s Gazette Special Section, Volume 14, No. 3, April 1992, p. 18.
Printing hexadecimal values in machine language. Includes source code.
Machine Language: Rotating Buffers: Compute!'s Gazette Special Section, Volume 14, No. 5, June 1992, p. 20.
Short machine-language routine reads disk file into a three-byte rotating buffer, looking for the end-of-program BASIC marker. Includes source code.
Machine Language: Simple Stack Usage: Compute!'s Gazette Special Section, Volume 14, No. 6, July 1992, p. 20.
Using the 6502 stack opcodes PHA, PLA, PHP, and PLP. Includes source code.
Machine Language: Screen Effects: Compute!'s Gazette Special Section, Volume 14, No. 7, August 1992, p. 20.
Walks through the development of short machine-language route that writes to screen RAM timed to match the screen retrace. Includes source code.
Machine Language: Smooth Scrolling: Compute!'s Gazette Special Section, Volume 14, No. 8, September 1992, p. 20.
Switching between buffered screens to achieve fine-scrolling characters in machine language. Includes source code.
Machine Language: Directories: Compute!'s Gazette Special Section, Volume 14, No. 9, October 1992, p. 20.
Technique for reading a disk directory in machine language. Includes source code.
Machine Language: Coding Choices: Compute!'s Gazette Special Section, Volume 14, No. 10, November 1992, p. 18.
A discussion of speed and memory tradeoffs, examining three approaches to a modulo calculation.
Machine Language: Animated Characters: Compute!'s Gazette Special Section, Volume 14, No. 11, December 1992, p. 19.
Short machine-language program creates a simple animation by manipulating the pixels of a user-defined character.
Machine Language: A Simple File Counter: Compute!'s Gazette Special Section, Volume 15, No. 1, January 1993, p. 18.
Inner workings of a short machine-language program to determine the size of a file on disk.
Machine Language: Fast Interrupts: Compute!'s Gazette Special Section, Volume 15, No. 2, February 1993, p. 18.
Using interrupt routines to pass signals to background programs. Includes source code.
Machine Language: Strange Opcodes: Compute!'s Gazette Special Section, Volume 15, No. 3, March 1993, p. 18.
A sample program using the unofficial opcode LSE. Includes source code.
Machine Language: Encryption: Compute!'s Gazette Special Section, Volume 15, No. 4, April 1993, p. 18.
A Vigenère cipher program written in machine language. Includes source code.
Machine Language: Arrays: Compute!'s Gazette Special Section, Volume 15, No. 5, May 1993, p. 18.
Working with BASIC's array pointers in machine language. Includes source code.
Your Own Database: Compute!'s Gazette Special Section, Volume 15, No. 5, May 1993, p. 36.
A simple database program written in BASIC, with an explanation of its structure and advice for modifying it.
Machine Language: Screen Screamer: Compute!'s Gazette Special Section, Volume 15, No. 6, June 1993, p. 18.
Butterfield compares two implementations of a machine-language program that fills the screen with characters. Includes source code.
Machine Language: File End Check: Compute!'s Gazette Special Section, Volume 15, No. 7, July 1993, p. 18.
Testing for end-of-file in machine language. Includes source code.
Machine Language: File-End Trimmer: Compute!'s Gazette Special Section, Volume 15, No. 8, August 1993, p. 18.
Trimming garbage after an end-of-file marker in machine language. Includes source code.
Machine Language: Boot Basics: Compute!'s Gazette Special Section, Volume 15, No. 9, September 1993, p. 18.
A simple technique for loading and executing a machine language program from a BASIC boot program.
Machine Language: Assembler Tricks: Compute!'s Gazette Special Section, Volume 15, No. 10, October 1993, p. 18.
Uses of the asterisk (*) as the assembler's working address pointer. Includes source code examples.
Machine Language: Squiggle Array: Compute!'s Gazette Special Section, Volume 15, No. 11, November 1993, p. 18.
A simple PETSCII animation program illustrates array-handling in machine language. Includes source code.
Machine Language: Branches and Jumps: Compute!'s Gazette Special Section, Volume 15, No. 12, December 1993, p. 24.
Illustration of the opcodes that redirect program flow. Includes source code.
Machine Language: I/O Buffers: Compute!'s Gazette Disk Edition, Issue No. 1, January 1994, p. 9.
Butterfield demonstrates I/O buffering with a simple disk copy program. Includes machine-language source code.
Machine Language: The List You See: Compute!'s Gazette Disk Edition, Issue No. 2, February 1994, p. 10.
Comparing representations of machine-language programs: hex dumps, BASIC loaders, disassemblies, assembler listings, and macros. Includes machine-language source code.
Machine Language: BASIC Fun: Compute!'s Gazette Disk Edition, Issue No. 3, March 1994, p. 10.
Changing BASIC keywords after copying BASIC ROM to RAM.
Machine Language: Where to Put It?: Compute!'s Gazette Disk Edition, Issue No. 4, April 1994, p. 13.
On deciding where to place machine-language programs in RAM on various Commodore machines. Includes machine-language source code.
Machine Language: Text to SpeedScript: Compute!'s Gazette Disk Edition, Issue No. 5, May 1994, p. 7.
Converting PETSCII sequential files to SpeedScript format in machine language. Includes source code.
Machine Language: Wordcount: Compute!'s Gazette Disk Edition, Issue No. 6, June 1994, p. 7.
A simple word-count program in machine language. Includes source code.
Getting Started with Machine Language: Compute!'s Gazette Disk Edition, Issue No. 6, June 1994, p. 25.
Topics: registers, some introductory opcodes, the Kernal, flow control, and integrating with BASIC. Includes source code.
Machine Language: Screen Zap: Compute!'s Gazette Disk Edition, Issue No. 7, July 1994, p. 8.
Comparison between filling the text screen with BASIC vs. machine language. Includes source code.
Machine Language: Reading All Directories: Compute!'s Gazette Disk Edition, Issue No. 8, August 1994, p. 12.
A sample program that reads disk directories illustrates techniques for writing relocatable machine-language programs. Includes source code.
Machine Language: Counting Up/Down: Compute!'s Gazette Disk Edition, Issue No. 9, September 1994, p. 13.
Comparing looping methods and the relative merits of incrementing or decrementing index registers. Includes source code.
Machine Language: Strings and Structures: Compute!'s Gazette Disk Edition, Issue No. 10, October 1994, p. 7.
Butterfield illustrates a structure (similar to 'struct' in C) in machine language composed of fixed-length records. Includes commented source code.
Machine Language: The MLM and Testing: Compute!'s Gazette Disk Edition, Issue No. 11, November 1994, p. 8.
Topics: working with a machine-language monitor, setting break points, and testing short code snippets. Includes source code.
Machine Langauge: Simple String Sort: Compute!'s Gazette Disk Edition, Issue No. 12, December 1994, p. 7.
A simple bubble sort of fixed-length strings in machine language. Source code for the 128 version is on disk.
Bad File Names: Commodore World, Issue #4, 1994, p. 25.
Dealing with improperly closed files ("splat" files) and files saved with null file names ("comma" files).
Peripheral Vision: Understanding the Input/Output System: Commodore World, Issue #5, 1994, p. 49.
Topics: the I/O stream; logical files; BASIC commands CMD, PRINT#, INPUT#, and GET#; methods for formatting data.
Machine Language: Flags and Branches: Compute!'s Gazette Disk Edition, Issue No. 13, January 1995, p. 10.
The interaction of the 6502 processor flags with the branch instructions. Includes source code examples.
Machine Language: Lunar Landing: Compute!'s Gazette Disk Edition, Issue No. 14, February 1995, p. 9.
Calculations in machine language for a "Lunar Lander" game. Includes source code on disk.
Software in Review: Karma: Commodore World, Issue #9, August 1995, p. 30.
Review of Karma V1 by Brett J. Table from PHD Software Systems.
Peripheral Vision: Relative File Programming: Part Two: Commodore World, Issue #9, August 1995, p. 48.
Detailed follow-up to Peripheral Vision (Commodore World, Issue #8, 1995, p. 47). Butterfield lays out 13 "rules" for working with RELative disk files.
Getting Ready for Machine Language: Commodore World, Issue #10, October 1995, p. 16.
Things to think about before starting to learn machine language. Similar to Butterfield's introductory remarks in Machine Language for the Commodore 64, 128, and Other Commodore Computers, but much more detailed.
A Beginner's Guide to Machine Language Elements: Commodore World, Issue #10, October 1995, p. 18.
Topics: registers, instruction set, and addressing mode. Includes a detailed 6502 instruction set reference chart.
A Machine Language Program for Beginners: Commodore World, Issue #10, October 1995, p. 22.
A simple assembly-language program illustrates assembler conventions, Kernal routines CHRGET and CHROUT, loops, and branching. Includes source code.
Peripheral Vision: Serial Bus Basics: Commodore World, Issue #10, October 1995, p. 48.
Serial I/O and the LISTEN-TALK-UNLISTEN cycle.
Peripheral Vision: Much Ado About NULL: Commodore World, Issue #11, November 1995, p. 50.
The problem with reading NULL characters from a data stream and some advice for dealing with NULLs. Includes example program fragments in BASIC and machine language (with source code).
Assembly Line: First Registers, First Debugging: Commodore World, Issue #11, November 1995, p. 52.
Topics: using a machine-language monitor to enter assembly-language instructions, running a program, testing, reading the status register, and debugging with BRK. Includes source code.
Peripheral Vision: The Direct Approach to Relatives: Commodore World, Issue #8, 1995, p. 47.
Programming RELative files. Illustration of side-sectors with diagrams.
Peripheral Vision: Making it Neat: Simple Tips on Better-Looking Output: Commodore World, Issue #6, 1995, p. 50.
Formatting strings and numbers for displaying on screen, printing, and writing to files.
Peripheral Vision: Disk Commands and the Wedge: Commodore World, Issue #7, 1995, p. 50.
General information about how DOS wedges work and typical wedge commands, and their BASIC equivalents.
Mastering the DON'T-DO-IT Key: Commodore World, Issue #12, January 1996, p. 37.
The behaviour of SHIFT-RETURN in the screen editor.
Peripheral Vision: Devices 0 and 3: Commodore World, Issue #12, January 1996, p. 50.
Working with device 0 (the keyboard) and device 3 (the screen). (The magazine's article description is the result of a printing error. It appears to belong to Peripheral Vision: Much Ado About NULL by Jim Butterfield, Commodore World, November 1995, p. 50.)
Assembly Line: Commodore World, Issue #12, January 1996, p. 52.
Topics: registers, looping, Kernal CHROUT routine, and working with a machine-language monitor. Includes source code. (The magazine's article description is the result of a printing error. It appears to belong to Assembly Line: First Registers, First Debugging by Jim Butterfield, Commodore World, November 1995, p. 52.)
Peripheral Vision: The Cassette Connection: Commodore World, Issue #13, February 1996, p. 50.
A deep look at the hardware of the cassette port edge connector.
Assembly Line: Organization and Input: Commodore World, Issue #13, February 1996, p. 52.
Organizing a machine-language program into sections for code, constants, and variables. Includes a small routine for taking input from the keyboard with source code.
Peripheral Vision: Joystick, Paddle, and Mouse: Commodore World, Issue #14, April 1996, p. 48.
Reading input devices through the joystick ports in BASIC, with code examples.
Assembly Line: Input and a Little Arithmetic: Commodore World, Issue #14, April 1996, p. 52.
Getting user input from the screen by calling the Kernal INPUT subroutine. Includes source code.
Assembly Line: Review and Practice: Commodore World, Issue #15, May 1996, p. 40.
Topics: non-printing characters, control codes, and lookup tables. Includes source code.
Peripheral Vision: INPUT# Versus the String Thing: Commodore World, Issue #15, May 1996, p. 42.
Explanation of String Thing, a routine for reading string data from a file that is more reliable than BASIC's INPUT# or GET#.
Assembly Line: Processor Status Register Flags: Commodore World, Issue #16, August 1996, p. 44.
Topics: flags and branching, status register and the stack, and opcodes that affect flags. A short example program spools data from a disk file to a printer. Includes source code.
Peripheral Vision: The Peripheral Bus: Commodore World, Issue #16, August 1996, p. 46.
Pin configurations of the IEEE-488 parallel bus and Commodore serial bus, and the interactions of the bus with BASIC I/O commands.
Assembly Line: Numbers and Arithmetic: Commodore World, Issue #18, December 1996, p. 38.
Explores the relationships among PETSCII, binary, and BCD representations of digits when taking input or performing addition. Includes source code.
Peripheral Vision: Keyboard Tipping: Commodore World, Issue #18, December 1996, p. 42.
A "listicle": 33 facts about the keyboard. Topics: hardware configuration, the keyboard matrix, using Kernal routines to read the keyboard, the keyboard buffer, interrupts, and cleaning.

Compiled by Dr. Myles L. Skinner, “curator” of the Commodore 8-Bit Magazine Index.