A static analyzer for a sloppy combination of c/c++ and ocaml made as an afterthought

safety checks will make bigger binaries even without static linking. And cause problems that are independent of you, which could be a good thing in some cases, but in others it's not.

learn what's dynamic linking and then use it

Most of safety checks (for example, borrow checks) are done purely in compile time. Plus the lifetime annotations help the compiler to do this without any overhead.

I know what it is and I wouldn't use it.

no, comeon remember that static linking 'sucksless' according to some weirdo that khs

Attached: 1532983842974.jpg (1500x1210, 425K)

>I know what it is and I wouldn't use it.
>100000 copies of the same data on your hard drive
unironically kill yourself

Yeah I prefer performance. Storage is dirt cheap.

>he thinks dynamic linking is only good for save some space

fuck off pajeet

Oh... man... dealing with other people Error type can be so annoying... if only rust had heritage

Made me ponder,
Consider the following Rust code:

fn uno() -> Result {}

fn dos() -> Result {
//call to uno() at some point.
}

fn tres()-> Result {
//call to dos() at some point.
}

fn main() {
tres();
}

Man what should I do with all those different error type... How do I organize them so I can handle them cleanly in main?
Should I?

struct MyAppError {
is_nigerr: Option,
is_chinkerr: Option,
}

And then in main():

fn main() {
match tres() {
Err(err) => {
match err.is_nigger {
Some(nigger) => nigger.send_to_jail(), //error handling code
None => _,
}
match err.is_chink {
Some(chink) => chink.trade_war(), //error handling code
None => _,
}
},
Ok(_) => _,
}
}

Oh man this is so gay... Should use 'if let' btw... But what are the error handling recommendations?
What is good style?

Using an enum with one variant for each error type makes more sense, the variant encapsulate the error. Much better and readable.

>What is good style?
buy k&r and install gcc

Attached: boomer.jpg (633x640, 67K)

I already own K&R. But it's the cheap version and it was owned by a Pajeet before so I never read it. Actually, it's the indian printing for K&R

sounds disgusting

That's Currygan & Riji, it's a different book

Attached: e58.jpg (500x370, 26K)

So, in effect, a CPU is pretty much hooking up your bedside lamp switch to put one faucet's output into the control valve of "faucet network".

You can send beeps and blops and flips and flops and even streams.

Intel calculates the stream. How you say it is irrelevant. Provoking the debate is a Communist conspiracy, equivalent to healing burn victims by causing them to scream.

Yes, they do become immortal. But literarly, you have made "Grim Reaper Army" ...

... what do they do next?

Steve Spielbergs ... "vineyard" part.

It's that bad scene from Indy 3. The book burning ...

Spielberg gets on stage. It's made like the Oscars due to Tom Cruises' toilet slaves.

He's unshaven, in a tuxedo, but more like, forced Viking made to dress up for ... ... ... art.

The more he talks, the more horrible it gets.

But MOAR and MOAR college kids seek him!

He is a literal Artistic Mecca, in a realm outside of time and space.

He throws the Oscar in the garbage, and somehow Disney monetizes it to make trillions.

>why is your compiler chosing to staticly link literally everything?
(1) Rust doesn't get as many benefits from dynamic linking. If you want to upgrade from shittylib 1.0.1 to shittylib 1.0.2, even if your binary is dynamically linked and all shittylib API types and signatures are identical, you still need to recompile your binary instead of just swapping out the .so. This is because rustc will inline library functions and expand generic definitions into your own binary, and those definitions need to match up with what's in the .so. GHC (Haskell) does the same thing, by the way, and similarly defaults to static linking.
(2) Stupid people like it when they can scp a binary to their server and have it Just Werk(TM) without understanding dependencies and linker paths. This is the same reason Go defaults to static linking.

Welcome to a new episode of "Bot or not?"

try reddit they love that sort of thing

>... what do they do next?
They install gentoo

R-respect that people have differences of opinion and that every design or implementation choice carries a t-trade-off and numerous costs. There is seldom a right answer.

>rob pike on there twice
yes

When you play a Paladin and reputation fall to law.
Oh man I want to browse /tg/ now.

it's just the compiler default, you can switch to dynamic linking and it'll spit out a bunch of .so as expected

/g is deleting my posts

PS:

What is the first post ever on each board?

Couldn't we use the "free" logging of AWS to do some "Text Expression" ??? :( :( :) H :L => The right angle, the first military "secret" ...

twitter.com/HartkenSteve/status/1024351792543481858

Implement From to convert each type of library error into your own error type that keeps whatever amount of detail you want. Or just unions the library error types.
It will be used automatically if you do potential_lib_fail(foo)? in a function that can return your own error type.

>Or just unions the library error types.
That's what I did last hour, it's pretty neat but the "From" solution seems to be the best, problem: I haven't fully studied rust's trait yet so it will be for later refactoring.

Lad, that language is pretty neat. I was just to stupid to see it at first.

twitter.com/HartkenSteve/status/1024386545430736899

twitter.com/HartkenSteve/status/1024388167099731969