Machine language for the Commodore 64, 128, and other Commodore computers (book review)

“Machine language for the Commodore 64, 128 and other Commodore computers” is a machine language course written by the world-famous computer guru Jim Butterfield. Mr. Butterfield was very active in the 80’s and early 90’s as a freelance technical writer. Most of his work deals with Commodore computers and you could find his articles on several magazines, including “Compute!”. Although Mr. Butterfield is no longer with us, he has never left us. In fact, what many Commodore users have learnt from him will never die.

Jim Butterfield was a pioneer of computer programming. He moved his first steps on big mainframes. Then, he started studying micros with the MOS / Commodore KIM-I, a 6502 based computer board with a numeric display and a little calculator style keyboard. He was one of the authors of the book “The first book of KIM-I”.

Then he moved on Commodore PET computers and, as soon as new Commodore models were released, he constantly provided his support by writing excellent technical articles that were very simple to understand, even when dealing with difficult topics.

His book on machine language actually reflects all of these qualities. It is very well written. You can find many information, but you will never end up dealing with very long explanations. Mr. Butterfield had the ability to achieve effective communication without having to use many words. He just knew how to put up sentences properly, in a simple yet catchy style.

 

 

The book is clearly focused at a general 6502 machine language understanding. So, you won’t find sophisticated programs written for a particular computer. But, if you are interested on a simple yet comprehensive introduction to 6502 machine language programming, then this book just suits your needs perfectly.

The book just puts you in front of a Commodore computer with a machine language monitor and gets you going in a short time. Many examples are provided, and you are forced to write programs since the beginning. Everything gets a clear explanation, so that you build up self-confidence.

The first chapter tells you about the architecture of a computer and the behavior of a microprocessor. No advanced technical concepts are introduced: you are given just what you need from a programmer’s perspective.

Chapter two deals with output controlling and tells you how to print characters on the screen by using the CHROUT KERNAL routine. Examples on the whole book are adapted so that they can run on several Commodore 8 bit computers.

Chapter three provides information on flags and logic. Many concepts are introduced and you are told the meaning of all the 6502 flags and how to make comparisons between numbers by using them. Logical operators are also explained. Not only you get information about the logic operations a 6502 processor is able to perform, but you also get programming tips on how to use them proficiently. The book doesn’t only show truth tables, it goes deep into the meaning of each operator and its practical use in programming.

Chapter four is just a masterpiece. It provides you with an excellent introduction on how computers work with numbers – both signed and unsigned. Signed numbers are introduced in a way that should be more than clear to all beginners.

Chapter five is another great chapter which tells you about 6502 addressing modes. Everything is just awesome. Each addressing mode is cleverly explained. You just get a crystal clear explanation on how to use a given addressing mode and what practical applications it can be useful for. Even the rare “indexed, indirect” addressing mode – which may be a little difficult to understand on some books – gets an extremely clear explanation.

Chapter six allows you to obtain information on how to use BASIC and machine language together. Making BASIC programs and ML ones live peacefully may be difficult sometimes, but Mr. Butterfield goes into a thorough explanation of BASIC pointers. That way, you get to know how BASIC programs use memory and you are able to put the machine language code on the right places in memory, so that no code gets corrupted.

Chapter seven introduces advanced topics. You get a clear explanation of the 6502 stack and how to use it. You get a clear understanding of how the RTS instruction works, and you are also told about a nice trick that allows you to use RTS for jumps.

This chapter then gets even more appealing, as it tells you about how to use interrupts and provides you with a simple introduction on how to add commands to BASIC.

Chapter 8 is the final chapter. After explaining timing and simple I/O, a review of the instructions learned so far is provided. Then some debugging tips are introduced. The Author then tells you about symbolic assemblers, as they are required for more advanced programming. Then, you get the award deserved for reading this masterpiece. You are told that with the concepts you have learned, you can go virtually anywhere in computer programming. And I strongly believe this is the truth.

There are many books dealing with 6502 programming. Still, I don’t think any book equals the masterpiece of Jim Butterfield. Actually, many books offer more topics and far more advanced programming examples, but no other book has the ability to provide such beautiful explanations like this one. This book focuses on machine language monitors, which is the best way to learn ML for the beginner. Furthermore, the book provides you with a large quantity of useful reference material, so that you can start your own projects with the computer.

The book clearly asks you to do coding – you are not only provided with examples to read. The best way to learn is by doing, and this is just what this book is all about. Jim Butterfield was well known for his sympathy for beginners, and this book once again demonstrates that. Please read it if you haven’t already, even if you can code ML. You’ll get an excellent 6502 reference, and a friendly, comprehensive tutorial as well.

 

Precedente Zooming a square with Commodore 64 BASIC - a simple 2D realtime zoomer using sprites Successivo Programming sprites on the Commodore 64, a simple tutorial using BASIC V2

Lascia un commento

*