Hacker News new | past | comments | ask | show | jobs | submit login
Byte Magazine: LISP (1979) (archive.org)
259 points by PaulHoule on Aug 5, 2022 | hide | past | favorite | 107 comments

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".

"Metaprogramming" is a very broad term. Templates etc. might be nice, but it's hardly anything compared to what you can do with Lisp macros (there's an orthogonal issue that this power leads to unreadable code; see "Lisp Curse", but ignore it for now.).

There is this project


which I might finish up when I'm done with the report I'm writing. It is possible to create Java expression trees with trees of static method calls that look a lot like S-expressions and stick them together into statements, methods and classes.

You should be able to do the same tricks people do with LISP macros and it could work code generation miracles but it would have that "LISP curse" problem in spades.

The plan is to generate a code generator that is sufficient to generate the full DSL implementation (ferocity0) and use that to generate the full implementation (ferocity.)

I have some tests for ferocity0 writing .java files to get fed to javac and for ferocity0 running expression trees with a primitive interpreter. Already the type system is enriched over the type system because interpreted ferocity0 can handle Java expressions as a type at run time so you get issues like quoting and unquoting in LISP.

How does this compare to Common Lisp or Scheme macros in in terms of amount of code needed to generate things? How does it compare in terms of what kind of functions and instructions are used? Can one use standard Java language to use it? Could one for example throw a for loop in there or directly write something like "class Point { ..."?

As a sibling post said, code is data is a different thing. https://taeric.github.io/CodeAsData.html 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.

And would have been way cleaner had they just left it as sexprs.

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.

It's a pretty computer. I'd love if we did replicas of it the way a company did with the C64 maxi.

Would also make the lives of time travelers much easier.

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: <https://news.ycombinator.com/item?id=28603556>

>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: http://www.netlogoweb.org/launch#http://ccl.northwestern.edu...), 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: https://www.amazon.com/gp/product/0262570653

* Visual Modeling with Logo: A Structured Approach to Seeing: https://www.amazon.com/gp/product/0262530694

* Turtle Geometry: The Computer as a Medium for Exploring Mathematics: https://www.amazon.com/Turtle-Geometry-Mathematics-Artificia...

* Computer Science Logo Style: http://people.eecs.berkeley.edu/~bh/v1-toc2.html

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.

Yeah. I recommend it because it goes way beyond the stuff another commenter complained about in this thread:

> 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.

E.g. the last chapter is an intro to general relativity, with a simulator for motion in curved spacetime.

(CS Logo Style also covers many topics, but it looked like they were all familiar to me as an experienced programmer. I haven't seen another book for programmers about most of the math in Turtle Geometry.)

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.

Mmmh... no.

I grew up and learned programming in that era, bought magazines, typed pages and pages of listings.

98% of the listings in these magazines were BASIC, 1% were assembly, and the rest was... well, others.

LOGO was a niche language then, and Forth even more so.

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: https://www.slnova.org/

NetLogo: https://ccl.northwestern.edu/netlogo/

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!] http://www.edm2.com/index.php/Microsoft_LISP

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”.

PASCAL is a case-insensitive programming language, so both are correct.

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.

Those ads made the magazine possible and accessible. Of course, McGraw Hill made a profit, but BYTE would be a lot more expensive if it were not for the ads.

One interesting point about the ads is that the time it took for a new technology to appear in the ads was usually much shorter than for it to appear in articles. In that sense, the ads were opportunities to peek into the near future (and, in the case of vaporware, alternate timelines).

I like the way magazines like BYTE are preserved and I hope we preserve our current tech as well.

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' :-)

[0] https://xlinux.nist.gov/dads/HTML/SchorrWaiteGraphMarking.ht...

[1] https://en.wikipedia.org/wiki/Lispkit_Lisp

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.


Byte Magazine – LISP (1979) - https://news.ycombinator.com/item?id=20008908 - May 2019 (67 comments)

BYTE Magazine's Lisp issue (1979) [pdf] - https://news.ycombinator.com/item?id=15033439 - Aug 2017 (151 comments)

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.

[1]: http://www-formal.stanford.edu/jmc/recursive.pdf

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 (<https://news.ycombinator.com/item?id=12448545&p=2#12454400>).

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 archive.org as well, e.g. https://archive.org/details/Radio-Craft . (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.

I loved the old Byte issues with the fun covers (I still want to buy prints of a couple like the AI and Smalltalk covers). This particular one was a bit funny because my mom thought it was more of that D&D crap[1]. Thinking about it, reading the DMG and articles about Lisp, might make me think she had a point.

1) I should point out that my parents never bought into that whole D&D is evil craze. Star Frontiers was "cute" though.

Amazingly enough, you can! Robert Tinney was the illustrator for many Byte covers from the 70s and 80s (though not sure if he did this one, based on the style). He used to have a website up, but if you check archive.org you can still find his email address. If you send him an email, he’ll let you know what cover prints are available and you can order them directly from him. I recently ordered 5.

Byte, in it's heyday, had the best cover illustrations of any magazine published before or since.

I would put The Saturday Evening Post cover illustrations by Norman Rockwell ahead of the Byte cover illustration.

For a certain crowd, I agree. The Saturday Evening Post covers spawned a homage set of covers with DC superheroes and villains that is very true to the original's spirit. I will say that in my youth the Byte covers were "better" because I didn't grow in a place that the SEP covers would invoke feelings of nostalgia or familiarity.

Love these ads. There were almost as many computer companies back then as there are crypto currencies now.

For a mere $1595, you got a 16k computer with microsoft basic but the best part is that it comes with 2 Z80 chips. Not sure how much a Z80 chip cost but surely the user would prefer an extra 8k or whatever. Best part is that you get to learn how the computer works by building it.

You can see why user testing is so important.

There are things I don't miss about the era -- good riddance to floppy disks and hard drive crashes -- but the PC world pre-IBM had so much latent possibility and sometimes just plain weird stuff:


> A major advance was announced in a press release dated October 25, 1975 in which the young specialty firm offered a relatively new and promising concept. The Hypercube was advertised as a four dimensional arrangement of dual 8080 processor "nodes" configured in 2x2x2x2, 3x3x3x3, and 4x4x4x4 arrays, with each node capable of communicating, via shared memory, with 8 adjacent nodes. This arrangement provided for the first processor in each node to handle system overhead and communications tasks while the second was left free to execute user code. The operating code was to be stored in ROM, and the total system promised unparalleled processing power at a fraction of the cost and overhead of mainframe machines from IBM, Honeywell, Boroughs, and other giants of the period. The advertised price of these three offerings was $80,000 for the Hypercube II, $400,000 for the Hypercube III (about 1/10th the cost of an IBM 370-168), and $1,280,000 for the Hypercube IV which was to be released in the second quarter of 1976. The concept was legitimized by publication in the December 11, 1975 issue of ELECTRONICS magazine. Ultimately, the U.S. Navy ordered a Hypercube II for installation in Huntsville, Alabama.

> good riddance to floppy disks and hard drive crashes

When did HD crashes go away? I still suffer through them.

And good riddance to serial ports and parallel printer ports. USB saved approx. fifty bazillion man-hours of hassle.

But cost about forty bazillion man-hours from people inserting the cables the wrong way.

I was a teenager, desperately looking for the cheapest possible system (because I couldn't afford any of them). And I would longingly read all the ads hoping a miracle wold happen. Later on I learned that one of those companies was named after the college dorm where the computer was conceived. So cool.

Totally have this and most other period Popular Electronics and BYTE’s in mah collection..all paid for with my lawn mowing money.

Like stacks of thoughts that got played and worn Used over and over till they were tired and torn

I never noticed before when this link has come up, but it lists a rescan in the description: https://archive.org/details/byte-magazine-1979-08-rescan

In my quick view, this is more cleaned up and easier to read at smaller sizes. (You might lose some of that "old magazine" feel, if you prefer that, though.)

I have a hard copy of this issue; it predated my subscription to Byte by a couple years, but I was able to purchase it as a back issue some time in the early 80s.

I threw out most of my Byte magazines from that era a long time ago (got tired of moving them around; they're big and heavy), but this issue and the Smalltalk one are two that I kept.

Interesting model of the brain https://archive.org/details/byte-magazine-1979-08/page/n69/m... Proving that scarcity forces you to think ahead. Could be very useful for AI/ML models today.

Always love the cheesy old computer mag ads.

But the "No Loose Ends" ad is pretty good. Probably the most modern sort of advertising, i.e based on an emotive pull, a dream, rather than every thing else that uses tech spec numbers, bigger is better.

Ah I miss the old Byte Magazine (like people miss the NES or PS1 etc). The ads looks completely insane with 2022 glasses on - who'd buy a random 64 KB ram extension for an S-100 bus? What was the market for this? Couldn't have been large.

The S-100 bus was popular with an early generation of machines with 8080 or Z-80 processors that ran CP/M, though there were a few counter examples.

By the time I started reading Byte at the public library (1980) there were a few computers that were mass market like the TRS-80, Apple ][, Commodore PET, TI-99/4A, etc. Mass market computers were talked about a lot in the editorial in Byte but Byte was also full of ads for more exotic machines aimed at OEMs, for instance to build a cash register system for a supermarket. Cromemco, for instance, advertised harder than anybody, but it was rare to see Cromemco and other exotics talked about in the articles.

Can you imagine cutting off the bottom 1/4 of a magazine page, writing your name and address on the order form, putting that in an envelope with a check and then waiting 6-8 weeks for your new memory card to show up in the mail?

Imagine? No. Remember? Yes.

And this in an era where there was no such thing as package tracking. You got your stuff when you got your stuff.

I've ordered a few things mail order this year because they were not available any other way. The wait doesn't bother me. Order confirmation comes when the bank tells me the check has been cashed. But the lack of package tracking causes mild anxiety.

Wow, what can you still order by mail but not online?

Most of it was art. Some from the artists. Some from auctions. When you get to a certain grade and price of certain items, online becomes a liability, not an asset. Too many scammers, I presume.

Also, some hand-made things. Custom paper and such.

Yeah, I mean who could possibly need more than 64kb of ram?

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact