Skip to content(if available)orjump to list(if available)

Byte Magazine: LISP (1979)

Byte Magazine: LISP (1979)


·August 5, 2022


The first article in this issue of BYTE has a very interesting characterization of Lisp that I have not come across before. I mean, famous quotes like "Lisp is a programmable programming language" by John Foderaro and "The greatest single programming language ever designed" by Alan Kay are often mentioned in articles about Lisp. But in this issue of BYTE, the article "An Overview of LISP" by John Allen at page 10 has something very interesting to say. Excerpt from the article:

"The best description of the LISP programming language is that it is a high level machine language. That is, it shares many of the facets of contemporary machine language --the necessity for attention to detail and the freedom to manipulate the machine's data and programs without restriction-- yet LISP is high level in that the language contains the expressive power and convenience of traditional high level languages. The contradiction is resolvable: a LISP machine is just a higher level machine whose data items are organized differently from the binary bit patterns of most machines, and the LISP programming language is the assembly language for this machine."

Consider the Emacs Lisp (Elisp) interpreter for example. Elisp interpreter is the Lisp machine. It understands Elisp symbolic expressions, the language of this machine. With enough code written in this machine's language, we get this fine editing and productivity software known as Emacs!


This exactly matches my thoughts. It seems that machine language and LISP are the only two languages (that i know anyway) where code and data are fundamentally the same kind of thing.


There are many languages that are dynamic and let you generate code and run it inside the program. For instance in Java you can generate bytecode for a class and run one of the methods. In FORTH you can write new "words" (roughly functions) that are the same as the built-in words.

It is mainly languages built around AOT compilation like C, Pascal, FORTRAN and such that completely separate code and data. (I guess though you can make a C program that writes a C program, runs "cc" on it, makes a shared object file, loads the library dynamically, and calls a function from it.)


I'm aware of a discussion about what homoiconicity should be defined as after Julia claimed to be a homoiconic language. It (and many others) have ways to manipulate the AST with its own language, but requires basically a different set of functions and tools to manipulate it that is different from those that manipulate the data, so that claim was eventually withdrawn.


Code is data isn't just about emitting and running code. It's also traversing your code as the data structure it is and changing it as you see fit.


Even "languages built around AOT compilation" are increasingly blurring the phase distinction between "ahead-of-time" and "at runtime", via increased use of metaprogramming and constant evaluation facilities. We may end up with a state of things where even some "AOT-language" programs are written to do much of their work at compile time, perhaps adding more and more of those facilities that were formerly allowed only at "runtime".


As a sibling post said, code is data is a different thing. is a fun blog I wrote on this once.


No one's said the magic word yet: homoiconicity


Forth is the exact same thing.


I’m a Lisper but I love Forth and Forth people. The only computer subculture as devoted to their weird little secret ancient Jedi art as we parenthesis shufflers.


Prolog and Clojure (effectively a LISP dialect) probably also qualify, and more modern: I think that in a way JSON also qualifies.


JSON is not a programming language.


I have fond memories of Allen's book Anatomy of Lisp. I guess there are only historical reasons to read it now, but at the time it felt like an introduction to wizardry.


Historical reasons for reading are always good. We gain much insight from time travel and, until we invent actual time machines so we can get our IBM 5100's and go ourselves to Woodstock, books are the next best thing.


I have IBM 5100 nostalgia. I wrote a lot of software for that 40 years ago. Speaking of Lisp Machines, the 5100 was basically an APL machine: BASIC and APL in microcode.


Actually SBCL (and other CL impls) still follow this tradition; cf.

You can also use the new sb-simd to play around with vectorization in the interpreter. Okay you'll break something, but it's such joy while you do it. C/C++ and other "strictly-separated compilation" languages OTOH seem so dogmatic and stupid now. It's no surprise why development is no painful in the latter. Also not surprising that the world prefers them.


The first Scratch applet was a LISP runtime implemented in Java.


Would that description have been influenced by symbolics and such systems? It is pretty spot on but perhaps more true of those systems than of today's lisps.


The second article in this issue of BYTE has a delightful mention of Logo (the programming language). On page 20, it says,

"LOGO is, up to surface structure, more or less equivalent to LISP."

It further says,

"The LOGO system supports two different (by no means disjoint) environments: the Turtle, Graphics and Musicbox world (ie: peripheral devices which are controlled by a command language) and the LISP world."

And then in a later bullet point on page 22,

"Our experiences, especially with young students, indicate that programming in LOGO may serve as a bridge between natural language communication and reasoning and the formal and abstract symbols and reasoning in mathematics and programming languages."

This bullet point ends with,

"Our findings can at least be partly explained by the cleanliness by which the basic computational ideas are embodied in LISP/LOGO."

In my own life, I was fortunate to have stumbled upon Logo as my first computer programming language. The simplicity and elegance of Logo had a powerful effect on me at a very young age. It immediately turned me into a computer programmer for life!


People at MIT like Seymour Papert were aghast that BASIC became the dominant programming language for education in the 8-bit age, they were hoping they could push out LOGO as a new standard but it did not get a lot of traction.

Three years later Byte ran a special issue on LOGO which I thought was one of the best issues of Byte ever

in particular it had some great reviews of LOGO implementations for different home computers some of which were pretty strange like the TRS-80 Coco and the TI-99/4A. It was very close to the cultural peak of the 1980s before Michael Jackson dropped off the charts, the Atari 2600 went down without being immediately replaced (unless you count the C-64), etc. Byte was a lively magazine so long as the market was split up between a wide range of computers but it never really found it's niche in a world dominated by the IBM PC at the high end and the C-64 at the low end.

Speaking of which, LISP never really caught on in the 8-bit era. This issue has some articles about how you would do so but it didn't seem to shoehorn so well into a tiny machine (like the 1k of RAM on the Sinclair ZX80) as BASIC did. From the viewpoint of a kid who just learned BASIC, FORTH seemed to offer a lot of what LISP did and it was very available, even if it was a few weeks of assembly coding to write a FORTH.


Pegasus Lisp for the 6502 Apple II was pretty god - I really enjoyed it.


> People at MIT like Seymour Papert were aghast that BASIC became the dominant programming language for education

Like how we are all aghast at Python now. (All us Lispers, anyhow :-)


>The second article in this issue of BYTE has a delightful mention of Logo (the programming language).

Hacker News discussion of BYTE's special Logo issue: <>

>In my own life, I was fortunate to have stumbled upon Logo as my first computer programming language. The simplicity and elegance of Logo had a powerful effect on me at a very young age. It immediately turned me into a computer programmer for life!

I well remember the epiphany I felt while learning Logo in elementary school, at the moment I understood what recursion is.

While I have never worked as a professional software developer, computers have been a hobby all my life. I don't think the fact that the language I have mostly written code in in recent years is Emacs Lisp is unrelated to the above moment.


> I well remember the epiphany I felt while learning Logo in elementary school, at the moment I understood what recursion is.

Yep, this was 100% me too.

I "got" recursion through math and induction and a bit of graph paper, and the way it made my mind recurse to infinity made me feel ... funny ... in that age.

But it wasn't until I used Logo on the school's only Macintosh LC475 that I got the full psychedelic effects.

Nothing as intricate as NetLogo (e.g. see its Koch curve here:, but still a strong impression.

Funnily, that had as a consequence to fall in love with iterative function systems and pizzabox-form desktops, leading to me being introduced to Matila Ghyka's book, and Sun's Sparcstation 5.


> "The LOGO system supports two different (by no means disjoint) environments: the Turtle, Graphics and Musicbox world (ie: peripheral devices which are controlled by a command language) and the LISP world."

Whelp, the lack of an Oxford comma there really through me for a loop until I continued reading. Anyway...

> "Our experiences, especially with young students, indicate that programming in LOGO may serve as a bridge between natural language communication and reasoning and the formal and abstract symbols and reasoning in mathematics and programming languages."

If anyone is interested in this, there are the following books:

* Exploring Language with Logo:

* Visual Modeling with Logo: A Structured Approach to Seeing:

* Turtle Geometry: The Computer as a Medium for Exploring Mathematics:

* Computer Science Logo Style:

It's disappointing to me that Logo died out and didn't remain around or evolve, and I find it a bit sad that many kids are getting introduced to programming via something like Python or Scratch. I feel there's still space for Logo, and it would be cool to see an easily downloadable and installable version of it.


Turtle Geometry is still worth checking out. The value is in working through the ideas, and details of Logo take up very little of the book.

(I've only glanced through CS Logo Style and haven't seen the other two.)


I think the same basically goes for any of those books. One could easily port the code to Racket, for example.


Wasn't it predictable, though?

Take a look at that issue of BYTE entirely dedicated to LOGO that was referenced multiple times in this discussion.

A dozen articles about the language, with listings. The screenshots? All the same, showing recursive pictures of rectangles and circles. Great. LOGO can do that. But what else? Big empty void there.

Contrast that with what BASIC could do at the time... Is it any wonder LOGO died out and BASIC thrived?


> Contrast that with what BASIC could do at the time... Is it any wonder LOGO died out and BASIC thrived?

AIUI, implementations of BASIC on home computers were a lot simpler and more straightforward than LOGO or LISP - for instance, GC in BASIC was an afterthought and only applied to strings. The real competitor to BASIC back then was FORTH.


What could Basic do over Logo? As a few of the books I posted show, Logo is a very capable language, ignoring turtles. Was Logo in the 80s somehow less capable?


> Big empty void

See my comment upthread about Turtle Geometry.


> It's disappointing to me that Logo died out and didn't remain around or evolve

But it did remain around and evolve.

See, e. g.:

StarLogo Nova:



Scratch was produced at MIT just like Logo and I think it is an evolution of what they were trying to do with Logo.


Despite the heritage of the creators, I personally view Scratch as a misstep. I am a big fan of visual programming, but Scratch is essentially an everyday imperative language with a structured editor and sprites. It doesn't maintain any of the simplicity or elegance of Logo or Lisp, and I'm honestly a bit surprised that the MIT Media Lab invests so much in it.


My first experience programming was with a LOGO turtle in third grade. I remember the lab full of Apple IIs, and the joy of PEN DOWN, UP 10, PEN UP style commands.


266 pages of well-written, edited, fact-checked electronics and computer programming. Monthly. Let that sink in.

There is so much good info packed into this one issue, it is worth terabytes of crap on stack overflow. Clearly there was less information back then, but it was far higher quality.

I'd like to understand how C came to dominate the world when LISP could replace all of the scripting languages we used today. Was it tooling on cheaper machines that made C so popular? Or that it was closer to ASM than LISP? I never really formed a good opinion on this, I'm missing lots of history.


Worse is better. C and Unix were faster to implement new stuff as they were only 'good enough'. Lisp machines wanted to do everything 'right', right from the start, and were slower to implement new features. Unix was already winning by then...


And now the industry is going after C Machines, as the ultimate solution to fix C memory corruption issues, the irony.


Irony is the "worse is better" guy was a lisp fanatic IIRC :)


C came to dominate the world because of Unix. But not directly, because Unix didn't really dominate the world other than some of the institutional and corporate world. GNU and Linux picked up the domination torch and are still working on it.

I strongly suspect Microsoft was the catalyst which propelled C, absent of Unix.

Microsoft had been infatuated with Unix from early on. They had their own version called Xenix, based on AT&T licensed code. Part of the MS-DOS API consists of "Xenix functions", imitating some Unix-like things. MS-DOS, and consequently Windows feature Unixy conventions like .. for the parent directory and . for current, even though the underlying link concept isn't there.

Microsoft produced a C compiler + IDE which I believe highlighted and legitimized C as a viable language in the mass market world of IBM PC compatibles.

According to the Wikipedia page on Microsoft Visual C++, Microsoft already had a C compiler out in 1983.

"Microsoft C 1.0, based on Lattice C, was Microsoft's first C product in 1983. It was not K&R C compliant."

Microsoft picking up Lattice C and running with it is probably what caused the C explosion. Borland joined in the fray in 1987 with Turbo C.

But wait, Microsoft had a Lisp product too: why didn't that help?

[plain HTTP!]

Probably they just didn't peddle it hard enough.

Microsoft also used C for developing Windows, and supported C development for Windows:

"Microsoft sold as included Windows Development libraries with the C development environment, which included numerous windows samples."

The rise of MS Windows dragged C with it, with the API's and code samples being expressed in C.

Plus, it was probably not lost on the PC programming population that if they learn and work with C on that platform, their skills will be applicable in Unix and elsewhere.


The irony of reading this.

Until Visual C++, almost no one would bother with buying Microsoft compilers, rather going for Borland and Watcom offerings on MS-DOS, which was fully written in Assembly.

On the MS-DOS days, C was was yet another slow high level language, sharing attention with Modula-2, Pascal dialects (mostly QuickPascal, TMT Pascal and Turbo Pascal), BASIC (QBasic, Turbo Basic and QuickBasic), and Clipper/Paradox for DB stuff.

Anyone that cared about performance was using TASM and MASM for most of their coding.

When Windows finally became usable, with version 3.0, anyone that cared about productivity was buying Borland C++ for Windows, using Object Windows Library, or Microsoft's Visual Basic, only masochists were using pure C with the Win16 SDK.

Only the release of Visual C++, alongside MFC, made most devs have a second look at Microsoft's own compilers, and then with Borland's mismanagement, devs eventually jump ship from what was then Delphi and C++ Builder into Visual C++.

Microsoft was never a big C shop, as proven with the decision to ignore C past C89, which they only backtracked (sadly) due to customer pressure.


The main competitor to C would have been PASCAL, and the drawbacks of standard PASCAL for low-level programming (a necessity on the computers of the day, where even ASM programming was commonly resorted to in order to eke out the best performance) were very well known. C was not perfect by any means (the segmented memory models on 16-bit x86 required non-standard extensions to support, for example) but it was a lot better than the alternative.

LISP would've been a total non-starter for serious use given its requirement for GC and being an interpreted language. Quite comparable to the dog-slow Java applets of the mid-1990s, and in fact even worse on early hardware.


Maybe I’m just projecting my own childhood as a universal case, but for a computer passionate teenager, Turbo Pascal was pretty much the sweet spot between kids tools like Basic (particularly pre qbasic if my memory serves) and C which I admit was still inscrutable to me. I’m trying to teach my middle school kids the fun side of programming and 35 years later I can’t find an IDE as perfectly integrated for debugging as I had in Turbo Pascal 5.

The folks I always had mad respect for were those who could write in assembly on their Commodores, etc… I never had one of those machines but I still bow my head to those who could write anything meaningful in pure assembly as a teenager in the pre internet era when you had to figure out so much more on your own.


It's “Pascal”, not “PASCAL”.


To be fair, out of these 256 pages, 200 are really just ads.

Your point still stands, but the actual substance is a lot smaller than you describe.


The advertisements are among the most interesting things about old magazines like BYTE, though. They preserve a snapshot of what the computer industry was like back then. Even the pricing information alone is very valuable.


Oh absolutely! Browsing through these pages today, I find myself reading the ads a lot more than the actual articles, which haven't aged well.

But back then... man, these ads were cancer and they made up 80% of the weight and price of the magazine.


Counterpoint taken.


C is much closer to the machine and very fast. When I learnt C I went to the book store. There were two C books (K&R and Byte Books C) and one Lisp book. I learnt both. Lisp was fun but, at the time, I never appreciated the introspection. It was only when, a long long time later, I learnt Python and remembered the ability to iterate the elements of a class and thought how handy that was for some programs.

C could more easily access the lower level resources as well.

I still wonder why one of these, like forth, lisp later Python did not become the standard command line interpreters whereas it would never have been C, and I have written very featured C interpreters.


Lisp Machines, Lisp just as C, had low level primitives.


The article about the Lisp interpreter written in 6809 machine language describes a stackless garbage collector which uses the pointer-reversal trick for traversing the heap.

> "The author's system uses the pointer reversal method, and he will testify to the unlimited number of obscure problems which can appear during the debugging phase of its implementation."



They don't cite[0] quite possibly because they independently discovered it as did others like L.P. Deutsch (who sometimes is prepended as Deutsch, Schorr, Waite). It stands out for me as something I ended up working out as an improvement for an implementation of LispKit Lisp[1] sometime around 1982. Imagine my surprise when I came across a reference to DSW describing my 'little pointer trick' :-)




It's amazing that this magazine issue is still (somewhat) relevant and interesting 43 years after its initial publication.

(I note that HN frequently has posts on Lisp as well as 8-bit systems.)

Other than HN, is there anything equivalent to BYTE in the modern era?

I do like magazines like Linux Format and RasPi, but they're focused on Linux and Raspberry Pi whereas BYTE seems to have covered all "small systems" from microcontrollers to multiuser systems (so both Linux and Raspberry Pi systems would be in scope, as would Arduino as well as Apple/Microsoft/Android/etc..) This issue also included a wide range of contributors from enthusiast developers to industry professionals to teachers and researchers.


Actually, that might be evidence that there really hasn't been much progress in Systems/PL.


I continually find new features of programming languages.

Covid, my time in this house, and the people I was with, gave me a chance to explore Scheme and CLOS derivatives (GOOPS). It's a joy to work with, and it helps me understand Ruby and other later developments. The different hooks it gives you into your hierarchy really map out the space that's possible.

It would be nice to lose myself in BYTE. It was influential. But it feels wrong somehow? Maybe that's on me. Maybe someday I'll write a BYTE random-page generator service.


C++ seems to have made some progress in the last few decades. Python improves on BASIC in some ways. Java, JavaScript, Swift, and Rust have memory safety like Lisp, PL/I and Ada did.

But I tend to agree - the biggest advances seem to be in hardware: now you can run Unix on an internet-connected watch, voice recognition/translation/automatic transcription on a mobile phone, and real-time ray tracing on a game console.


Most of that progress is catching up with what we already had, as you kind of point out on your memory safety remark.

C++ improvements are related to the bare language itself, in regards to tooling, no one seemed to have cared to go beyond what something like C++ Builder has been doing for the last 30 years (more or less).

Python improves on BASIC, while still missing the compilation story from most BASICs.

Diving into Xerox PARC documentation about Interlisp-D, Smalltalk, Mesa XDE and Mesa/Cedar is quite revealing in what we already had 40 years ago, and how long it has taken to bring those ideas back into mainstream.


Just this week while going through the book _Ideas That Changed the World_ I read the original paper on LISP[1]. I have to say this magazine article reads a bit cleaner. But that's kind of the fun of the book -- learning to decode the excited yet formal language of computational innovation over time.

The book traces out what are effectively conversations across decades (or centuries if you include Aristotle). So when you see McCarthy name drop Church's lambda calculus, you know how it ties into a conversation about Hilbert's decidability problem, and that self-reference ("recursion") is a fundamental tool.

And from the perspective of now, you see that this is the first encounter with automatic garbage collection, describing a simple mark and sweep algo. The BYTE magazine covers a more advanced garbage collector, Lambdino, which assumes a massive amount of familiarity with LISP and internals than the previous article comparing LISP and LOGO.




Byte Magazine – LISP (1979) - - May 2019 (67 comments)

BYTE Magazine's Lisp issue (1979) [pdf] - - Aug 2017 (151 comments)


Starting on page 154 a now-familiar new product is introduced, and compared to Lisp as such:

> Returning to the LISP theme of our current issue, Visi- Calc is an example of a tree-oriented parallel data struc- turing problem for which LISP is a most appropriate lan- guage of expression. Due to a lack of availability of LISP as a software development tool for personal computing hardware, its authors did not use LISP. They also had to make a number of compromises and tradeoffs as a result of the small size (eg: 16 K to 48 K bytes) of the main memory of personal computers. But they did use many of the tree concepts of artificial intelligence research. This provides us with the ultimate example of the relevance of LISP-like languages and approaches to personal computing: one of the most generally useful new user software tools for small machines, Visi-Calc, tackles just the sort of problem for which LISP is an appropriate tool of expression.


And, in turn, whenever Joel Spolsky's "You Suck at Excel" video comes up, people discuss how Excel (and spreadsheets in general) is a functional programming language (<>).


I looked through the rest of the magazine. From the preview of the Motorola 68000:

> Coupled with the new low cost, high density memory devices with 64 K bit capacity and with even greater density coming, the personal computer will attain or exceed the power of an IBM 360 Model 30 within the next decade.

Wow. We've come a long way...


Memory Lane!

Page 177 had an advertisement mentioning Alpha Micro Systems, where I worked at the time.


from the conclusion:

> We do not want to give the impression that all interesting uses of computers are centered around LISP. Some of the most innovative work was done by the Learning Research Group at Xerox Research Center in their development of the Dynabook and the Smalltalk language.

and the rest is history


Eighties computer magazines were amazing. Is there anything that comes close?


I think you have to go all the way back to the 1920s- and 1930s-era radio magazines for a comparable vicarious-zeitgeist vibe.

Conveniently, some of those are on as well, e.g. . (Cheat code for search purposes: gernsback.) March 1949 is especially awesome, with articles by Sarnoff and De Forest on the Next Big Thing of the day (television) and, as an afterthought towards the back, an article on NIST's first atomic clock.


Hacker News. It's worse because it's better.