its

groups.google.com/g/comp.lang.lisp/c/MmtQreo3PCM Parenthetically Speaking with Kent Pitman: The Best Intentions: EQUAL Rights -- And Wrongs -- In Lisp: https://www.nhplace.com/kent/PS/EQUAL.html Kent M. Pitman Answers On Lisp And Much More: https://developers.slashdot.org/story/01/11/03/1726251/kent-... Kent M. Pitman's Second Wind: https://developers.slashdot.org/story/01/11/13/0420226/kent-... Tutorial on Good Lisp Programming Style: Peter Norvig, Sun Microsystems Labs Inc; Kent Pitman, Harlequin
Inc.: https://www.cs.umd.edu/~nau/cmsc421/norvig-lisp-style.pdf Notes from the ANSI standardisation process: https://stackoverflow.com/questions/72414053/notes-from-the-... Issue CLOS-CONDITIONS Writeup: https://www.lispworks.com/documentation/lw50/CLHS/Issues/iss... On Pitman's “Special forms in Lisp” (2011) (kazimirmajorinc.com): https://news.ycombinator.com/item?id=29947329 https://news.ycombinator.com/item?id=29954993 DonHopkins on Jan 16, 2022 | parent | next [–] Kent Pitman also wrote the "Revised Maclisp Manual (Saturday Evening Edition)" aka the "Pitmanual". https://en.wikipedia.org/wiki/David_A._Moon http://www.nhplace.com/kent/publications.html >In 1983, I finished the multi-year task of writing The Revised Maclisp Manual (Saturday Evening Edition), sometimes known as The Pitmanual, and published it as a Technical Report at MIT's Lab for Computer Science. In 2007, I finished dusting that document off and published it to the web as the Sunday Morning Edition. http://www.maclisp.info/pitmanual/ Not to be confused with David Moon who wrote the "MacLISP Reference Manual" aka the "Moonual", and who co-authored the "Lisp Machine Manual" with Richard Stallman and Daniel Weinreb, which had big bold lettering that ran around the spine and back of the cover, so it was known as the "LISP CHINE NUAL" (reading only letters on the front). https://news.ycombinator.com/item?id=15185827 https://hanshuebner.github.io/lmman/title.xml https://news.ycombinator.com/item?id=15186998 DonHopkins on Sept 6, 2017 | next [–] The cover of the Lisp Machine Manual had the title printed in all caps diagonally wrapped around the spine, so on the front you could only read "LISP CHINE NUAL". So the title was phonetically pronounced: "Lisp Sheen Nual". My friend Nick made a run of custom silkscreened orange LISP CHINE NUAL t-shirts (most places won't print around the side like that). https://www.facebook.com/photo.php?fbid=74206161754&l=54ec4e... I was wearing mine in Amsterdam at Dappermarkt on Queen's Day (when everyone's supposed to wear orange, so I didn't stand out), and some random hacker (who turned out to be a university grad student) came up to me at random and said he recognized my t-shirt! http://www.textfiles.com/hacking/hakdic.txt CHINE NUAL (sheen'yu-:l) noun. The reference manual for the Lisp Machine, a computer designed at MIT especially for running the LISP language. It is called this because the title, LISP MACHINE MANUAL, appears in big block letters -- wrapped around the cover in such a way that you have to open the cover out flat to see the whole thing. If you look at just the front cover, you see only part of the title, and it reads "LISP CHINE NUAL" toomanybeersies on Sept 7, 2017 | parent | next [–] Link to an image of the manual, for the lazy: https://c1.staticflickr.com/1/101/264672507_307376d26c_z.jpg https://news.ycombinator.com/item?id=27332340 DonHopkins on May 30, 2021 | prev | next [–] Here's the source code for Kent Pitman's "DOCTOR" in MACLISP, which was of course inspired by ELIZA. (Joseph Weizenbaum taught Kent Pitman LISP!) https://github.com/PDP-10/its/blob/master/src/games/doc.102 And here's what happened with he (manually by typing) hooked it up with Kenneth Colby's "PARRY" (the paranoid patient): https://www.maclisp.info/pitmanual/funnies.html >Parrying Programs >I didn't write the original ELIZA program, although my Lisp class was taught by Joseph Weizenbaum, who did. I later wrote a very elaborate program of similar kind, which I just called DOCTOR, in order to play with some of the ideas. >At some point, I noticed there was a program at Stanford called PARRY (the paranoid patient), by Kenneth Colby. I understand from Wikipedia's PARRY entry that Weizenbaum's ELIZA and PARRY were connected at one point, although I never saw that. I never linked PARRY with my DOCTOR directly, but I did once do it indirectly through a manual typist. Part of my record of this exchange was garbled, but this is a partial transcript, picking up in the middle. Mostly it just shows PARRY was a better patient than my DOCTOR program was a doctor. >I have done light editing to remove the typos we made (rubbed out characters were echoed back in square brackets). >Also, I couldn't find documentation to confirm this, but my belief has always been that the numeric values after each line are PARRY's level of Shame (SH), Anger (AN), Fear (FR), Disgust (DS), Insecurity (IN), and Joy (J).—KMP [...] ;;; Notes about CLI interrupts and eval-in-other-lisp: https://news.ycombinator.com/item?id=20267415 https://news.ycombinator.com/item?id=38061207 >Here's Kent Pittman's :TEACH;LISP from ITS, which is a MACLISP program that teaches you how to program in MACLISP. (That's "Man And Computer Lisp" from "Project MAC", not "Macintosh Lisp".)

regard them as distinct langauges, not mere dialectal variations, although plainly they are from what I would call the same language family. >You will probably prefer to use one or the other in the end, but they each have things to teach you. Even if you prefer to use neither, you will use the things you learn from these languages in your future thinking, becuase they will give you metaphors for thinking about things that other languages do not. This is like catnip for people interested in the sociological and cultural aspects of programming language design: Common Lisp: The Untold Story; Kent M. Pitman, HyperMeta Inc. https://www.nhplace.com/kent/Papers/cl-untold-story.html Here's a description of :TEACH;LISP that I posted to reddit 11 years ago: https://www.reddit.com/r/programming/comments/t4rre/comment/... >xardox 11 yr. ago >Kent Pitman's a great guy who's done a lot of pioneering work to teach people Lisp. >KMP wrote a Lisp program to teach MACLISP on the MIT AI Lab's ITS systems called ":TEACH;LISP", which I used to learn Lisp (but which Jerry Pournelle cited in a not-friendly light). >KMP kindly took the time to personally teach me some LISP, by challenging me to a dual! We both ran our own LISP processes, and loaded a function called EVAL-IN-OTHER-LISP that used "core link interrupts" to send s-expressions from one LISP to another, so we could evaluate code in each other's LISP. That made it easy for him to define and call functions in my LISP, which was quite fun, but then he set my numeric output base to roman numerals! He won that dual. Core Link Interrupts (ITS's interprocess communication mechanism, sending messages through actual core memory on a PDP-10): https://web.archive.org/web/20110904184550/http://www.avanth... How Jerry Pournelle got kicked off the ARPANET: http://www.art.net/~hopkins/Don/text/pourne-smut.html >From: Kent M Pitman <KMP at SCRC-STONY-BROOK.ARPA> >Subject: Pourne >Personally, I'd just turn off his account. It's not like it's the first time, and he not only flaunts his use of our machines but stabs us in the back with grumblings about why he doesn't like this or that program of ours when he gets a chance. (Am thinking particularly of an article he wrote which condemned Lisp for reasons amounting to little more than his ignorance, but which cited Teach-Lisp in a not-friendly light... The man has learned nothing from his presence on MC and sets a bad example of what people might potentially accomplish there. I'd rather recycle his account for some bright 12-yr-old...) Here's the source code to EVAL-IN-OTHER-LISP: https://www.maclisp.info/pitmanual/system.html The following is some sample code (complete with documentation) that I found in my notes and thought might be helpful: ;;; Notes about CLI interrupts: ;;; ;;; A CLI interrupt is what happens when another job sends to yours. It is ;;; normally the case that other jobs will send directly to a user's HACTRN. ;;; If, however, Lisp is interrupted by a CLI message, it can elect to handle ;;; handle the interrupt in an arbitrary way. ;;; ;;; To define a handler, two things must be done: ;;; [1] Place the name of the handler function (function of one arg) ;;; in the variable CLI-MESSAGE. ;;; [2] Enable CLI handling with (SSTATUS CLI T) ;;; ;;; The handler should take a single argument which it probably should ignore ;;; since I have no idea what it is likely to be. ;;; ;;; The handler should open the file "CLA:" in (CLA BLOCK) mode and immediately ;;; discard the first 8 characters which will be garbage. ;;; ;;; The remainder of the stream, until a control-C or an eof, will be the text ;;; of the message sent. It may be read with TYI, READ, etc. and handled ;;; however. (eval-when (eval compile) (cond ((not (get 'iota 'version)) (load "liblsp;iota")))) (defun handle-cli-msg (ignore) (iota ((stream '((cla)) '(cla block))) (do ((i 0 (1+ i))) ((= i 8)) (tyi stream)) (do ((c (tyi stream -1) (tyi stream -1))) ((or (= c -1) (= c 3))) (format t "~&~3,'0O ~@:C~%" c c)))) ;print out chars seen (setq cli-message 'handle-cli-msg) (sstatus cli t) ; -------- (defun eval-cli-msg (ignore) ;alternate handler (iota ((stream '((cla)) '(block cla))) (do ((i 0 (1+ i))) ((= i 8)) (tyi stream)) (do ((f (read stream nil) (read stream nil))) ((null f)) (errset (eval f) nil)))) ;Quietly evaluate forms... ;; Assumes the other lisp will have EVAL-CLI-MSG as value of CLI-MESSAGE (defun eval-in-other-lisp (uname jname s-expression) (iota ((stream `((cli) ,uname ,jname) '(out ascii block))) (print s-expression stream)))

id=37723853 [4] https://news.ycombinator.com/item?id=37780515 [5] https://github.com/PDP-10/its/blob/master/src/sysnet/supdup.... subttl LSRCHK and LSRWRN -- see if user is loser ;;; This checks to see if the loser is an AI or LCS member or on a ;;; winners list. If not, a warning net-hopping message is printed ;;; and the program offers to kill itself off. ;;; The winner-p check has been extracted so that if at some point in ;;; the future this program is modified to check if it's running from ;;; a CRTSTY, those people may not be warned. ;;; If you mung this you might wish to mung CHTN similarly. ;;; skips unless the luser should be warned. lsrchk: pushj p,winchk ;are they a winner? skipa ;nope jrst popj1 ;yea; so skip ;; check to see if they're in loser table move t,[-loslen,,lostab] ;; winchk left xuname in tt lsloop: camn tt,(t) popj p, ;loser -> don't skip aobjn t,lsloop ;; check inquir entry movei a,filech move b,[-lsrpgs,,hstpag];map lsr where host table will be pushj p,lsrtns"lsrmap jrst lsrlos ;something wrong; print loser message .suset [.rxuname,,b] ;xuname into b pushj p,lsrtns"lsrunm ;find our entry in database jrst lsrlos ;no inquir entry; must be loser .close filech, ;close lsr file movei a,lsrtns"i$grp ;we want to check group pushj p,lsrtns"lsritm popj p, ;none means guest ildb a,a ;get field caie a,"A ; AI lab cain a,"L ; LCS jrst lsloo1 caie a,"V ; NIL group cain a,"Z ; Clinical Decision Making jrst lsloo1 caie a,"C ; Theory of Computation popj p, ;they're not a lab member lsloo1: movei a,lsrtns"i$rel ;Check relationship pushj p,lsrtns"lsritm popj p, ;none means loser ildb a,a ;get field caie a,"X ;some losers put AX when they mean XA ;; These names are for NETWRK popj1: aos (p) ;otherwise skip cpopj: popj p, ;when returning lsrlos: .close filech, ;close lsr file popj p, ;don't skip ;;; Skip means these people know what they're doing; don't hassle them winchk: .suset [.rxuname,,tt] move t,[-winlen,,wintab] wnloop: camn tt,(t) jrst popj1 ;winner; skip aobjn t,wnloop popj p, ;;; these people aren't hassled wintab: irp x,,[gumby,alan,cstacy,cent,devon,dph,oaf,mly,jtw,jnc,klotz,cbf,sra,ed,swa,map,jbvb] sixbit/x/ termin winlen==.-wintab ;;; These people are always hassled lostab: irp x,,[tk,hewitt,rms] sixbit/x/ termin loslen==.-lostab ;;; warn loser that net-hopping is a waste of the machine lsrwrn: movei tt,[asciz/ Using this machine to access another will needlessly drain resources, slowing the system both for you and other users. You'll probably get better response by connecting directly. You should not do this unless you have a good reason to do so. If you have any questions, typing :LUSER to DDT will request a system programmer to assist you. Are you sure you want to net-hop?/] pushj p,outstr $call iot,[#ttyich,a],[#%tinwt] ;Wait for character .lose %lssys caie a,"y cain a,"Y popj p, ;it was a Y caie a,40 ;maybe it was a space? .logout 1, popj p,

erminals (like adding reverse and bold text, or line/char insert/delete, to a terminal type that doesn't support it), and it still works perfectly. https://donhopkins.com/home/archive/NeWS/news-tape/applicati... # This is a faster termcap for psterm, Warning: if you use this termcap # some control characters you type will do strange things to the screen # on systems that echo typed control characters to the users terminal. psterm-fast, am, km, hs, cols#80, lines#34, bel=^G, cr=\r, csr=^E%p1%d;%p2%d;, clear=\f, el=^C, ed=^B, cup=^D%p1%d;%p2%d;, cud1=^P, home=^R, cub1=^T, cuf1=^V, ll=^U, cuu1=^Y, dch1=^F, dl1=^K, blink=^Ob, bold=^Od, smcup=^Ot, smir=^Oi, rev=^Or, smso=^Oo, smul=^Ou, sgr0=^N*, rmcup=^Nt, rmir=^Ni, rmso=^No, rmul=^Nu, flash=^Z, fsl=^Nl, is1=^N*, il1=^A, kbs=\b, kcud1=\E[B, kcub1=\E[D, kcuf1=\E[C, kcuu1=\E[A, nel=\r\n, rs1=^N*, rc=^\, sc=^], ind=^W, ri=^X, ht=\t, tsl=^Ol, I don't understand why it's better to emulate only one fixed terminal type (especially the verbose anathema that's vt100), since you might encounter programs or operating systems that don't support vt100 or whatever you chose to emulate, don't respect termcap, and might use any other fixed set of escape sequences, which psterm can easily handle. Even if you encounter a program that requires a totally new terminal you've never seen, you can easily write a termcap entry for it, and psterm will emulate it without any changes. Why rewrite a bunch of other programs, or a bunch of other terminal emulators, when one terminal emulator can easily adapt to them all? In 1988 when psterm was written there were many different programs and operating systems and terminals like that, especially since terminals can talk to other operating systems than unix that don't support termcap, via telnet or serial ports and modems. It wasn't anything like the stagnant linux/xterm/vt100 monoculture we have today. And if you're going to standardize on one terminal, the vt100's one of the worst you could possibly chose! That's kind of the whole point of a terminal emulator: to emulate terminals, so the more the merrier! The idea of virtualizing terminal protocols has been around for a long time, like Marc Crispin's SUPDUP Display Protocol for ITS and Lisp Machines (RFC734 from 1977), and ITS's CRTSTY virtual terminal emulator (kind of like "screen" for translating virtual to actual terminal sequences for many terminal types, adapting dumb terminals without line/char insert/delete, supporting redisplay for low baud rates or congested ARPA connections, and keeping your session and jobs alive if you disconnect, so you can continue after you reconnect, even with a different terminal type, if you got kicked off a nice AAA and forced to use a shitty VT52). http://junk.nocrew.org/pipermail/its/1988-September/002005.h... https://github.com/PDP-10/its/blob/master/doc/sysdoc/itstty.... >This file describes just about all there is to know about using and programming TTYs (abbreviation for "Teletypes", for which read "consoles") on the ITS operating system. https://datatracker.ietf.org/doc/rfc734/ >NWG/RFC# 734 MRC 07-OCT-77 08:46 41953 SUPDUP Display Protocol Page 1 Network Working Group Mark Crispin Request for Comments 734 SU-AI NIC 41953 7 October 1977 >SUPDUP Protocol >This document describes the SUPDUP protocol, a highly efficient display telnet protocol. It originally started as a private protocol between the ITS systems at MIT to allow a user at any one of these systems to use one of the others as a display. At the current writing, SUPDUP user programs also exist for Data Disc and Datamedia displays at SU-AI and for Datamedias at SRI-KL. The author is not aware of any SUPDUP servers other than at the four MIT ITS sites. >The advantage of the SUPDUP protocol over an individual terminal's protocol is that SUPDUP defines a "virtual" or "software" display terminal that implements relevant cursor motion operations. The protocol is not built on any particular display terminal but rather on the set of functions common to all display terminals; hence it is completely device- independent. In addition, the protocol also provides for terminals which cannot handle certain operations, such as line or character insert/delete. In fact, it is more than this. It provides for terminals which are missing any set of features, all the way down to model 33 Teletypes. >The advantage over the TELNET protocol is that SUPDUP takes advantage of the full capabilities of display terminals, although it also has the ability to run printing terminals. https://its.victor.se/wiki/_media/ai_wp_235.pdf >The SUPDUP protocol [Crispin 77] is a highly efficient display telnet protocol. The advantage over the TELNET protocol is that SUPDUP takes advantage of the full capabilities of display terminals, although it also has the ability to run printing terminals. When you use the SUPDUP protocol, you do not need to tell the remote host which you are connecting to what type of terminal you have or what the terminal's capabilities are. The host you are SUPDUPing from handles the actual display support for your terminal. >Additionally, SUPDUP defines a network graphics protpcol [Stallman 78] which makes it easy for network hosts to draw pictures along in addition to text. I even wrote a SUPDUP emulator in FORTH and RPN 6502 assembly, which is about as backwards and upside-down as it gets -- this code also supports the SUPDUP line saving extensions that RMS hacked into ITS Emacs, so it can stash lines on the screen in local memory before overpainting them, then almost instantly pop them back on the screen later, so you can scroll back and forth through text really fast at 300 baud (plus Devon McCullough made ZipMod with Huffman encoding to make it even faster on top of that): https://donhopkins.com/home/archive/forth/supdup.f HEX CREATE SETUP-LINE ASSEMBLER BOT LDA, N STA, BOT 1+ LDA, N 1+ STA, BOT 2+ LDY, SCR-LBASES ,Y LDA, N 2+ STA, SCR-HBASES ,Y LDA, N 3 + STA, SCR-WIDTH 1- # LDY, RTS, At 300 baud over a congested ARPA connection, we had a lot of time to think about how to optimize terminal emulation while waiting for the screen to repaint... And just what's wrong with backwards and upside-down algorithms that solve problems in ways that forward and rightside-up algorithms can't? That's how Emacs's infamous screen redisplay algorithm (and many other common algorithms like pathfinding in games and route planning in cars) work: recursively flood filling forward then navigating backwards from the goal to the current position at the minimal cost, through a matrix or maze of different possible alternative escape sequences and drawing operations or roads with different costs, to find the optimal shortest possible route. At 300 baud or even 1200 baud, and even on a busy Vax 11/750, there's a lot of time between each character for Emacs to think about what text and escape sequences to send next. And of course Emacs's screen update algorithm would automatically take into account and use the short optimized custom control codes defined in the psterm-fast termcap entry, to be much more efficient that the verbose inefficient vt100 codes. Read the paper and display.c code I linked to, and see the wikipedia page on dynamic programming: >James Gosling's Emacs screen redisplay algorithm also used similar "dynamic programming techniques" to compute the minimal cost path through a cost matrix of string edit operations (the costs depended i.e. on the number of characters to draw, length of the escape codes to insert/delete lines/characters, padding for slow terminals, etc). https://en.wikipedia.org/wiki/Gosling_Emacs >Gosling Emacs was especially noteworthy because of the effective redisplay code, which used a dynamic programming technique to solve the classical string-to-string correction problem. The algorithm was quite sophisticated; that section of the source was headed by a skull-and-crossbones in ASCII art, warning any would-be improver that even if they thought they understood how the display code worked, they probably did not. https://donhopkins.com/home/archive/emacs/skull-and-crossbon... >Trivia: That "Skull and Crossbones" ASCII art is originally from Brian Reid's Scribe program, and is not copyrighted. https://donhopkins.com/home/archive/emacs/mw/display.c /* 1 2 3 4 .... Each Mij represents the minumum cost of +---+---+---+---+----- rearranging the first i lines to map onto 1 | | | | | the first j lines (the j direction +---+---+---+---+----- represents the desired contents of a line, 2 | | \| ^ | | i the current contents). The algorithm +---+---\-|-+---+----- used is a dynamic programming one, where 3 | | <-+Mij| | M[i,j] = min( M[i-1,j], +---+---+---+---+----- M[i,j-1]+redraw cost for j,2 4 | | | | | M[i-1,j-1]+the cost of +---+---+---+---+----- converting line i to line j); . | | | | | Line i can be converted to line j by either . just drawing j, or if they match, by moving . line i to line j (with insert/delete line) */ https://donhopkins.com/home/documents/EmacsRedisplayAlgorith... https://dl.acm.org/doi/10.1145/1159890.806463 >A redisplay algorithm, by James Gosling. >Abstract >This paper presents an algorithm for updating the image displayed on a conventional video terminal. It assumes that the terminal is capable of doing the usual insert/delete line and insert/delete character operations. It takes as input a description of the image currently on the screen and a description of the new image desired and produces a series of operations to do the desired transformation in a near-optimal manner. The algorithm is interesting because it applies results from the theoretical string-to-string correction problem (a generalization of the problem of finding a longest common subsequence), to a problem that is usually approached with crude ad-hoc techniques. [...] >6. Conclusion >The redisplay algorithm described in this paper is used in an Emacs-like editor for Unix and a structure editor. It's performance has been quite good: to redraw everything on the screen (when everything has changed) takes about 0.12 seconds CPU time on a VAX 11/780 running Unix. Using the standard file typing program, about 0.025 seconds of CPU time are needed to type one screenful of text. Emacs averages about 0.004 CPU seconds per keystroke (with one call on the redisplay per keystroke). >Although in the interests of efficency we have stripped down algorithm 5 to algorithm 6 the result is still an algorithm which has a firm theoretical basis and which is superior to the usual ad-hoc approach. https://en.wikipedia.org/wiki/Dynamic_programming >Dynamic programming >Figure 1. Finding the shortest path in a graph using optimal substructure; a straight line indicates a single edge; a wavy line indicates a shortest path between the two vertices it connects (among other paths, not shown, sharing the same two vertices); the bold line is the overall shortest path from start to goal. >Dynamic programming is both a mathematical optimization method and an algorithmic paradigm. The method was developed by Richard Bellman in the 1950s and has found applications in numerous fields, from aerospace engineering to economics. >In both contexts it refers to simplifying a complicated problem by breaking it down into simpler sub-problems in a recursive manner. While some decision problems cannot be taken apart this way, decisions that span several points in time do often break apart recursively. Likewise, in computer science, if a problem can be solved optimally by breaking it into sub-problems and then recursively finding the optimal solutions to the sub-problems, then it is said to have optimal substructure. >If sub-problems can be nested recursively inside larger problems, so that dynamic programming methods are applicable, then there is a relation between the value of the larger problem and the values of the sub-problems.[1] In the optimization literature this relationship is called the Bellman equation.

d a Lisp dialect that only runs on ITS and a few other OSes of similar vintage and commercial utility. However, it is still under active development because people are interested in it. Besides: Digging into a codebase to fix a dumbass printer? People will do that out of spite. People will do that for the blog post and Hacker News thread.

g interviews. The task is to print the numbers from 1 to 100, but for multiples of 3 print "Fizz" instead of the number, and for multiples of 5 print "Buzz". For numbers which are multiples of both 3 and 5 print "FizzBuzz". Implementing Fizz Buzz in TECO would be quite a challenge due to the language's design and constraints. TECO is not really meant for such tasks, as it is a text editor and correction programming language. However, I'll provide a rough example of how you might implement FizzBuzz in TECO, although it's somewhat complex and involves a few workarounds: 0uz ! Store 0 in register Z (counter) ! <qz+1uz ! Increment Z ! qz:< ! Inner loop, executes while Z is less than or equal to 100 ! qz\3%<iFizz$> ! If Z is divisible by 3, insert "Fizz" ! qz\5%<iBuzz$> ! If Z is divisible by 5, insert "Buzz" ! qz\3%qz\5%"nqz\*A$' ! If Z is not divisible by 3 or 5, insert Z (as a character) ! ia ! Insert a newline ! >' ! End of inner loop ! > ! End of outer loop ! This is a very rough, and not perfect, implementation. It doesn't properly handle numbers over 9, because TECO doesn't really support integer arithmetic in the way modern languages do. When we print a number, we're actually printing a character with the corresponding ASCII code, so numbers over 9 would turn into non-digit characters. Implementing FizzBuzz properly would likely involve manually converting numbers to digit strings, which would make the program quite a bit more complex. In practice, you would rarely if ever use TECO for this sort of task. TECO was designed for editing text, not for general-purpose programming, and it lacks many of the features that make modern languages suitable for tasks like FizzBuzz. But, this does demonstrate some of the ways you can use TECO's unique features to solve problems.

and said: [1:i\*^Yu14<q1&377.f"nir'q1/400.u1>^[[8 .-z(1702117120m81869946983m8w660873337m8w1466458484m8 )+z,.f^@fx\*[0:ft^]0^[w^\ And I said "I didn't get nothing, I had to rebuild the bittable in queue six" and he said: [1:i\*^Yu16<q1&77.+32iq1f"l#-1/100.#-1&7777777777.'"#/100.'u1r>6c^[[6 .(675041640067.m6w416300715765.m6w004445675045.m6 455445440046.m6w576200535144.m6w370000000000.m6),.fx\*[0:ft^]0^[w^\

al hardware the emulator supports yet, but he's probably worked on some of that too. ;) ) https://github.com/PDP-10/its/issues/620 Thanks to Lars, here are two revisions of an AI Lab memo about LLOGO: http://bitsavers.org/pdf/mit/ai/aim/AIM-307.pdf http://bitsavers.org/pdf/mit/ai/aim/AIM-307a.pdf And a Logo manual and glossary of PDP-11 Logo: http://bitsavers.org/pdf/mit/ai/aim/AIM-313.pdf http://bitsavers.org/pdf/mit/ai/aim/AIM-315.pdf http://bitsavers.org/pdf/mit/ai/aim/AIM-315a.pdf