Rust the C replacement

http://esr.ibiblio.org/?p=7294&cpage=1
In practice, I found Rust painful to the point of unusability. The learning curve was far worse than I expected; it took me those four days of struggling with inadequate documentation to write 67 lines of wrapper code for the server.

Even things that should be dirt-simple, like string concatenation, are unreasonably difficult. The language demands a huge amount of fussy, obscure ritual before you can get anything done.

The contrast with Go is extreme. By four days in of exploring Go I had mastered most of the language, had a working program and tests, and was adding features to taste.

Doesn't Go not have generics?

Pike pls

The language learning curve is irrelevant in practice as it gets highly amortized the more you use the language. In fact, the amortized cost may even turn negative if the language complexity simplifies using libraries, testing, optimization, improves correctness etc.

>>2
`>I want to call a function but I don't know which one I want to call

Generics were a mistake.

>>5
Dude, even fucking BASIC had generics.

>>5
You ever programming was a mistake.

Https://appliedgo.net/generics/

Just reading about the "alternatives" to generics made by gotards makes me laugh. There's not a single viable alternative there but they actually recommend you to simulate generics through hand-rolled shitty code generators. Fucking numbskulls. Just the fact they think there can be any debate about whether generics are necessary shows Go is a language by a retard and for retards.

I think Golang should be renamed into Nolang, short for "No Generics Language".

>>8
Go is weird. It really seems like its language authors set out to ignore the last 30 years of language research, and succeeded. The first thing I did in a non-trivial program was take a parallel work queue function I'd written and abstract it to handle any type.

I start with this:

WorkInParallel(items []Foo, workOnItem func(f Foo) {
// work on f
})

But I need to be able to call it with []Bar too. Well I can't do the obvious and write something like WorkInParallel<T>(items []T, workOnItem func(t T)) because no generics. Fine, I'll just use the unspecified type and force the callers to cast.

var bs []Bar = ...

WorkInParallel(bs, func(i interface{}) {
b, _ = i.(Bar)
// do the actual work
})

That looks like shit, but at least it works. Oh wait, no it doesn't:

cannot use bs (type []Bar) as type []interface {} in argument to WorkInParallel

Well I'll just cast bs to a slice of interf--

invalid type assertion: bs.([]<inter>) (non-interface type []Bar on left)

OK FINE

var bs []Bar = ...

is := make([]interface{}, len(bs))
for i, b := range bs {
is[i] = b
}

WorkInParallel(is, func(i interface{}) {
b, _ := i.(Bar)
// do the actual work
})

What the fuck??

I'm not saying I completely dislike Go. It's reasonably performant, easy to write and doesn't have too much baggage. It feels more structural than object-oriented, which is nice. I even think that design decisions based on subjective factors are defensible.

But what I can't stand is Go zealots pretending there's some grand strategy behind the language's quirks other than "Ken/Rob didn't like that feature". There is no method to this madness.

Check 'Em.

>>11
Awesome dubs, Mr. President.

Daily reminder that even C has generics in form of _Generic macro which selects overload of function/macro based on compile-time type.

>>13
Or you could just use tagged unions like a normal person, rather than reinventing the wheel.

C replacement? It's been with us awhile now, and it's called C++.

>>15
sage

>>16
yes this is a sage post very wise

>>15
IHBT

Rustafarians Unite!

https://upload.wikimedia.org/wikipedia/en/e/e0/Clang_Invasion_screenshot.jpg

Found something else. Let's take a look at cat(1)

Here's a big list, except for sbase's and acu's: https://gist.github.com/pete/665971
The Suckless version from sbase: http://git.suckless.org/sbase/tree/cat.c

Now, GNU and BSD's version of cat are bloated, sure. But take a look at cat re-implemented in Rust.

https://github.com/uutils/coreutils/blob/master/src/cat/cat.rs

Look at home many people are contributing to the project. They're already campaigning in typical marxist fashion for distros to use it instead of GNU Core Utils, claiming it's more secure and faster and that it's the future.

>>21
Its faster because putc/getc are slow.
Try to read()/write() with custom buffer

>>22
but many C cat implementations don't use putc/getc. see plan9

>>21
Look at the binary sizes for even more sense of bloat.

>>22
It also takes over the cache with its elephantine size, making everything else on the system slower. These benchmarks are stupid and the reason for things like 4-kilobyte memcpy() implementations.

>>23
Most don't. Suckless is one of the exceptions.

I'm gay!

>>25
fuck off fake cudder

>>21
Incredible. Rust has all the inefficiencies of a scripting language, except you actually have to type them out yourself instead of the runtime inserting them automatically.

>>21
This smells like a dead striped Polecat /kebabs/, not like a cat.

I also remember that the echo implementation of GNU as well as the original echo for unix both could handle out of memory situations unlike the plan9 echo that needed to allocate a whole buffer and crashed otherwise.

>>28

the original echo for unix both could handle out of memory situations

What's the point of handling OOM if your program's only job is to send the input to stdout? What is it going to do, keep running? Might as well crash.

Of course if plan9 is doing something insane like buffering the entire input, then yeah they're idiots.

>>29
Why should it crash when it doesn't have to? Sure, running unbuffered will be slow as balls, but for forensic sys admin slow is better than nothing.

>>28-30
The real question is why the fuck does echo even need to dynamically allocate memory? Its only job is to print argv, which has already been allocated by the kernel. If there's no memory for argv there's no chance the process can even start.

>>31
cudder man, where can i find some of your source code repos?

>>31
what about echoing a stream though

u need to allocate a buffer to hold each chunk

or you can do it 1 byte at a time but that's not efficient

>>32
``open source" is a codeword for bloat

C CONSIDERD HARMFULL AND RUST TOO!!! ALL COMPUTER VIRUS ARE CREATED WITH C SCIENCE COMPUTERS RUST MAKES MORE VIRUS!! IM COMPUTER SCIENCE HASKELL USE HASKELL PROTECT

>>35
The Hasklel runtime is written in C. Use a self-hosting lambda calculus interpreter instead.

>>33
What do you mean "echoing a stream" --- the echo command echoes argv and nothing else. (Unless GNU decided their bloatutils version would...?)

https://github.com/brho/plan9/blob/master/sys/src/cmd/echo.c#L28

Why did they do this

>>38
probably to make the program 'faster' by doing only one io syscall. (it's retarded and they shouldn't)

>>38
Because write is orders of a magnitude slower, especially when writing to regular old disk drives.