Picture of author.

Nat Wadsworth (–1998)

Autor(a) de Z80 software gourmet guide & cookbook

5 Works 18 Membros 4 Reviews

Obras de Nat Wadsworth

Etiquetado

Conhecimento Comum

Data de nascimento
c. 1943
Data de falecimento
1998-11-25
Sexo
male
Nacionalidade
USA
Ocupação
electrical engineer
Organizações
SCELBI

Membros

Resenhas

I thought this book might be an interesting look into old computer technology, or give some details on 8-bit computer architecture, both topics of which interest me. This book does not talk about either of those things. This book discusses the very basics of computation and how a CPU works, intended for laypeople to better understand the personal computers (before they were called that) of the late 1970s.

Anybody interested in modern computing is going to want to reference a more modern book, and anybody interested in 1970s or 8-bit computer architecture is going to want to reference a more technical book (such as Digital Computer Electronics: An Introduction to Microcomputers).… (mais)
½
 
Marcado
lemontwist | 1 outra resenha | Feb 6, 2022 |
This book is a great introduction to the way things were in 1977. Nat Wadsworth is credited with building the first commercially available personal computer in 1974, the SCELBI-8H personal computer with an Intel 8008 CPU.

Wadsworth understood microcomputers even when the only way to program them was in machine language. He was a machine language programmer par excellence. Numerical input was accomplished by a row of front panel switches. Numerical output was sent to a row of red LEDs.

Four years after creating the primitive SCELBI-8H personal computer, Wadsworth could write about advancements, such as, keyboards and video displays for I/O and a higher level language (BASIC) for programming. Three decades later, the fundamental concepts that Wadsworth writes about in this book have not changed.
… (mais)
 
Marcado
MrJack | 1 outra resenha | Nov 4, 2008 |
This handbook by Nat Wadsworth provides machine language and assembly language programmers with Z80 mnemonic codes, their accompanying machine codes, and corresponding usage instructions -- information that is needed for reference while writing programs in a low-level language that will run at peak efficiency on computers built with a Z80 CPU.

This is a one-chapter book with one appendix. There is no table of contents and no index. Nevertheless, it is a handy reference for Z80 programmers, deserving of a 5-star rating.

The appendix tabulates the entire instruction set (N=700) of the Z80 CPU. It is organized alphabetically by the industry standard Z80 mnemonic code for each instruction. The machine code for each mnemonic is given both in octal and in hexadecimal notation. The number of CPU clock cycles required to execute each instruction is also given, an important consideration for programmers who wish to write efficient code or to optimize existing code. The book does not need a traditional index because each mnemonic in the appendix is matched with a page number that points the reader to the place in the book where full text instructions about the mnemonic can be found.

Wadsworth organizes the main text of his book categorically, not alphabetically. The sectional headings that follow will, perhaps, serve as a substitute for the book's missing table of contents.

§1. Load and Data Transfer Instructions, pp. 9-24.

§2. Stack Instructions, pp. 25-29.

§3. Multiple Operation Transfer Instructions, pp. 29-32.

§4. Increment and Decrement Instruction Group, pp. 32-37.

§5. Arithmetic Instructions, pp. 37-42.

§6. Double-Precision Arithmetic Instructions, pp. 42-45.

§7. Logical Instructions with the Accumulator, pp. 45-50.

§8. Instructions for Rotating the Contents of a Register, pp. 50-61.

§9. Instructions for Shifting the Contents of a Register, pp. 61-65.

§10. Bit Manipulating Instructions, pp. 65-75.

§11. Data Search/Compare Instructions, pp. 75-78.

§12. Special Purpose Instructions, pp. 78-83.

§13. Input Instructions, pp. 83-86.

§14. Output Instructions, pp. 86-89.

§15. Jump Instructions, pp. 89-94.

§16. Subroutine Calling Instructions, pp. 94-98.

§17. Information on Instruction Execution Times, p. 98.

The Z80 is an 8-bit microprocessor chip designed and sold by Zilog from July 1976 onwards.

The Z80 was designed to be binary compatible with the Intel 8080. This meant that 8080 code, such as, the CP/M operating system, would run unmodified on the Z80.

The Z80 offers many improvements over the 8080:

• An enhanced instruction set
• Two new index registers and instructions for them
• Two Interrupt modes
• Two separate register files
• Less hardware required for power supply, clock generation, and memory I/O
• A single 5 Volt power supply (the 8080 needed three: -5V, +5V, and +12V)
• A single-phase clock (the 8080 needed a two-phase clock)
• A built-in DRAM refresh mechanism
• Non-multiplexed buses (the 8080 had state-signals multiplexed onto the data bus)
• A much lower price

The major key to the success of the Z80 was probably the built-in DRAM refresh, which allowed systems to be built with fewer support chips.

The Z80 quickly took the market away from the 8080 and became the most popular 8-bit CPU.

The Z80 dominated the 8-bit microcomputer market from the late 1970s to the mid-1980s.

The Z80 was the CPU in my TRS-80 Model I Micro Computer.

For more help in assembly language programming for the Z80, see: Z80 Software Gourmet Guide & Cookbook by Nat Wadsworth (1979).

About the Author, Nat Wadsworth

In 1974, SCELBI ("SCientific, ELectronic, and BIological") Computer Consulting began selling what some say was the first personal computer, the SCELBI-8H personal computer with an Intel 8008 CPU. It was designed by Nat Wadsworth and Robert Findley. In 1975, the SCELBI-8B business computer was introduced, also designed by Nat Wadsworth and Robert Findley.

Wadsworth was a machine language programmer. His primitive microcomputers were programmable in machine language via a row of front panel switches. See: Nat Wadsworth, Machine Language Programming for the 8008 and Similar Microcomputers, SCELBI Computer Consulting, (Milford, CT) 1973.

About Generational Programming Languages

First Generation Language (1GL): Machine Language.

Machine language is the lowest-level language for programming a computer. It can be likened to a CPU's "native tongue."

No translator is used to compile or assemble the instructions which are entered as binary 1s and 0s directly into the registers of the CPU through front panel switches on a computer system.

Machine language programming on modern personal computers can be done at the keyboard using DEBUG without the aid front panel switches. DEBUG can act as an assembler, disassembler, or hex dump program allowing users to interactively examine memory contents, make changes, and selectively execute COM, EXE and other file types. It also has several sub-commands which can be used to access specific disk sectors, I/O ports, and memory addresses.

The main benefit of programming in a first-generation programming language is that the code a user writes can run very fast and efficiently because of its direct execution by the CPU.

As might be expected, since machine language is the only language a computer knows, all higher level programming languages must be interpreted or compiled into a computer's native tongue (machine language) before a program will run.

Obstacles to Programming in Machine Language

Machine language is more difficult to learn than higher level programming languages.

It is far more difficult to debug and edit machine language when you make an entry error or a logical error in programming.

If additional instructions need to be slipped into memory at some location, then all the instructions after the insertion point have to be moved down to make room in memory for the new instructions. Doing this on a front panel with switches can be very difficult.

Program portability is nonexistent. Before code can be transferred to a computer made by a different manufacturer, it must be completely rewritten because the machine language for one computer brand is different from another.

Second Generation Language (2GL): Assembly Language

Assembly language is a low-level programming language in close proximity to machine language.

The use of symbolic names (mnemonics) for memory locations and machine instructions is the chief human benefit of writing programs in assembly language. This feature is especially appreciated by assembly language programmers when their code requires modification. It saves the assembly language programmer from having to do table look-ups, make tedious calculations and manual address update entries that plague the machine language programmer.

Another big advantage of assembly language code is that it can be written by a programmer sitting in front of an ordinary keyboard -- no more front panel switches to toggle.

Before an assembly language program will run on a computer, it must be converted to machine readable form by a process called "assembly." This is where virtual switch toggling takes place to create a machine language program. A compiler (assembler) is used to translate the assembly code into machine code that the CPU understands.

2GL languages are frequently used for writing the kernels of higher level languages and for writing device drivers.

Assembly language is also used to address critical performance issues in computer games and other programs that make intensive use of graphics and animation.

Real-time applications, such as software written for automobile and aircraft computers, are also beneficiaries of programs written in assembly language.

A programmer who knows how to write a program in assembly language usually knows how to read the output from a disassembler, a reverse-engineering tool that translates machine code into assembly language that can be used for debugging bad code. You can examine any machine language code in this way, whether the code was generated by a 2GL assembler or by a 3GL or 4GL higher level programming language. A disassembler is essential for optimizing code for greater efficiency.

Third Generation Language (3GL): Higher Level Languages.

3GL languages are higher level languages that were designed with human reading and writing skills in mind.

Most programming languages developed since the 1950s are 3GLs. COBOL, FORTRAN, BASIC, Pascal, C, C++, Perl, and Java are examples of 3GL programming languages.

Computers do exactly what they are told to do. As a result, they cannot handle ambiguities in expression the way humans do. Nevertheless, 3GL programs are one step closer to natural language and one more step of abstraction farther away from machine language.

Procedural 3GL languages use a syntax akin to natural language using words, numbers, and punctuation from a natural language, such as, English. Of course, they follow a much stricter grammar than the natural language they're derived from.

One of the best features of modern 3GLs is their support for structured programming, a major programming paradigm that is famous for reducing reliance on the GOTO statement.

According to Donald Knuth, structured programming means that it should be possible to draw a program's flow chart with all forward branches on the left, all backward branches on the right, and no branches crossing each other -- no more spaghetti code.

Fourth Generation Language (4GL): Advanced Special Application Languages.

4GLs made their appearance in the 1970s. These languages represent the next level of abstraction in computer programming.

The term 4GL was ushered into the world by James Martin in his 1982 book Applications Development Without Programmers. He used 4GL to refer to non-procedural, high-level specification languages.

DataFlex, Panther, PowerBuilder, SQL, FOCUS, Forth, Infomix-4GL, MATLAB, SAS, SPSS, and RPG-II are examples of 4GLs.

Certain kinds of applications can be developed more rapidly in a 4GL because a single instruction can generate the equivalent of a complicated block of 3GL instructions with fewer errors.

A 4GL is defined as a language that supports 12-20 FP/SM. Don't know what that means? Neither do I.

The fourth generation language that I use most frequently is ASQ (Administrative Systems Query) on my institution's minicomputer. ASQ is a database query language, somewhat like SQL. A one-line, English-like sentence in ASQ will do the work of several 3GL programs (SORT, PRINT, POINTER, SAVE, RECALL, and XTAB).

Fifth Generation Language (5GL): Artificial Intelligence.

The next level of removal from dependence on machine language programming brings us into the realm of artificial intelligence, a quantum leap in abstraction.

A 5GL programmer focuses on a problem to be solved without worrying about writing an algorithm to solve it. Let the programming language figure it out!

5GL programming is sometimes referred to as constraint logic programming or declarative programming. For example, a programmer gives logical constraints to a 5GL program and the Fifth Generation Language makes the computer write a program that solves the problem.

LISP, Prolog, OPS5, and Mercury are examples of 5GLs.

5GLs never lived up to their promise and hype. They have not sustained any admiration or acceptance outside of academic circles.

Critique of the Generational Concept of Programming Languages

Will there ever be a 6GL or a 7GL? Not likely. So far, I agree with those who say there is not even a 5GL. Artificial Intelligence? Give me a break!

The idea of GLs is that each is an abstraction of the former. We start at the bottom with machine language, move up a level to assembler, then up to C++, Java, and the like, and finally up to advanced business and scientific application languages.

The truth is, programmers have not really succeeded at achieving a higher level of abstraction than 4GL. 5GL is all carnival ballyhoo and hoopla -- an illusion.

Think of it this way: 1GL = data, 2GL = metadata (data about data), 3GL = meta-metadata (data about data about data), 4GL = meta-meta-metadata (data about data about data about data). You can't get much more abstract than this and maintain your sanity!

5GL brings us to Artificial Intelligence where it is supposedly impossible to tell the difference between computer intelligence and human intelligence. Alas, no computer has yet been able to pass the Turing Test, a really simple test that is used to judge whether a computer is intelligent or not.

6GL would bring us to Natural Intelligence where the machine practically becomes human, like Lt. Commander Data, the sentient android on Startrek, the Next Generation.

7GL brings us to the computer as God. "In the the not-too-distant future, computers will become more intelligent than human beings, and eventually achieve god-like powers." --Ken Korczak, Columnist. No way, says I! This is the stuff of science fiction, not down to earth science and technology.

As for me, 3GL and a little bit of 4GL are Good Enough. If I were ever to move away from 3GL and 4GL, it would be in the direction of 2GL, not 5GL.
… (mais)
 
Marcado
MrJack | Oct 31, 2008 |
Wadsworth begins with the Z80 instruction set, then procedes to discuss utility routines, stack operations, input/output processing, conversion routines, search and sort routines, decimal arithmetic routines, floating point routines, and space capture. His final chapter deals with creative programming concepts. An appendix consists of a table presenting the entire instruction set of the Z80 CPU.
 
Marcado
MrJack | Sep 26, 2008 |

Estatísticas

Obras
5
Membros
18
Popularidade
#630,789
Avaliação
4.1
Resenhas
4
ISBNs
3