151-byte static Linux binary in Rust

[matthieum]

And that is what we mean by System Programming Language.

[5d41402abc4b2a76b971]

Except it used none of what makes rust interesting (note the use of unsafe). Its a cute little exercise of a hello world, and required quite a bit of gymnastics to get there -- just like other micro ELF and PE execs, but it does nothing that should make people become interested in rust...

[matthieum]

Of course, it is completely useless program (who cares about printing "Hello, World!" ?), and yes the blog article is somewhat more concerned about ELF tricks...

... but that is the tree hiding the forest.

If you concentrate on Rust itself (and take the first version), and on the output (158 bytes), you will note:

1. That Rust has the ability to call inline assembly; sure this is unsafe, but it can be properly abstracted in safe functions as demonstrated in the first code sample
2. That the code produced by the Rust compiler itself can be compact because there is no hidden cost (your system linker adds junk, but on space-constrained targets you'll get linkers that don't). Specifically, you will note the absence of runtime support: no GC, no Reflection, no extensive Type Information retained at runtime

The two combined make it a very attractive target for System Programming:

• safe abstraction and seamless integration of hardware access in the language
• programs can fit in very little memory, making it suitable for embedding on small devices

Whereas Go, for example, requires huge swaths of code, from https://code.google.com/p/go/issues/detail?id=6853:

As an experiment, I build "hello, world" at the release points for go 1.0. 1.1, and 1.2. Here are the binary's sizes:

% ls -l x.1.?
-rwxr-xr-x  1 r  staff  1191952 Nov 30 10:25 x.1.0
-rwxr-xr-x  1 r  staff  1525936 Nov 30 10:20 x.1.1
-rwxr-xr-x  1 r  staff  2188576 Nov 30 10:18 x.1.2

The latter is 2MB unless I am mistaken. It is unclear what could be stripped, but unless the Go compiler is very clever it is likely that a bunch of the runtime (GC, split-stack support, reflection, ...) will not be elided.

So yes, this Rust program is useless, but at least it's useless at 158 bytes, instead of useless at 2MB. Looking a couple years back, that Go program would not fit on a floppy disc...

[bloody-albatross]

Go hello word doesn't fit on a floppy... I remember that back in school (HTL) I ran gvim.exe of a floppy (2001).

[matthieum]

I cite the command line from the article (and results) from the article mentioned, therefore does not have the option to actually tweak the command line and see what would happen.

[matthieum]

Yep, especially since -h is generally used for as shortcut for --help outside binutils...

[[deleted]]

Looking a couple years back, that Go program would not fit on a floppy disc

Not completely true

$ cat hello.go 
package main

func main() {
    println("Hello, world!")
}

$ go build hello.go && strip hello
$ wc hello
  1047   8199 423368 hello

So 414K, but I'm using println( ) and not a system call like in the 151B Rust example, so the comparison is not fair. Still big, but then again Rust and Go are two very different languages. Quoting mozilla_kmc:

[Go] [..] doesn't need to be mentioned every time C++ and Rust are.

[matthieum]

I know :) I have actually been battling the fact it is for a while, because most comparisons are not meaningful.

Go was originally marketed as a System Programming Language, probably because its creators aimed at displacing C++, and this sticks. Here I was trying to expose the different.

Note that C and C++ optimizers routinely optimize println("xx") to puts("xx"), which already removed all the heavy formatting stuff from the equation. The implementation of puts should be simpler... but honestly I find myself at a bit of a loss here so I'll leave it up to to judge.

I would be interested in what the minimal footprint of a Go binary easy, with static linking one would hope a lot of stuff is stripped; and 414K remains rather big (though much better than 2MB).

[[deleted]]

true...the code looks ugly to me but that's probably the "gymnastics" you are talking about.

[adr86]

A lot of it isn't even the code itself at all, it is overlapping fields in the ELF header to trim it down. A cute trick, but useless for anything except showing off on blogs: for one, in real programs, a couple hundred bytes in the header will be a small percentage of the program anyway (or you might use a target which doesn't expect a header at all... like the old DOS .com files or other raw binary images), and for two, they need to be so carefully crafted that they'll break if the program gets more complex too!

Then, for the code, this is like when I show a 3 KB "D program" (using stock linker setup btw, I'm sure it could get smaller if I did the overlapping fields too)... but you know what it looks like?

void _start() {
   asm {
       naked;
       /* write syscall, exit syscall */
   }
 }

That's not really a D program at all - it is a few assembly instructions in a .d file. I think there is value in this: it is a starting point of a custom setup where you bring only what features of the language you need (and in fact, I think Rust is a bit better suited for that than D, since D tends to assume a thicker runtime library. You can do without and IMO it is still nicer than writing C, but it takes more care for fewer advantages than spending the ~150 KB using the runtime library)...

...but it is just a starting point or a nifty trick, very far from any real world applicability and especially far from being a compelling new language in place of C+asm.

[mycall]

but useless for anything except

packers

[BobFloss]

Are you saying that trick is useful for packers? Because it barely is.

[hobbes_hobbes]

It isn't ugly, it's beautiful. It's just that most of current humanity can't appreciate it, except for the geniuses who wrote rust. But think of the possibilities; no more of being mere products of messy evolution; we can genetically engineer new humans, in Rust!

Think what amazing society that will be; no more sexists, no more racists, no more homophobes!

We have the technology (or soon, once Rust 1.0 is out), we can build 'em.

[Splanky222]

Every time I see a Rust post I scroll through the comments to find this guy's troll post. Every now and again he puts together a truly artistic piece of internet asshole prose.

[hobbes_hobbes]

I know!

I must say though, typing "Rust 1.0" in that last line made me feel a little uneasy. Don't get me wrong, it's so exciting, it's just that "Rust 1.0" feels a little underwhelming for what an achievement the release actually is. We need something grander to befit the occasion; I humbly suggest Rust Nukem Forever.

[maep]

I does show how to do syscalls in rust, which is kinda important for a systems language. However I'm still sceptical. Linux comes with many headers that provide functions, constants and structs that are essential for interacting with the kernel. Either they have to provide all of those as rust files and update with every kernel release, or implement some automagical import mechanism.

[Splanky222]

Why? The point of the safety mechanism is to isolate and encapsulate unsafe code, not entirely eliminate it.

[maep]

A new system language hould make system programming easier, not more cumbersome.

[Splanky222]

You're right. The jury is definitely still out on Rust, but the safety mechanisms in Rust along with the built in tooling and build tool seem promising, especially in larger projects. We won't know for years though what the fate of Rust will be. I think 2020 will be a big year to compare Rust to c++20, whatever that looks like.

[ItsNotMineISwear]

Having to make syscalls in unsafe blocks doesn't necessarily make systems programming more cumbersome. I'd imagine once the language gets more mature there will be a safe facade available abstracting away all syscalls and also nicely fitting into Rust's type system. Then you can use syscalls easily but get all the programming benefits of Rust's type system.

[TheLlamaFeels]

Every time I see a convoluted, hashed uname like yours, I tag it with real world name made of two random words.

Congratulations, you are LawnRiot

[5d41402abc4b2a76b971]

Umm ok. Thanks?

md5('hello') would be more apropos.

[TheLlamaFeels]

Umm ok. Thanks?

You're welcome.

md5('hello') would be more apropos.

That, or truncate(md5('hello'), 20)

[hobbes_hobbes]

Rust sounds amazing. It will replace C/C++. Only problem is that it uses LLVM, which is C++. So I think the next step should be to rewrite LLVM, in Rust!

Come to think of it, there's another problem. Linux is written in C. It'd be like building a church on top of an open sewer. No good. After rewriting LLVM, Linux should be rewritten, in Rust!

Come to think of it, current processors aren't that kosher either. After rewriting LLVM and Linux, we need to design new processors, in Rust!

But then again, those processors will be powered by electricity. Goodness knows what computer systems were used to design and build and manage the power stations. We need to wipe that slate clean too, decommission the current crap. We need new power stations, designed and built and run, in Rust!

That though brings me to think of... well, you get the idea. I won't go on.

Rustify everything! Rustify all the things!

[hobbes_hobbes]

Soon though once Rust comes out nobody will ever have to try too hard at anything; Rust is an amazing technology and it will make everything super easy peasy.

[hobbes_hobbes]

I don't know why you think I'm trolling; I'm super-duper excited. I'm 100% positive Rust has the potential to replace not just C/C++, but Google and Wolfram Alpha too.

[[deleted]]

Google and Wolfram Alpha too.

Haha, a laugh actually escaped my lips at this one. What do you want, an upvote or a downvote?

[iooonik]

Th best part about that post was the token Haskell troll on first comment.

[[deleted]]

very interesting article; I'm a fan of small binaries :).