Nir Lichtman's 12-minute Linux Distribution Video

With BusyBox for the user mode utilities and Syslinux for the bootloader. It takes a lot of work to do a demonstration like this, because you typically have try a bunch of things that don't work before you get to a bit that does!

See this comment: 

What would be good would be to find a way to "naturally fork" full distributions to create cut-down ones for specific purposes. The way the Debian project works makes this very difficult, and Raspbian is based on Debian. This is one of the goals that René Rebe had when he made T/2 2.0. See his book T2 System Development Environment Creating custom Linux solutions: 

T2 is not yet another Linux distribution: It is a flexible System Development Environment allowing not only the automated rebuild to create a new version or to optimize for the target CPU in use, it even allows the creation of adapted distributions. The level of adaptation reaches from simple package selection ..., special purpose patches ..., custom output format (such as Live-CD or ROM image for embedded systems) to tight integration with 3rd party administration, management, networking or other software. In summary T2 is an integrated development environment for custom distributions.

See also https://buildroot.org/:

Buildroot is a simple, efficient and easy-to-use tool to generate embedded Linux systems through cross-compilation.

He did a video about that too, and it's only 8 minutes:

 

Subscribe to Nir Lichtman.

I came here because I have been trying for months to get a Raspberry Pi Zero 2 W to act as a home router. I first tried OpenWrt but it didn't boot when I installed the "factory image" and I found it incomprehensible: see https://openwrt.org/docs/start.

What I have managed so far, is a set of steps that get something which is very nearly working, but it uses Raspios Lite which is over 2GB and includes NetworkManager and systemd and goodness only knows what else. All this thing needs to do is set up a Broadcom wifi and USB ethernet connection and transfer packets between them, and I'm quite sure that this could be done with less than 8KB of machine code. The problem is writing that 8KB of machine code; but I have a laptop with 8 CPU cores and 16 GB of RAM, so I think it ought to be possible to write software that runs on my laptop and creates the necessary 8KB of code and loads it onto the SD card that the Raspberry Pi Zero boots from. This would have the advantage that if somebody wanted to hack the router/firewall then they would need to upload their own binaries in order to be able do anything useful to them. See Eron Woolf on Why Open Source is Failing.

The thing is that the open source code has all of the information necessary to enable me to write that program, but it is not in a form that is easily ingestible by a program (or even a human being reading the source code). The reason for this is that the source code is modular and relies on libraries, API's and other concrete representations of the semantics of the hardware devices in the target machine. None of these things is actually essential, but they each need to be interpreted in order to abstract the semantics of the hardware. This is what I tried (and totally failed) to explain to Richard Stallman in an fairly protracted email exchange I had with him and others in 2014. This was my follow-up to this proposal for a GNU project, called GNU Thunder which I sent initially to Richard Stallman, Linus Torvalds and Theo de Raadt, and when I received luke-warm response from Stallman, and nothing from Torvalds, and "Bye bye" from De Raadt, I took it to the developers of GNU Guile and GNU Lightning which I judged to be the closest extant projects to the conception I had.

I was pleasantly surprised to hear that IOHK had funded Philip Wadler and others to work on a formalisation of System-Fωμ as a basis for the Plutus language. See System-F in Agda for Fun and Profit by James Chapman, Roman Kireev, Chad Nester, and Philip Wadler (2019). The paper Unraveling Recursion: Compiling an IR with Recursion to System F by Peyton-Jones et al. (2019) explains why they used System-Fωμ rather than plain System-F. But I don't think we  need intermediate representations with recursive data types on running hardware, in fact such things tend to develop unnecessary clutter in memory and require other complications such as garbage collectors and non-deterministic behaviour, which you don't really want in a secure system. I would prefer to compile code that just implemented π-calculus processes in terms of total functions with computable time and space guarantees. See Alice's Adventures In The Wonderland Wide Web.

In fact Linux and u-boot had been using abstract Device Tree Specifications since around 2013. This is only describing the hardware at the level of interfaces, registers and interrupts though, they do not describe anything about the device semantics or how a given system interfaces with those devices.

Subscribe to Bootlin.

People are doing good work on collaborative development environments, but it's hard to find it amidst all the hyped AI BS going around these days:

Here's a followup: see https://www.inkandswitch.com/ and https://seed.hyper.media/
 

Mintterteam/mintter has gone, but see https://github.com/mintterteam.

Subscribe to IPFS.