AsmBB – a lightweight web forum engine written in assembly language

That's the difference between a programmer and a real engineer: an engineer doesn't need any help from dependencies to make his code totally insecure.

not only are they almost never subject to the kinds of security problems we commonly associate with low-level languages like assembly or c (for example, buffer overflows and heap corruption) they also commonly need to run in constant time to prevent timing side-channel information leaks, and while that is not trivial to achieve in any language, it's more feasible in assembly than in c. also, they are commonly a performance bottleneck, and they commonly need kinds of bit manipulations that c is typically slow at, which rewards assembly implementations

openssl in particular contains about 85000 lines of assembly language, mostly embedded in perl files. (it uses perl as a sort of alternative macro assembler)

HTTP is fairly trivial as well; if you're afraid of little things like that, you'll never deliver best-in-class software.

In the same way children are expected to respect fire :-P

A basic implementation of that is totally possible in assembly with no calls to c libraries. Would even be a great project for people to learn some systems programming. Keep in mind, all of these protocols (except maybe web sockets) were designed when programming in assembler was common. There's probably some HTTP implementation in the wild doing the same thing.

That said there's a lot of reasons you probably don't want to do that, HTTP can be subtle and you probably don't want to be doing raw clone3 calls to spawn threads, if you want to be doing thread or process per connection in the first place.

You can certainly write your own TCP/IP stack with raw sockets and directly interface with the NIC, if you like. But at that point you're both reinventing the wheel and bypassing the entirety of the OS, you might as well just write a forum exokernel.

Most developers don't consider utilizing a library in another language as "cheating". Popular and core Rust, D, C++, Python, nodeJS, etc libraries do this all the time.

  > Argument words are pushed onto the stack in reverse order (that is, the
  > rightmost argument in C call syntax has the highest address), preserving the
  > stack’s word alignment. All incoming arguments appear on the stack, resid-
  > ing in the stack frame of the caller.

[0] https://www.uclibc.org/docs/psABI-x86_64.pdf

[1] https://www.sco.com/developers/devspecs/abi386-4.pdf

Just because there's an IR within the compiler doesn't mean there's no "assemble" stage. What do you think the "-pipe" flag to gcc is for? It pipes the compiler output into the assembler, rather than using a temporary .s file.

gcc has four main stages going from source to executable: preprocessor->compiler->assembler->linker.

Edit, for your convenience, gcc -save-temps example:

  > [user@host /tmp/foo]$ ls
  > f.c
  > [user@host /tmp/foo]$ cat f.c
  > #include <stdio.h>
  >
  > int main(int argc, char **argv)
  > {
  >         puts("Hello world!");
  >
  >         return 0;
  > }
  > [user@host /tmp/foo]$ gcc -o f -save-temps f.c
  > [user@host /tmp/foo]$ ls -l
  > total 48
  > -rwxr-xr-x 1 user user 15416 Jan 13 16:50 f
  > -rw-r--r-- 1 user user    91 Jan 13 16:49 f.c 
  > -rw-r--r-- 1 user user 17145 Jan 13 16:50 f.i 
  > -rw-r--r-- 1 user user  1496 Jan 13 16:50 f.o 
  > -rw-r--r-- 1 user user   515 Jan 13 16:50 f.s 
  > [user@host /tmp/foo]$ cat f.s
  >         .file   "f.c"
  >         .text
  >         .section        .rodata
  > .LC0:
  >         .string "Hello world!"
  >         .text
  >         .globl  main
  >         .type   main, @function
  > main:
  > .LFB0:
  >         .cfi_startproc
  >         pushq   %rbp
  >         .cfi_def_cfa_offset 16
  >         .cfi_offset 6, -16
  >         movq    %rsp, %rbp
  >         .cfi_def_cfa_register 6
  >         subq    $16, %rsp
  >         movl    %edi, -4(%rbp)
  >         movq    %rsi, -16(%rbp)
  >         leaq    .LC0(%rip), %rax
  >         movq    %rax, %rdi
  >         call    puts@PLT
  >         movl    $0, %eax
  >         leave
  >         .cfi_def_cfa 7, 8
  >         ret
  >         .cfi_endproc
  > .LFE0:
  >         .size   main, .-main
  >         .ident  "GCC: (GNU) 13.1.1 20230429"
  >         .section        .note.GNU-stack,"",@progbits
  > [user@host /tmp/foo]$ ./f
  > Hello world!
  > [user@host /tmp/foo]$ 
  >

> Splitting hairs

> > generally

smh

https://en.wikipedia.org/wiki/Compiler#Three-stage_compiler_...

https://github.com/CyberShadow/DFeed/blob/master/dub.sdl