rahen

"Personal computer" can refer either to a small-form computer, in which case the Olivetti P101 was likely the first in 1965 (the PDP-8/E was also a contender), or to a microprocessor-based computer, in which case the Micral N holds that title in 1973.

The Altair, in 1975, was the first commercially successful personal microcomputer.

Headlines like this make me glad that org-mode has almost completely replaced Word, Excel, PowerPoint, and OneNote for me (not to mention calendar notifications and Python notebooks). The only exception is spreadsheets with charts, which still require LibreOffice.

Granted, I don’t work in a corporate environment, so I’m free to choose my own tools. Living in Emacs is a blessing in today’s world of bloat, lack of control, short-lived cycles, and SaaS everything.

Those distributions either use neutered Google Play Services through a stub reimplementation (microG), or rely on sandboxing (GOS).

Either way, Google can only collect limited data on those distributions, and you have control over them. Concerning tracking applications, yes, some hygiene and good practices are necessary, the OS can only go so far.

These discussions seem to come up frequently lately. Both /e/OS and Lineage with microG provide good enough privacy for those who can't afford high-end smartphones like the Google Pixels.

The ranking would probably be:

- Pixel on GrapheneOS

- Any Android smartphone on Lineage or /e/OS

- iPhone on recent iOS (the best choice for technically illiterate people)

People concerned with privacy should avoid stock Android phones. Additionally, software only goes so far in protecting privacy. Some hygiene is also required, especially with iOS, where everything is sent to iCloud by default and E2E encryption is either not enabled by default or not available at all in some countries.

When it comes to hardware, nothing really compares to the Titan and T2 chips found in Pixels and iPhones though.

I definitely would switch to Lineage or /e/OS or anything more vanilla if I had a Samsung phone.

You absolutely can write something in C, Rust, Go, or whatever on Lineage. Just install Termux and the relevant packages (e.g., pkg install rust, etc.).

AOSP is still vanilla Linux under the hood, just with a touch interface on top. Plus, ART is open-source and works great for GUI apps.

Those are very relevant for a Linux laptop, but much less so for a Linux smartphone. An AOSP-based distro like LineageOS, GrapheneOS, or /e/OS paired with Termux provides almost a all of this, with the added benefit of ART - quite possibly the most polished runtime in the Linux ecosystem.

You can even plug a bluetooth keyboard and run Emacs on your Android / AOSP phone nowadays.

It's enabled on mine, at least. By default, it reboots after 18 hours without being unlocked.

Out of curiosity, do you happen to know which tools are most commonly used to generate those LaTeX papers? Is auctex still a thing nowadays?

Perl is becoming rare, but is LaTeX also falling out of use for technical papers? Most of the scientific and CS papers I’ve seen lately still seem to use it, even those coming from Microsoft.

That said, it's often generated via Org-mode or WYSIWYG tools these days.

Obligatory System Crafter videos:

- https://www.youtube.com/watch?v=f7xB2fFk1tQ

- https://www.youtube.com/watch?v=9gfKrrTtyOk

Try Guix System. The entire system, including PID 1, is configured in Scheme (Guile) and has a very nice Emacs-like hackability.

It’s exciting to hear that you’ve successfully run LISP and Spacewar on it, especially since the Verilog is based on the original schematics. That makes the PiDP-10 an actual KA-10 CPU, which is a big deal for authenticity.

I completely understand the difficulty with simulating peripherals. Perhaps the FPGA could focus on implementing the CPU, leaving the peripherals to a SIMH backend using a hybrid approach. A slightly longer PCB with space for both a DE10-nano and an RPi 0 might work out well.

Have you considered opening a discussion on VCFED or Google Groups to gather more ideas and see what others think? I’m sure many people would be excited to follow and contribute to that progress.

I'm looking forward to seeing how this develops.

Can't wait to see the PiDP-1! By the way, something I'm really looking forward to is the KA-10 FPGA implementation for the PiDP-10, rather than the less realistic SIMH simulator running on top of Linux/Raspberry Pi. It would be a true miniaturized PDP-10 CPU, not just a simulation. Do you know if this is still being worked on?

I'm pretty surprised by the claimed memory usage for 300B parameters (table 1). If we compare similar models:

- Llama 3.1 with 405B parameters: 2 TB of memory (FP32), 500 GB (FP8)

- DeepSeek R1 with 671B parameters: 1.3 TB (scaling linearly, around 600 GB for 300B parameters)

Ling claims no more than 96 GB of memory, most likely for inference. That's far more than a 20% reduction. Am I missing something?

Very nice to see him using eshell, which is a highly underrated shell: https://www.youtube.com/watch?v=9xLeqwl_7n0

With time, I find myself relying less and less on tmux and scripts, while increasingly using Elisp macros, Eshell, and Emacs-based applications more generally.

Those who see Emacs as a mere editor or as the ancestor of VS Code may also want to read these:

- https://protesilaos.com/codelog/2024-04-24-re-what-keeps-you...

- https://protesilaos.com/codelog/2019-12-20-vlog-switch-emacs...

Emacs provides a highly hackable and open TUI framework for digital sovereignty. Somehow, it embodies the spirit of free software. Just M-x your way through and shape it to your needs.

That's _GNU_ Emacs. The original Emacs is even older (1976), though back then it was still a set of TECO macros rather than a C core with Lisp macros.

Interestingly, the very first version of Emacs on the PDP-10 in 1976 was already developed by Richard Stallman.

Emacs keybindings are actually pretty nicely organized:

- M-x: What would now be called the Command Palette

- C-x: Global commands

- C-c: Custom keybinds

- C-h: Help keybinds

I see it the same way I see 'Applied Cryptography'. It’s old C code, but it helps you understand how things work under the hood far better than a modern black box ever could. And in the end, you become better at cryptography than you would by only reading modern, abstracted code.

edit: I was wrong, Delta Chat now has forward secrecy from v1.48: https://delta.chat/en/2024-11-20-webxdc-realtime

Furthermore metadata transparency can be made less problematic by using email aliases.

Here is a quick example of an application labeled as lightweight, which turns out to be a 500MB+ Electron monstrosity:

"MarkText is a lightweight, user-friendly Markdown editor that serves as a free and open-source alternative to Typora. It’s designed for everyday users who want a clean, intuitive experience."

https://myownsys.com/2024/11/24/everyone-should-have-a-free-...

On the positive side, the use of P2P and IMAP makes censorship difficult, which is a strong advantage in authoritarian regimes.

However this comes with serious trade-offs. PGP lacks forward secrecy: if a key leaks, all past messages can be decrypted. Also IMAP offers no metadata privacy, anyone can see who you email and how often.

Signal and WhatsApp are likely a step ahead in terms of privacy with their double ratchet encryption (https://en.wikipedia.org/wiki/Double_Ratchet_Algorithm).

Not only the Internet, but also its technologies. Electron apps bring older computers to their knees, and those apps are becoming ubiquitous (MS Teams, MS VS Code, Whatsapp, Signal...). Sometimes they are even labeled as "lightweight".

But isn't China the same? Tibet and Xinjiang are both nations with their own language and culture. I guess it wouldn’t be long until they became independent again if it weren’t for force and oppression.

DOS can also be a nice, predictable runtime for embedded or low-level systems, as long as you're running x86. Some implementations are even 64-bit clean, such as this one: https://github.com/dosemu2/fdpp.

I remember this project (https://jimhall.itch.io/toy-cpu), where the author shipped his emulator as a DOS binary instead of a web-based JavaScript version that would eventually break over time.

DOS can serve as a lightweight, efficient, and predictable runtime with extremely low system requirements and no need for updates. It can run on bare metal or as a WASM binary.

The development tools are small, free, and reproducible (e.g., Turbo C), ensuring that the code will still compile and run just fine even 10 years from now. Oh, and it also has some cool TUI libraries a la QuickBASIC. I’d argue it’s still a worthy option, if it’s not user-facing.

I would add the Honeywell 316/516 series to the list. The 316 was the first 16-bit minicomputer, still using DTL logic. The 516 used TTL and served as the IMP 'router' in the early ARPANET. They were fairly popular before the PDP-11 took over with its brillant architecture.

Cold latency is an issue with microservices. If you need to use Java, you'll likely end up using frameworks like Spring or Quarkus, which somewhat diminish the advantages of using the JVM and Java as a language.

At that point, you might as well start with Go from the beginning.

Agreed. For a long time, Cygwin was the best Unix userland. It also fit conveniently into a single folder, allowing multiple portable environments on the same machine. Mingw was pretty nice too.

Lightning uses incentives to keep nodes online, so it wouldn't be too difficult to leverage those incentives for Nostr with Zaps (earning a couple of sats per message for running a node and losing them if it goes offline for instance). However this would require a decentralized consensus system to assess node reputations.

I see no NIP for node incentives, perhaps this should be discussed further.

Have a look at Nostr: https://nostr.com/protocol