Redshirt is a research operating system written in Rust. It executes WASM binaries and can theoretically obtain them from a decentralised network.

Any program in Redshirt can declare that it implements some interface and OS will use the program to handle requests corresponding to the interface. For example such a program can work as a filesystem server or a TCP/IP stack.

Interfaces and programs in Redshirt are uniquely identified by their hashes, it allows to store the programs in an IPFS-like distributed database.

https://github.com/tomaka/redshirt

One old blog post about register allocation in CompCert.

http://gallium.inria.fr/blog/register-allocation/

I didn't consider WebAssembly seriously and thought that this technology was tightly connected to JavaScript and WEB browsers. Fortunately, I was totally wrong!

WASM is a modern low-level representation for portable executables. It is compact, efficient and compatible with "unsafe" programming languages like C and C++.

There are research projects developing WASM-based operating systems or firmwares for small devices. Many programming languages can be compiled to WASM. This is a very promising technology.

Today I would like to share a link to a small introductory article about WASM.

https://rsms.me/wasm-intro

I already wrote about bearssl, but it was a surprise for me that a huge part of the library was implemented in T0 - a special concatenative programming language with concurrency and memory safety features.

That language influenced another one, T1. T1 is type and memory safe, it provides a number of static guarantees, supports OOP, garbage collection and a kind of metaprogramming.

https://t1lang.github.io/

Bootstrapping a whole operating system from a simple in-memory monitor or debugger is a very catching topic. Just imagine: everything you have is just your hardware with some minimal firmware preloaded, just to give you an ability to edit data in memory, execute it and store somewhere. Could you start with these tools and develop or just build an existing modern operating system?

The Mes project aims to bootstrap the modern GNU toolchain starting from the bare minimum.

https://www.gnu.org/software/mes/

There is also an old conversation on Reddit which is related to the topic.

https://www.reddit.com/r/programming/comments/9x15g/programming_thought_experiment_stuck_in_a_room/

I have been using different text editors, most of them are lightweight and easy to modify: nano, vis, edit (by Quentin Carbonneaux). The only one exception is vim, which is a typical example of bloated software, but situation becomes better, thanks to neovim.

Looks like I just found a new favourite, its name is Lite. This editor is made with C and Lua, but Lua here is used not only as a noscripting language for plugins, almost everything is written in Lua: object system, UI, text view, command system, all the mechinics laying behind a good text editor. Only a small portion of code is written in C: drawing of rectangles, STB-based font rendering and input handling. Lite is really simple to study and modify, it is blazing fast and user friendly.

https://github.com/rxi/lite

Quibble is an open source bootloader for MS Windows capable to load all the versions between XP and 10.

https://github.com/maharmstone/quibble/blob/master/README.md

PagedOut is a cool e-magazine with a simple idea: every article fits to only one A4 page. The main topics are hacking, programming, retro computing, electronics and the demoscene.

https://pagedout.institute/

There are many good books on construction of compilers, but lots of them are just theoretical or suggest to use various high-level instruments like scanner and parser generators, existing compiler backends, etc.

The next free book is little bit old-fashioned, but it is still relevant. It follows the idea that practical approach to studying is the best one.

Did you read about bottom-up parsing? Nice, so try to implement a LALR parser generator similar to YACC in ANSI C. How about implementation of a whole C compiler and a bunch of tools that simplify the development? This book shows how to do it.

https://holub.com/compiler

Writing unit tests in C is a difficult matter. The most crazy part is mocking functions and complex data structures. The following article gradually shows various ways to mock functions in C programs.

The authors start with a simple macro-based approach but they try to make mocking more convenient and eventually finish with a bunch of trampoline wrappers written in assembly language.

https://locklessinc.com/articles/mocking/

The following article about Glush parser generator includes a perfect retrospective overview of existing parsing methods for context-free grammars.

https://www.sanity.io/blog/why-we-wrote-yet-another-parser-compiler

Have you heard about SWEET16? That was a meta-processor (virtual machine) written by Steve Wozniak for Apple II. Thanks to this technology it was easier to bring 16-bit operations to MOS 6502, a popular 8-bit processor.

http://www.6502.org/source/interpreters/sweet16.htm

Advent of Computing is a good podcast about history of hardware, software and programming languages.

http://adventofcomputing.libsyn.com/

A good introduction to typesystems based on linear types.

http://pauillac.inria.fr/~fpottier/slides/fpottier-2007-05-linear-bestiary.pdf

There are two well-known libraries for rasterization of TrueType fonts. The first one is FreeType which can be found in dependencies of almost any widely used free software that shows text on the screen. The second one is stb_ttf - a lightweight and portable rasterizer which is used primarily in computer games and small-footprint applications. Both libraries are examples of good software, but they are complex enough for studying by people unfamiliar with font rasterization.

The following git repository contains a tiny library for straight and dirty rasterization of TrueType fonts. It is buggy, especially the demonstration tool, but it shows how simple any rasterizer is in essence.

https://github.com/ZhUyU1997/ttf

When I started to work with Intel and AMD virtualization technologies there was only official documentation provided by the vendors. Times change: now you can read about development of hypervisors even in blogs. There are lots of good open source hypervisors and virtual machines to study.

Today I would like to share a link to a good tutorial. This shows how a simple hypervisor can be developed from scratch for the Windows kernel.

https://rayanfam.com/tutorials/

A good guide on studying logic for philosophers and mathematicians that includes recommendations of books and articles about the following topics: intro to logic, first order logic, elementary model theory, basic set theory, second order logic, intuitionist logic, modal and other logics, proof theory, computability, incompleteness, theories of arithmetic, serious set theory.

https://www.logicmatters.net/wp-content/uploads/2019/12/TeachYourselfLogic2020.pdf

LÖVE 2D is a simple and compact engine with permissive license that allows developing 2D and 3D games in Lua. LÖVE is available for all popular desktop and mobile platforms.

https://love2d.org/

There is a compiler for Lua 5.2 written in Lua itself!

https://github.com/leegao/LuaInLua

I always liked TeX but I was scared by the size of its distributions like TeX Live. To create a simple document with cyrillic you need to download lots of packages (more than 600 megabytes).

I tried to find an alternative, mastered troff and used its modern incarnations like neatroff and heirloom documentation tools. Troff is minimalistic, and its capabilities are no less than TeX's. At the same time a typical distribution size is a couple of megabytes including macro packages.

But I gave up, troff is incredibly archaic. To begin with, it does not tell you when you made a mistake in control structures. If troff does not know how to interpret a command, he tries to quickly throw it away and move on. You don’t see where you made a mistake, and the layout becomes broken in an unobvious way. And the fact that all commands have two characters in length does not add convenience. The worst thing is when you use arithmetic expressions with brackets and built-in registers:

.if (\\n(nl+1v)>(\\n(.p+\\ny) \
...

The brackets in the example above are balanced! The last straw was a bunch of errors in neatroff, which I caught trying to write my macro package. Enough, back to TeX.

Recently I found a noscript to download the minimum and orthogonal set of TeX Live packages and install it in the home directory. Only 150 megabytes.

https://yihui.org/tinytex/

Looks like there are a number of bots among the subscribers of this channel. So, I'll do some cleanup, the members counter will be decreased a little. Don't be scared.