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 216 articles in the index; this list is incomplete.

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.
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.
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.
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.
Machine Language Tools: Compute!, Issue 4, Volume 2, No. 3, May 1980, p. 57.
Introductory article about machine language resources, monitors, and assemblers.
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).
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).
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.
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.
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.
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.
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 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.
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.
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.
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.
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.
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.
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.
Basically Useful BASIC: Financial Fuzzies: Compute!, Issue 8, Volume 3, No. 1, January 1981, p. 22.
Correcting floating-point rounding errors in BASIC.
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.
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.
Butterfield Box: The Lazy Programmer: The TORPET, Issue #7, October 1981, p. 6.
Article about the virtue of "laziness" in programming.
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).
PET 4.0 ROM Routines: Commodore Microcomputers, Volume 2, No. 4, October 1981, p. 66.
A memory map of the BASIC 4.0 machines.
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 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.
Butterfield Box: Compiler Comments: The TORPET, Issue #9, April 1982, p. 15.
Comments about compilers and challenges with compiling BASIC.
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.
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 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: Comments on the Commodore 64 Memory Maps: Commodore Microcomputers, Volume 3, No. 5, October/November 1982, p. 81.
Preliminary memory maps for the 64.
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.
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.
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 on Computers for TVOntario (TVO).
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: Poor Man's Petunia: The TORPET, Issue #19, May 1983, p. 10.
Schematics for building a "poor man's" digital-to-analog converter.
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: 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: 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 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: 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: 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.
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.
Versatile Mortgage Calculator: TPUG Magazine, Issue #12, March 1985, p. 29.
Mortgage calculator with flexible payment schedule written in BASIC.
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.
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.
Inside Inner Space: TPUG Magazine, Issue #15, June 1985, p. 16.
A review of The Complete Commodore Inner Space Anthology (Transactor Publishing, 1985).
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.
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 – Keywords and Tokens: The Transactor, Volume 6, No. 3, November 1985, p. 32.
BASIC keywords and tokens in BASIC 7.0.
Commodore 128: New Things: TPUG Magazine, Issue #18, November 1985, p. 16.
New features that differentiate the 128 from the 64.
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.
Commodore 128 Memory Maps: Important Locations: The Transactor, Volume 6, No. 5, March 1986, p. 27.
A partial memory map of the 128.
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.
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).
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.
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.
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 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.
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.
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.
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.
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.
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.
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.
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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: Wordcount: Compute!'s Gazette Disk Edition, Issue No. 6, June 1994, p. 7.
A simple word-count program in machine language. 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.
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.
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.
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.
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.
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: 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: 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: The Cassette Connection: Commodore World, Issue #13, February 1996, p. 50.
A deep look at the hardware of the cassette port edge connector.
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#.
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: 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.
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.

Dr. Myles L. Skinner is the “curator” of the CBM 8-Bit Magazine Index.