From: ··········@YahooGroups.Com
Subject: 15 years LISP programming experience, available to work for you
Date:
Message-ID: <REM-2003aug07-004@Yahoo.Com>
Robert Elton Maas, Mountain View, CA
Telephone: 650-969-2958 Internet: ··········@YahooGroups.Com
Employment objective: Any computer software development using LISP,
preferably Common LISP, especially Macintosh Allegro Common LISP or
CMUCL. Or any computer software development using any programming
language, where my 15 years LISP experience (22 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 (Computer-Assisted Instruction)
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 (Computer-Assisted Instruction) 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 part-time employment.
From: lin8080
Subject: Re: 15 years LISP programming experience, available to work for you
Date:
Message-ID: <3F39929F.63F2D92A@freenet.de>
··········@YahooGroups.Com schrieb:
> Employment objective: Any computer software development using LISP,
> preferably Common LISP, especially Macintosh Allegro Common LISP or
> CMUCL. Or any computer software development using any programming
> language, where my 15 years LISP experience (22 years total programming
> experience) can be re-applied.
Well, happy birthday. This is what I found (:
.........................
Betreff:
Abuse
Datum:
Mon, 11 Aug 2003 20:17:47 +0200
Von:
"nic" <········@webmail.co.za>
Foren:
alt.comp.freeware.games
If you haven't tried this, do.
It was a commercial release and then was released as freeware
http://abuse2.com/frabs/
...........................
stefan
From: Joe Marshall
Subject: Re: 15 years LISP programming experience, available to work for you
Date:
Message-ID: <vft0cn15.fsf@ccs.neu.edu>
Allow me to offer some constructive criticism.
There is just too much detail you don't need. Pick the most important
sounding projects and forget the rest.
It appears that you have a 10 year gap in employment from 1991 to
present. You'll want to fill this in some way, even if it isn't lisp
related.
Put a `goal' at the top: `Seeking full-time position in the Bay Area
where I can use my skills as an experienced Lisp programmer.' You'll
never get calls for `part time', but you can certainly explain at an
interview that you are *not* available 40 hours a week.
There are places that can help you with your resume for free. Some
are better than others, but you can't argue with the price. If your
interview skills need help, there are places to go for them as well.
I think that with the proper editing you can get interviews (which is
the goal of a resume). Remember that better than 90% of the people
you send your resume to will simply toss it without reading it.
Therefore, to get a few responses you have to expect to send out
dozens of copies. Of those responses, many will be unacceptable, so
be prepared to send out a *lot* of resumes.
You may wish to create several versions of your resume, each focusing
on a different aspect of your skills. Choose the appropriate resume
for the appropriate employer.
I've re-arranged and cut things below. If you had presented this
version to me in 2000, I would have put it in the `call this guy'
pile. (The company I worked for went bankrupt, though.)
··········@YahooGroups.Com writes:
> Robert Elton Maas, Mountain View, CA
> Telephone: 650-969-2958 Internet: ··········@YahooGroups.Com
Languages: Lisp, C, Fortran, Forth, Cobol, HyperTalk, SAIL, and
assembly code on various CPUs (IBM 1620, IBM 360/370, DEC PDP-10,
MOS 6502, Intel 8080, 68000).
Systems: MacIntosh, PDP-10 (Tenex), ...etc...
> 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.
Cut the part between the slashes.
> MacLISP was my LISP of choice until I lost dialup access into the
> ARPA-Internet in the early 1980's.
Cut this line altogether.
> Meanwhile I found employment at Stanford in 1980 helping port CAI...
Rework this section. Put a little emphasis on spending 11 years with
one employer. Putting it in a `bulleted' format might help.
Employment
Standford University 1980 - 1991
Projects include:
> 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.
Cut this,
> Some individual modules I developed are listed individually later.
list 'em now:
> 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.
>
> Given mathematical expressions in REDUCE internal representation
> (s-expressions), 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.
Make this more politic:
> New ways to graph mathematical functions that are guaranteed to fill in
> all detail, rather than dishonestly taking shortcuts or smoothing.
`Developed new graphing techniques that avoid artifacts introduced
by smoothing and approximations.'
> English language interface for an instructable robot (A.I. research): I
> did research & programming under supervision of Patrick J. Suppes.
>
> Convert symbolic-logic CAI (Computer-Assisted Instruction) program from
> Algol to SL (Standard LISP)
>
> Port PSL system from Tenex to IBM mainframe running VM/CMS
Just highlight the major stuff.
Developed many productivity tools including:
> Prettyprinter using backtracking ("dynamic programming") to find the
> optimal indentation method for a given size print area.
>
> Conversion of source files between RLISP and s-expression format.
Cross-reference and indexing utility for multi-file programs.
> 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.
> Single-stepper for debugging LISP code.
Developed many system-level tools:
> 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.
>
> Fixes to bugs in PSL kernel on VM/CMS, and adaption to run under
> extended addressing.
>
> 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.
>
> Extracted relevant data from batch job logs or from ASCII
> databases. Correlating extracted information with directories to
> detect missing or undocumented files.
>
> 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.
>
> 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.
Other miscellaneous code:
> 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.
>
> 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. Fast modular exponentiation for
> Rivest codes.
>
> Interval arithmetic.
>
> Manipulating continued fractions and related representations by lazy
> evaluation.
>
> 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.
>
> ** 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.
Education
> 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.
Don't bother with these unless you want a government job.
> and I passed the California civil service exam for
> Programmer/Analyst I and the federal exam for Writing & Public Info
>
This will neither help in getting a job or getting laid:
> as well as the Mensa IQ test.
----
> US citizen, available immediately.
Joe Marshall quoted Robert Maas:
>> 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.
I'm curious. Urinary Nim? ("Unary" I might believe, though I'm
not sure what it would mean.)
You should probably be more specific than "Conway's book";
anyone who knows and cares enough to be impressed will want
to know that you know the difference between ONAG and "Winning
Ways" :-).
--
Gareth McCaughan
From: ··········@YahooGroups.Com
Subject: Re: 15 years LISP programming experience, available to work for you
Date:
Message-ID: <REM-2003aug17-001@Yahoo.Com>
{{Date: 15 Aug 2003 23:05:33 +0100
From: Gareth McCaughan <·····@g.local>
I'm curious. Urinary Nim?}}
In a men's restroom, with a long row of urinals, men would prefer not
to be immediately adjacent to another man. With that clue, given it's a
variation of Nim, I think you can deduce the rule-of-play, right?
Robert Maas wrote:
[I asked:]
>> I'm curious. Urinary Nim?}}
[Robert:]
> In a men's restroom, with a long row of urinals, men would prefer not
> to be immediately adjacent to another man. With that clue, given it's a
> variation of Nim, I think you can deduce the rule-of-play, right?
I think so. You can turn a pile of size N into two piles
of sizes p,q where p+q = N-3 provided p,q>0, or into
one pile of size N-3 or N-2? The Grundy numbers look
like they become periodic with period 34 after the
first 51 or so. (Given the first some-number-or-other
of values, this is easy to prove when it's true: by
induction, nothing new happens after a while :-).)
--
Gareth McCaughan
From: Robert Maas, see http://tinyurl.com/uh3t
Subject: Re: 15 years LISP programming experience, available to work for you
Date:
Message-ID: <REM-2005sep03-006@Yahoo.Com>
> http://groups.google.com/group/comp.lang.lisp/msg/3438dc4d46ddebe9
> From: Gareth McCaughan <····@g.local>
> > In a men's restroom, with a long row of urinals, men would prefer not
> > to be immediately adjacent to another man. With that clue, given it's a
> > variation of Nim, I think you can deduce the rule-of-play, right?
> I think so. You can turn a pile of size N into two piles
> of sizes p,q where p+q = N-3 provided p,q>0,
Yes, if you take a middle urinal you also hog the two adjacent urinals.
> or into one pile of size N-3 or N-2?
Yes, if you take either endmost urinal, you hog only one adjacent.
If you take next-to-end urinal, you hog two adjacent, one of which is
the last in that direction so there's no remaining sub-row in that
direction.
> The Grundy numbers ...
give the solution (via XOR of bits) only for the regular game (first
person with no legal move loses game), not the misere game (first
person with no legal move wins game). I was primarily concerned with
the misere game, since I regarded the regular game as trivial by
comparison. I defined equivalence classes modulo composition to yield
same winning status, then I tried to compute multiplication tables for
small numbers of sub-situations of different equivalence classes but to
arbitrary high exponents. I discovered that for several simple cases a
3-state (along each axis) table was sufficient: Zero, odd, and
nonzero-even exponent on that particular sub-game. But then I got busy
with paying work and didn't have time to finish my unpaid research, nor
to publish the paper I had already written, and then Conway came out
with his book which claimed to completely solve the problem, but the
notation in the book was so inscrutable that I couldn't figure out
whether he was even working on the same problem much less whether the
book presented a solution or not.