Robert Elton Maas, Mountain View, CA
Telephone: 650-969-2958 Internet: ยทยทยท@shell.netmagic.net
Employment objective: Any computer software development using LISP,
preferably Common LISP, especially Macintosh Allegro Common LISP. Or
any computer software development using any programming language, where
my 14 years LISP experience (21 years total programming experience) can
be re-applied.
I started programming in LISP in 1973 using Stanford LISP 1.6, then
switched to UCI (University of California - Irvine) LISP, then switched
to MacLISP when I obtained ARPANET remote access in the late 1970's.
MacLISP was my LISP of choice until I lost dialup access into the
ARPA-Internet in the early 1980's. Meanwhile I found employment at
Stanford in 1980 helping port CAI software from Algol to PSL (Portable
Standard LISP) on Tenex and later on VM/CMS. That employment ended 1991
August. Meanwhile I purchased a Macintosh Plus in 1990 January and
started using MACL (Macintosh Allegro Common LISP) shortly after.
During those years I've used the various implementations of LISP as a
general purpose programming language. Below is a summary of some of
applications I've written myself using UCI-LISP MacLISP PSL or MACL, or
helped develop as part of a team using PSL.
** Major LISP projects for pay where I worked with other people:
Multi-year project to implement CAI (Computer-Assisted Instruction) for
Calculus: I conceived & prototyped EQD (EQuational Derivation system)
and designed & implemented several other modules and helped with
others, and tested the program and some curriculum. Some individual
modules I developed are listed individually later.
English language interface for an instructable robot (A.I. research): I
did research & programming under supervision of Patrick J. Suppes.
Convert symbolic-logic CAI program from Algol to SL (Standard LISP)
Port PSL system from Tenex to IBM mainframe running VM/CMS
** LISP-productivity utilities I wrote:
Show the user where LISP source syntax is bad or where duplicated
function definition occurs.
Cross-reference of function definitions and calls in many files.
Build index of which functions are defined in which files and allow the
user to ask which files contain a given function or any of a given list
of functions.
Correlate number of arguments to functions in various files, alerting
the user whenever the number of arguments doesn't match, building a
database of correct argument-numbers to compare against.
Destructuring LET and LET* macros in PSL to emulate the ones in MacLISP.
Conversion of source files between RLISP and s-expression format.
Bounded explode and printing of s-expressions to fit limited space,
with larger expressions getting printed with "...".
Prettyprinter using backtracking ("dynamic programming") to find the
optimal indentation method for a given size print area.
Saving data areas of a PSL core image on VM/CMS for later restoration.
Interface from PSL to FORTRAN code on VM/CMS.
Interface from PSL to Unified Graphics System that checks arguments for
errors to avoid FORTRAN code causing an ABEND on seeing garbage data.
Single-stepper for debugging LISP code.
** Code I wrote to interface LISP to system-level utilities:
Random-access (read-write) mode I/O in MacLISP using system calls.
Interfacing to system utilities in MacLISP and on Macintosh.
Fixes to bugs in PSL kernel on VM/CMS, and adaption to run under
extended addressing.
Interfacing to magnetic tape drives on Tenex using system calls.
Time and date file last written (using system calls for Tenex and
VM/CMS), and automatically updating only the files whose prerequisites
have changed based on comparing dates written.
Create s-expression representing heiararchy of Macintosh folders on
hard disk and diskettes and the files they contain, update the
directory incrementally when individual diskettes are modified, invert
the directory to yield an index by name of file, automatically perform
various maintenance actions such as flagging files that have too many
versions and deleting selected old versions of files, correlating the
inverted index with an annotated description of all my archived files.
Interfacing to Macintosh resource manager such as detecting and
removing the WDEF virus automatically while compiling indexes of
diskettes.
** Low-level LISP utilities I wrote:
Two-step hashing whereby the result of the first step is a fullword
integer which nearly uniquely identifies the key and allows very fast
searching of hash tables or binary trees.
Utilities for storage allocation of virtual strings composed of
multiple pieces whose total size cannot be estimated a priori, used for
sort/merge and for filling in templates for batch job scripts.
Utilities for building tree structures such as balanced binary trees
and heapsort, used for sort/merge and hashed databases.
Sort/merge systems for large files of arbitrary-length delimited strings.
Derived input stream where text is broken into words and case is
normalized, for use in word-based data compression or information
retrieval applications.
Generating pseudo-random numbers, generating pseudo-random primes
within a desired range, generating a pseudo-random pair of primes whose
product is within a given range and then using them to generate a pair
of corresponding exponents modulo a particular product of primes
thereby generating a Rivest code (public-key cryptosystem), fast
modular exponentiation for Rivest codes.
Recursive BNF-driven type-checking of data at runtime.
Interval arithmetic.
Collect titles of sections in segmented archive files and compile
indexes of the archives. Extract sections by keyword from archive into
single-section temporary files.
** Mathematical tools I wrote in LISP:
Multiply mathematical permutations. Decision procedure as to whether a
given permutation is generated by a given set of permutations.
Counting the number of paths through a graph by backtracking, counting
the number of ways various size chessboards can be bisected along the
lines into symmetric pieces.
Cellular automata similar to Conway's "Life".
Given mathematical expressions in REDUCE internal representation
(similar to LISP executable form, externally as s-expressions i.e.
Polish notation with parentheses), compute the sizes of the various
sub-expressions recursively and lay them out on a fixed-pitch character
display in nice two-dimensional format similar to Macsyma.
Research on unsolved 3n+1 (Collatz) problem.
Graphical demonstration of Newton's method and other zero-finding
methods.
Compute the "Maas function" I invented about 1956 (in 6th grade),
related to continued fractions and fractals I found out later.
Convert nested mathematical expressions into more flattened canonical
form such as expanding sums of sums into single sums.
New ways to graph mathematical functions that are guaranteed to fill in
all detail, rather than dishonestly taking shortcuts or smoothing.
Modifying the innerds of REDUCE to avoid automatic rearrangement of
mathematical sub-expressions into alphabetical order.
Interactive tool for locating&marking sub-expressions in math
expression, with simple motion commands (left right deeper shallower),
and marking&splitting at arbitrary places within long sums and
products. Used to limit effect of distributive law and Calculus rules
to split only where desired.
Recursive method on derivatives of polynomials to find zeroes extrema
and other interesting points. Higher-level methods based on that method
for conic sections, quotients of polynomials, and trigonometric
functions of polynomials. Using this information to find the optimal
domain and range for drawing a graph that shows most of the interesting
behaviour nicely spread around the screen, and for splitting the domain
into pieces to avoid singularities.
Drawing parametric graphs, emulation of graphs on character-display for
use when debugging higher-level code from home.
** Major personal research I did in LISP to develop new applications:
Several different programs to experiment with different data
compression algorithms, most of them based on nested splitting of
intervals.
Research&demo of proximity-hashing clustering and net-relaxation to
yield an efficient nearest-match information-retrieval system.
Research into generalizations of the golden-ratio optimal-filling
algorithm for more than one dimension.
Tree-structured and keyword-based information organization&retrieval.
** Telecommunications utilities I wrote in LISP:
Terminal emulation, such as random cursor location and automatic
setting of optimal tab stops on Beehive 3A.
Translate between various cross-assembler syntaxes.
Interfacing to remote processes via TELNET or PTY to perform common
tasks automatically such as Datacomputer access or electronic mail or
file transfer.
8-bit I/O in MacLISP using system calls.
Several programs for PCNET communication protocol using various
programming methodologies (co-routines, subroutines, interrupt-driven).
These include answer mode, originate mode over the network to another
machine or via dialout, and test mode with canned scripts. Also
emulation of 8-bit I/O in 7-bit stream to debug binary protocols over
non-binary network connection.
Downloading binary images to MOS 6502 and Intel 8080, including automatic
locations of multiple segments, error control, status display on
microcomputer-connected terminal.
Compiling graphs into 6502 machine programs for counting the number of
paths in them.
** LISP programs I wrote to play or analyse mathematical/board games:
Calculation of canonical representatives of equivalence classes of Nim
and Misere games (this work predates Conway's book). Games included are
Sprouts, pile Nim, urinary Nim, NimLine, domino Nim. The Sprouts
software uses an abstract vertices&edges representation of the
topological properties of the diagram, rather than trying to draw the
diagram as a picture. After training, my Sprouts program became an
expert up through 7 dots.
Go (Wei Chi), the national board game of Japan: Expert program on small
boards by a combination of a general program that makes good moves most
of the time especially towards the end, an exception list to provide a
canned move when the computed move isn't good enough to win, and
automatic recording of all lost games and training mode for updating
the move-correction table automatically. With first move, after it was
trained, this program became unbeatable on 5*5 and nearly unbeatable on
7*7. Also processing traditional Japanese picture diagrams of games.
Cylindrical checkers (better than usual game because draws are rare).
Hex, taking advantage of non-1:1 text aspect ratio on standard
terminals to emulate hexagonal grid.
** Miscellaneous utilities and applications I wrote in LISP:
Manipulating continued fractions and related representations by lazy
evaluation.
Convert from ASCII text with formfeeds into IBM carriage control for
purpose of interfacing to Computer-Output-Microfilm vendor. Compile
index of fiche batches to place in front of the batch (upper-left
corner of first fiche in each group).
Gleaning relevant data from batch job logs or from ASCII databases such
as my index of all my personal files. Correlating gleaned data with
other data such as directories of diskettes to detect missing or
undocumented files.
Convert from an old local IMSSS mathematical-document format called MSS
into Knuth's TeX format, in preparation for the demise of the only
remaining machine that could print MSS documents.
Organizing a database of over a thousand personal files being miagrated
from magnetic tape to Macintosh diskettes after the Tenex machine died,
being sure I had exactly one best version of each file and that no
files got lost during the conversion.
Checksumming files in a way that ignores variations in spacing or line
filling.
Comparing text files using first-match lookahead.
Resampling a black&white image to a smaller scale and applying
Floyd-Steinberg error-diffusion to render the smaller image in
black&white (on Macintosh).
Converting Macintosh MacPaint files to startupscreen format.
** Other (non LISP-related) work I've done, and other qualifications:
I programmed a lot using SAIL (a version of Algol 60) and assembly
languages on various CPUs (IBM 1620, IBM 360/370, DEC PDP-10, MOS 6502,
Intel 8080, 68000), plus Fortran, HyperTalk (the scripting language of
HyperCard), MacSyma, MainSail, C, Forth, and Cobol.
I have a Bachelor of Science degree (Mathematics major) from the
University of Santa Clara, plus some graduate studies at University of
Oregon. I was among the top five (in U.S.A.) in the William Lowell
Putnam undergraduate mathematics competition, and I passed the
California civil service exam for Programmer/Analyst I and the federal
exam for Writing & Public Info as well as the Mensa IQ test.
US citizen, currently seeking immediate employment.