the-super-tiny-compiler VS bocker

Now, those concepts are a whole entire world to explore, and this is out of the scope of this article. I suggest the reading of the Chapters 4, 5 and 6 of the book Crafting Interpreters by Robert Nystrom for a wider (but still practical) understanding of those subjects. Another practical great resource to look at is The SuperTiny Compiler. To explore them from a theorical point of view, you can find A LOT of resources from books or courses online.

The super tiny compiler by Jamie

I am currently writing a much more intricate version of the Super Tiny Compiler (https://github.com/jamiebuilds/the-super-tiny-compiler) in Rust, only I plan on handling many basic operations, essentially a compiler for a MUCH simpler version of Go. Great project idea btw, for anyone who wants to explore compilers. But in doing so, have really found a new respect for just what is going on when you gcc -o garbageprogram mytrashcode.c

Here, at least take this floatie: https://github.com/jamiebuilds/the-super-tiny-compiler

Outside of this, I recently learned about The Super Tiny Compiler which was a project written to be read. Mind you, it has a vast amount of comments, which may be more of a leg-up than you're asking for.

You could start here:

https://github.com/jamiebuilds/the-super-tiny-compiler

That converts from lisp-like to javascript. Really though this is a big field, and there are lots of resources out there.

To get started look at your input language; you'll need to lex and parse that. Then massage the parsed structure into the appropriate output.

You can see me convert brainfuck to C, or x86 assembly language here:

https://github.com/skx/bfcc

A (joke?) one-liner I came up with while thinking about solutions to centralized container management across multiple SSH hosts. Shame on me.

The name is inspired by bocker [0], albeit this doesn't re-implement docker-compose in bash, I found it to be fitting enough.

I'd love to see someone come up with a smarter and/or shorter way to do this.

[0] https://github.com/p8952/bocker

When I did a talk about docker I also wanted to show a bit of what it does under the hood without going through all the layers and without too much details. This ~120 lines of shell script is really good in providing just an intro into what's needed for containers: https://github.com/p8952/bocker/blob/master/bocker

i tried it and like the concnpt, but until it can be launched via a systemd userspace service (without previously manually booting it) among other problems i will keep using docker (or bocker)

> But you couldn't reimplement podman in a few hundred lines of code.

You don't even need a few hundred: https://github.com/p8952/bocker

And then there's 'dokku' which IIRC, started as a bash version of Heroku.

> Not all ideas have the same quality.

They really do. I've heard all kinds of things in my career, but almost none I would want to dedicate a portion of my life building. Not because they are bad ideas or won't work, but because of the person with the idea or it just didn't interest me. Those people went on to be moderately successful (like hundreds of millions worth) but I'm glad I wasn't on that ride.

Bocker is in this same category...docker clone in bash that's helpful in seeing what's really happening underneath with nsenter, namespaces, network bridging, cgroups, etc.

https://github.com/p8952/bocker

Docker implemented in around 100 lines of bash: https://github.com/p8952/bocker

This is the most mindblowing example for enterprise security teams that think Docker is a new threat on a single tenant Linux host.

No, buddies, all this stuff is already there. If you were fine with your visibility before*, you're still fine. Go find a real problem while we play with our developer dopamine.

* NARRATOR: They shouldn't have been.

Bocker[1] does a reasonably good job of showing the value of Docker was mostly in Docker hub.

[1] https://github.com/p8952/bocker

There is a cool project I've seen called "bocker" (https://github.com/p8952/bocker) which is something of a proof of concept of implementing Docker with bash, which speaks a bit to how Docker is indeed in many ways an amalgam of lower level primitives (such as chroot as you mentioned). Pretty neat!