MakerLisp: Embedded Lisp Machine

Text APPLESOFT BASIC source code -- It's only 201 lines! Beautiful!:

http://apple.rscott.org/tools/view.htm?crc=e7d8e947136190aa&...

    60000  HOME : PRINT "MICROLISP/16-JUN-78": PRINT "COPYRIGHT 1978 APPLE COMPUTER INC"
    60010  PRINT "IT WILL TAKE APPROXIMATELY 1.5 MINUTES"
    60027  PRINT "TO INITIALIZE THE ARRAYS."

http://apple.rscott.org/tools/dldsk.htm?crc=e7d8e947136190aa

HN discussion of 6502 Language Implementation Approaches (dwheeler.com):

https://news.ycombinator.com/item?id=18376842

https://dwheeler.com/6502/

Documentation from Apple Software Bank Volume 3-5:

https://archive.org/details/Apple_Software_Bank_Vol_3-5/page...

Program Name: MICROLISP

Volume Number: 3

Software Bank Number: 00398

Submitted By: 0le Anderson

Program Language: APPLESOFT II

Minimum Memory Size: 32K Bytes

The following discussion assumes the user is already familiar with the principles and technical vocabulary of the LISP language.. The user should consider this document more as reference material on how MICROLISP differs from other versions of LISP, and what features it implements. A good reference for learning LISP is Weissman's LISP 1.5 Primer (see Bibliography). We also can recommend Friedman's The Little LISPer as an enjoyable introduction.

MICROLISP is a cassette-based microprocessor implementation of an interpreter for LISP, a programming language useful for symbol processing. The MICROLISP interpreter is written in APPLESOFT II BASIC. More complete documentation will soon be available when Hayden Press publishes a book on Microlisp by Ole Anderson. This book will include an annotated source listing of the interpreter, an explanation of its theory of operation, a detailed reference manual, an application section describing how to do graphics from MICROLISP using BASIC, a short LISP primer for the inexperienced user, and a bibliography of LISP literature useful to the MICROLISP user.

Many programming languages (BASIC for example) have been created to deal primarily with numerical data, and programs written in those languages can solve a large range of problems. But there is an equally interesting area of programming that deals with symbolic data.

If you want to be "in" with the artificial intelligence crowd, you might consider learning a symbolic manipulation language. Symbolic data might be chess positions, equations (treated as equations, not as expressions to be evaluated), or natural-language sentences. LISP is a language for list processing (hence the name: LISt Processor). Lists are the data items of LISP, just as numbers are the data items in BASIC. Because list elements are symbols not restricted to numbers, LISP makes it possible to solve many types of symbolic manipulation problems as easily as simple numeric problems are solved in BASIC. LISP is used primarily for artificial intelligence applications such as processing natural-language input, performing symbolic differentiation and integration of numerical formulas, and proving mathematical theorems. MICROLISP is a version of LISP that will allow you to learn the elements of LISP by writing and executing LISP programs.

BASIC goes a long way toward making the power of the personal computer available to the average person, but it lacks several critical features found in many other high-level languages: naming of subroutines and calling them with parameters, use of variable names with more than the first two characters significant, recursive subroutines and dynamic allocation of variables. These features are all found in MICROLISP.

Implementing MICROLISP in BASIC means that LISP programs do not execute very rapidly. However, it makes it possible to see how the language has been implemented. On the other hand, APPLESOFT II supports real (floating point) arithmetic, string functions and trigonometric functions, and these are all available to the MICROLISP user (often they are not available in larger versions). Another convenient feature in APPLESOFT II is the ability to PEEK and POKE memory locations, and to CALL machine-language routines from BASIC. This is often useful for interfacing special hardware and for applications where speed is critical. Another reason MICROLISP was written in BASIC is for tutorial purposes.

Many personal computer users desire to learn about the techniques involved in implementing high-level computer languages. This program is an example of a complete language processor which accepts characters typed from the keyboard, builds symbols from them, and processes these symbols according to the syntax of the LISP language. Thus, it uses many of the important algorithms employed by all other interpreters, compilers and language processors. MICROLISP can also be used as an educational tool for introducing elementary list-processing concepts.

What happened was that the DOS flash image got corrupted somehow, so Noko implemented missing bits in his lisp implementation and made the phone boot directly into it. Since all the software he used was written in his Lisp, there was not much of a difference in usability :-)

It’s what’s called a 40% layout (as in 40% of the keys of a standard 104 key board). To save space it doesn’t have a number row, you have to use a fn key to type numbers.

It’s not ortholinear, as another poster claimed. See the Planck keyboard for an example of that.

(PS If you’re the type of person who can fall down a rabbit hole for a subject with lots of lore to learn and that allows infinite customization, you should probably avoid the world of custom mechanical keyboards ;)

It's a neat processor.