jonjacky

The article title is actually "How I use my terminal"

This has long been recognized in literature and philosophy. Friedrich Nietzsche described a 'will to ignorance':

a 'suddenly erupting decision in favor of ignorance, of deliberate exclusion, a shutting of one's windows, an internal No to this or that, a refusal to let things approach, a kind of state of defence against much that is knowable, a satisfaction with the dark, with the limiting horizon, a Yea and Amen to ignorance'.

quoted in 'To Know or Not to Know', by Costica Bradatan, review of Ignorance and Bliss: On Wanting Not to Know by Mark Lilla, in TLS Apr 25, 2025, p. 12

This is quite cool. The CPU has only four instructions, which can be applied to immediate arguments or run in sequence to get six more, which can then be used to write real programs!

This is the best comment -- with the best advice -- in this whole discussion.

(1993)

This post might be a response to yesterday's announcement of Microsoft's new Edit editor, which has some of the same features as kilo.

1. https://news.ycombinator.com/item?id=44031529

There is Wirth's 4 page guide, How to use the Oberon System

https://people.inf.ethz.ch/wirth/ProjectOberon/UsingOberon.p...

Also The Oberon Pi Quick Reference and System User Guide at this project page.

A much earlier (2012) attempt at a Python bytecode interpreter on an FPGA:

https://pycpu.wordpress.com/

"Running a very small subset of python on an FPGA is possible with pyCPU. The Python Hardware Processsor (pyCPU) is a implementation of a Hardware CPU in Myhdl. The CPU can directly execute something very similar to python bytecode (but only a very restricted instruction set). The Programcode for the CPU can therefore be written directly in python (very restricted parts of python) ..."

May be of interest: Flip [1][2], a logical framework in Python. A logical framework is a library for defining logics and writing applications such as theorem provers. One Flip application is a proof checker for entering and editing proofs in natural deduction style.

1. https://jon-jacky.github.io/FLiP/www/

2. https://github.com/jon-jacky/FLiP/

This 20-page paper on the Java Optimized Processor is quite interesting. It has been implemented on FPGAs:

https://www.jopdesign.com/doc/rtarch.pdf

via https://www.jopdesign.com/ which includes a link to the github repo --- with 20-year-old files!

A related font, Routed Gothic, linked and discussed previously: https://news.ycombinator.com/item?id=30190397

Also of interest, posted here a couple of years ago:

ATX-80 – ZX-80 computer clone with ATmega8 processor https://news.ycombinator.com/item?id=29569523

This is not an exact replica like the one linked above, but an ingenious DIY re-creation built with modern parts, including just two ICs, with an ATMega8 processor instead of a Z80. Not an emulation, but a complete rewrite of the original Z80 monitor and BASIC interpreter in AVR assembly.

In HN 4 months ago: https://news.ycombinator.com/item?id=41370020 152 comments, 612 points.

See also The Monospace Web: https://owickstrom.github.io/the-monospace-web/

Click on the [Book] link at the top of the page, then scroll down to the database book -- it's the second one -- and click on the [Read] link.

"Build a Commodore 64 from scratch" using modern parts. Very impressive, long detailed writeup, lots of photos.

Suprised it got no comments and only 2 points - maybe because it was posted on Christmas eve. Also posted two years ago, with 132 points and 19 comments:

https://news.ycombinator.com/item?id=34211922

Compare this to the LGP-30, a "small" (desk-sized) vacuum tube computer of the 1950s. It also had just 16 instructions. It nominally had some registers, but these were just locations on the same magnetic drum that stored all the other data.

https://en.wikipedia.org/wiki/LGP-30

Details of what happened here: http://ascii.textfiles.com/archives/5672

via HN: https://news.ycombinator.com/item?id=41288051

There were several more HN threads - just search for 'Living Computer Museum'

The answer to your question is, the people who made fortunes in this industry -- some of them in Seattle -- are not interested in the history of their industry, even when they made some of it.

It's a telling contrast to the wonderful Museum of Flight, also in Seattle.

The standard textbooks by historians are:

A History of Modern Computing by Paul Ceruzzi

There is a completely rewritten version of this with an additional author:

A New History of Modern Computing by Thomas Haigh and Paul Ceruzzi

Also:

Computer: A History of the Information Machine by Martin Campbell-Kelly and William Aspray

There are good books by journalists and popular writers. Favorites on HN are:

The Dream Machine -- you are already reading this. Also:

Hackers: Heroes of the Computer Revolution by Steven Levy

Where Wizards Stay Up Late: The Origins Of The Internet by Katie Hafner and Matthey Lyon

These and many many other books are recomended and described in this HN thread from a few years ago:

Ask HN: Computer Science/History Books? https://news.ycombinator.com/item?id=22692281

This is the Tate art museum catalog entry for a computer whose cabinet was designed by Richard Hamilton, the artist who created the famous 1956 pop art collage, "Just what is it that makes today's homes so different, so appealing?"

https://en.wikipedia.org/wiki/Just_what_is_it_that_makes_tod...

Also, there were other emacses that preceded GNU Emacs and were written from scratch: Bernard Greenberg's MULTICS Emacs, written in MacLisp [1], James Gosling's Unix Emacs, mostly written in C [2], and Daniel Weinreb's Zwei, written in Lisp Machine Lisp [3].

1.https://multicians.org/mepap.html

2.https://dl.acm.org/doi/10.1145/62402.62417

3.https://en.wikipedia.org/wiki/EINE_and_ZWEI

The Tulip Creative Computer[1][2] hits most of your points (I'm just a customer). It is definitely not a retro computer. It uses modern technology (ESP32S3 microcontroller with megabytes of flash memory and RAM, USB ports, wifi, color touch screen etc.) and runs a modern programming language (MicroPython) that also serves as the operating system.

This particular product might not be exactly what you want, but it shows that you can use these technologies to build a computer that is much simpler and more malleable than a modern PC in both hardware and software, but is still very capable, and intriguing to use.

1. https://github.com/shorepine/tulipcc 2. https://news.ycombinator.com/item?id=41122986

I think her character Prof. McGonagall in the Harry Potter movies drew heavily on her much earlier role as that other Scottish school teacher, Jean Brodie.

Those wide DECwriters were the standard console terminals for DEC systems in the late 1970s and early 1980s. It is the only kind of terminal shown on the cover and interior of DEC's VAX-11/780 Hardware Handbook [1] (especially see Preface p. x)

We had two of these, for our VAX 11/780 (delivered 1980) and PDP 11/23 (1981).

You wanted a printed record of everything that happened at the console. A system crash would print a register dump and other information that would scroll out of sight on a video terminal (there were no scrollback buffers then).

1. https://course.ece.cmu.edu/~ece447/s15/lib/exe/fetch.php?med...

Maybe kragen's admu, part of his BubbleOS suite:

https://gitlab.com/kragen/bubbleos

He writes:

An ADM-3A terminal emulator called admu, which works well enough to run vim, screen, or tmux in. It displays using Yeso [the BubbleOS GUI system], but the terminal emulation component is separable from Yeso, and is under 600 bytes of machine code — under 400 bytes on ARM with Thumb2. Because the ADM-3A is supported by terminfo and termcap, most Unix terminal handling works on it, except for color.

I recall reading that the original vi was developed on an ADM-3A.

Earlier projects with similar motivation:

OSKit (1999 - 2002) https://www-old.cs.utah.edu/flux/oskit/

Pintos (up to 2018, used in computer science courses) https://web.stanford.edu/class/cs140/projects/pintos/

Old guy here -- I came of age in the PDP-11 era. I thought it was funny, just a gentle parody of a certain Im-being-patient writing style.

I am sure the author does not really believe older people can't understand CHERI. One of the original contributors to CHERI is Peter G. Neumann, born 1932, programming since the 1950s. Chisnall (the author of this piece) and Neumann are among the co-authors of a paper on CHERI presented at ASPLOS'24 this year [1]

I guess this shows the risk in using humor in scientific writing -- you never know how it will land.

[1] https://www.cl.cam.ac.uk/research/security/ctsrd/cheri/cheri...

I see there is a desktop version prebuilt for Mac OS 10.15 or higher, or you can build it for Linux:

https://github.com/shorepine/tulipcc/blob/main/docs/tulip_de...

There was a post about it with exactly that title a year ago, and it got no comments until I made one:

https://news.ycombinator.com/item?id=34797041

I repeat what I wrote then -- this is very impressive! Especially that it runs Python without a conventional OS, I would expect that alone should get some attention on HN.

Yes, it had a variable word length - a number was a string of decimal digits of any length, with a terminator at the end, kind of like a C character string.

Machine code including instructions and data was all printable characters, so you could punch an executable program right onto a card, no translation needed. You could put a card in the reader, press a button, and the card image would be read into memory and executed, no OS needed. Some useful utilities -- list a card deck on the printer, copy a card deck to tape -- fit on a single card.

https://en.wikipedia.org/wiki/IBM_1401