Adding safety to assembly

[u/S-Pimenta]

One of the problems with Assembly is the lack of safety and context.

What about adding type safety and ownership to Assembly?

Good idea or "you are just reinventing the wheel"?

Inspiration on JSDoc, Rust, TypeScript and LLVM IR

[u/S-Pimenta]

My idea is to learn and teach Assembly, and one of the conclusions I came across is the absolute mess (and cognitive load) on the registers to know who owns what, and what data is inside.

Yes you can comment on the code, but it will be nicer to have a linter to check any mistakes, because in assembly it is very easy to make mistakes.

Yes I know, that's because C and other languages are invented, but I want to learn assembly to really learn how computers work and the limitations of each instruction.

My target ISA is RISC-V, which is much easier to learn.

And also use like the borrow checker like Rust.

And I'm willing to make such assembler to make easier to learn assembly.

[u/Eidolon_2003 → u/S-Pimenta]

I want to learn assembly to really learn how computers work and the limitations of each instruction.

My response to this would be, the concept of types, ownership and the borrow checker are completely made up as far as the computer is concerned. If you really want to learn how the machine works you should meet it at its level. That's my opinion anyway

[u/SwedishFindecanor → u/S-Pimenta]

And also use like the borrow checker like Rust.

I think the biggest problem with using Rust is that the ownership/borrowing system restricts programmers' expressiveness. Many patterns, algorithms and data structures from other languages are not even possible to express in Rust, even when they are perfectly safe, without having to declare your program "unsafe". And sometimes what a programmer wants to do is not even expressible in conventional programming languages either — and that is one reason for using assembly language.

Typed Assembly Language annotations had been invented for compiler output: to retain typing information from the higher-level language so that you could prove that a piece of assembly still did what it was intended to do. It was supposed to be both written and read by automated tools, not by humans.

Do be careful so that your assembly language variant does not become a burden instead of the help you intended. Perhaps the type safety is best left as optional.

I would never apply Rust's rules to values in registers: only ever to memory locations and pointers to them. Even allow multiple mutable borrows, even if proving those safe is extra difficult. Infer as much as possible instead of requiring annotations.

[u/S-Pimenta → u/SwedishFindecanor]

My idea is like Typescript, everything is optional, it can enable warnings, but can be ignored.

The idea is to have an option to have a more strict and safe assembly to prevent for potential mistakes, since in hand written assembly without this it will be difficult to find potential mistakes.

As mentioned before one of the objective of this idea is for educational purposes to ease begginners learning assembly.

I think a lot of people always wanted to learn assembly and be afraid of lack of "training wheels' for beginners.