asmttpd

I really like this. I have written a comment previously about it recently (https://news.ycombinator.com/item?id=47548393) but essentially, I believe that the more tooling/projects within this space, the better. I have had an idea recently where I can use something like https://github.com/nemasu/asmttpd (assembly webserver) created by nemasu (they are on HN with same name) and deploying this under container from:scratch or gvisor on a single Virtual machine to have thousands of isolated git still on a more safer degree. Asmttpd has made me gone into a rabbit hole of finding minimalist ways to create web servers but I don't know asm/low-level. I kinda wish to Try Zig for a project like this but I have been unable to really get the feels of running a web server on anything low level (Rust requires lots of deps etc.), I really love golang for

I love blog posts like these: they don't go after real-world problems directly but rather explore what's even possible. paulfurtado in this comment section mentioned UPX[0] as a way to get binaries even smaller. Funnily enough UPX even managed to decrease the size of the asmttpd web server for me: ### build stage ### FROM ubuntu:18.04 as builder RUN apt update RUN apt install -y make yasm as31 nasm binutils git RUN git clone https://github.com/nemasu/asmttpd.git asmttpd RUN mv asmttpd/* . RUN rm -rd asmttpd RUN make release # i have the upx binary on my machine in this case COPY ./upx-3.96-amd64_linux/upx upx RUN ./upx --brute asmttpd ### run stage ### FROM scratch COPY --from=builder /asmttpd /asmttpd COPY ./index.html /web_root/index.html CMD ["/asmttpd", "/web_ro

I love assembly! I think if you know C/C++ it's not too difficult to learn. One thing I noticed is, it can be a bit rough coming back to an old project, I thought I had left enough comments on one of my projects (https://github.com/nemasu/asmttpd), but I was still scratching my head a bit in some places.

Reminded me of people making docker containers out of this: https://github.com/nemasu/asmttpd eg. https://hub.docker.com/r/0xff/asmttpd/ 7KB web server container.

I'll try and get this building for OSX. For the uninitiated, might I recommend my: http://nickdesaulniers.github.io/blog/2014/04/18/lets-write-... Though, this is written in yasm syntax, which is slightly different. Also, keep an eye out for a blog post on Interpreters, Compilers, and JITs I'm working on (cleaning it up and getting it peer reviewed this or next week)! update 1 Actually, would the syscall's be different between Linux and OSX? Let's find out, once this builds! hammers away update 2 Got it building and linking. bus error when run, debugging with gdb. update3 Can't generate dwarf2 debug symbols for OSX? $ yasm -g dwarf2 update 4 Careful, this tries to listen on port 80 [0] (0x5000 (LE) == 5*16^1 == 80), I would never run any assembly program off the web with elevated privileges. I recommend 0xB8B0 (LE, port 3000). update 5

Perhaps I am searching too closely for parallels here, but what would be the analogue of this from a software engineering perspective? Maybe writing something like an HTTP server in assembly, or something? I remember this (https://github.com/nemasu/asmttpd) popping up on HN some time ago. Writing your own kernel, or compiler? Building your own 8-bit microcomputer, and then running something on it? (A project like that was part of a course I took at college, and it did a decent job at demystifying many common concepts about computing).

Pretty neat! It's awesome how assembly these days is reasonably high level: https://github.com/nemasu/asmttpd/blob/master/http.asm It dawns on me why we couldn't have shortcuts for several patterns that show up everywhere: - mov, mov, mov then call/syscall could just be written as call(arg, arg, arg) since it's not that difficult to figure out which argument needs to go to which register if there was a defined order of arguments. - push push push push <function body> pop pop pop pop <ret> could just be a define really. I realize that there are cases where you wouldn't necessarily do that, but that seems to be the minority. The compiler could just figure out what registers you use in the routine and push / pop those. If you want to keep a register, there could be added syntax for that. It seems in both of these cases the language optimizes