EVERYBODY, PLEASE READ THIS

Retards like you like to point to the C v. Rust benches, comparing a language which has been standardized (and its compilers optimized) for 30+ yrs to one which is still very much in flux - yet when Rust, despite these shortcomings, wins the contest, you claim it is meaningless??
Really makes you think...

not an argument

fuck off you don't tell me what language to use or not to use.

You're right, but when there's a substantial speed or safety difference, there is literally no reason to use your snowflake language. Kill yourself retard.

Ada won't let people say things like this because C had no influence on Ada.

How about none of them?

fuck of

triggered?

you can program bugs in any language

...

actually no: mgattozzi.com/avoiding-logic-errors

...

filter all namefags and tripfags

you cant fake my trip fags
Barely Functional indeed

WEW LAD!

They are trying hard to shove rust in as a foundation for everything. C is bad, but we should take the opportunity to find someting better than Rust. One temporary solution is not to add more functionality than is needed and change software slowly. They could have thrown away the ugly C syntax but no, they kept it.
From wiki.theory.org/index.php/YourLanguageSucks#Rust_sucks_because:

filter all anonfags

not an argument
so? in c everything is potentially unsafe while in rust only the parts explicitly marked as such are.
not an argument
not true with incremental compilation enabled.
if you dont like the default just change it? also on windows the system allocator is used by default.

They have made a very judicious compromise between terse syntax like Haskell provides and providing familiarity to most devs. Rust already introduces too much new stuff for a lot of programmers to be able to pick it up in a reasonable amount of time, if they had gone one step further it would've probably remained irrelevant outside of niche situations, much like Ada has.

a) No.
b) Where you do actually end up needing unsafe, you're not less safe than C and C++.

That's not overly terse nor is this strange API you're only going to see once in a millenia. You're just not supposed to have to write a thesis and fill 100 forms in triplicate to instantiate a linked list.

Granted. This is not a limitation of the language though, it's just immature tooling that's still improving.

By default, yes. If this is a problem, just tell it to link against the system allocator, or link dynamically to a system-provided jmalloc.

kys

wew

how about you modify the css line-height property instead of writing like a retard?

this thread is dogshit

this post is dogshit
why arent you saging if it is dogshit?

sage

Show me a functional, commercial OS written in Ada.
Can I install a modern browser/word editor completely written in Ada?

Languages don't exist so you can jerk off to them.
They're written so that presumably, people can build better things faster with them.

Off topic, are there slightly more in-depth resources for learning Rust?
I've read the rust book several times. The concepts are conceptually easy, but the moment you start trying to develop, it all goes to hell.
Obscure error messages, massive type errors, and much more implicit stuff you can't predict without advanced experience.

doc.rust-lang.org/stable/nomicon/
A collection of notable Rust blog posts: gist.github.com/brson/a324c83a6af6a8a78dfaa9d33eb9b48e

Thanks m8.
This is exactly the stuff I was looking for.

just when i thought nobody could come up with a more retarded argument than "ugly syntax"

a collection of cringy bullshit

not an argument

ADOPT ADA, YOU WANKERS

...

That's a huge nitpick.

That's not a nitpick, because if Rust was safe, this page wouldn't have to exist: doc.rust-lang.org/book/second-edition/ch19-01-unsafe-rust.html
What about calling it "safer"? Then you have said that it is safer than C, but still has (unsafe) options for programmers in need of that extra functionality.

Meant to reply to

Not him, but that's a huge nitpick.
Unsafe Rust is literally designed for backwards compatibility with other unsafe languages.

The creators of C are the retarded ones.

C syntax wasn't familiar to most devs in the 1980s, but it hasn't stopped them from learning C.

Show me critical infrastructure such as air traffic control running Rust.
Can I fly in a plane that has systems programmed in Rust?

Languages don't exist so you can jerk off to them.
They're written so that presumably, people can build better things faster with them.

lol, nice pasta.
I'm not a huge advocate of Rust, but it's in its infancy.
Ada has been around for 30 years. Is there an OS written in Ada?

Let me google that for you.
stackoverflow.com/questions/6398305/operating-system-in-ada

bro.

First comment:
>There is also TAMP: github.com/Lucretia/tamp

I wish Rust was as simple as C. It's not. You can add new features to C and still keep C simple, but they created a language so complex it makes my eyes glaze when I read the code.
Honestly, the only features I'd like to see in C are operator/function overloading, and struct.function() as a shorthand for function(&struct). C would become the ultimate language for me if this happened. Nim comes close, but the syntax gives me cancer.

I worry about that a lot.
I really want to safely code in a low-level language, but Rust is dangerously difficult to learn.
They might end up like all the Ada/Haskell-fags.

There was actually a project in my country to program trains infrastructure on Rust.

I guess meant for

C is not simple. It doesn't have many concepts, but it has a lot of quirks and bad design, which make it complicated without making it more powerful. I don't know any other language that does this.

boards.4chan.org/g/thread/61406655

Even 4chan is less cucked than this place

Stay in your cuckchan, mate.
It's not like Rust's SJWs haven't been talked to fucking death here anyway. Some actual technical discussion once in a while is good.

...

The way everyone promotes rust as safe only makes me afraid of rust programmers' code. It's all nice and dandy, but you just know that 90% of "programmers" will think

Nice strawman.

Threads like this will do more to kill rust than c, just from people wanting to avoid assholes.

I hate how they've co-opted the language.
Now it's a meme.
Fuck SJWs

Shift+click this thread on the catalog to hide it permanently

ur not the boss of me.
i do what i want

muen.sk/
Your move, faggot.

The purest of utter bullshit. Ada traces its ancestry via Pascal and ALGOL 68.

>muen.sk/
Thanks for the link. But why even bother with Rust when there's Ada? What advantages does Rust have over Ada? So far I have seen none.

The singular advantage that Rust has is affine typing. This is what allows heap memory leak and some race condition analysis. Fortunately, it's not hard to add to Ada via an extended type checker, and Ada has every other advantage. It's easy to write memory safe and thread safe code without it in Ada.

Also, I just found out about incremental recompilation. So they added a whole bunch of complexity to their compiler because their language couldn't handle separate-but-not-independent compilation? That's fucking hilarious.

If you're retarded.

How about no?
Bugs are the programmers' responsibility. If they screw up memory management and pointers, it's their fault.

Really makes you think.

wow big surprise that corporate shit sucks and curses everything it touches

...

Rustniggers need to fuck off.

i just want a language that's like comfy but doesn't have a garbage collector by default.

That's Ada.

Nobody will use this wordy named after a hoax language today. You should stop shilling.

...

...

Holy shit, so while we shitpost about Rust, apparently it is actually useful in the real world.

Dropbox recently mitigated all their Go code to Rust for memory reasons.
archive.is/gRktl

joking aside, i don't get the point of a garbage collector if it doesn't even solve the problems eitherway.

stopped reading right there lmao.
quality (((journalism)))

You sound like a well-informed chap.

Jesus, must I read everything to you like a schoolmum?

Here are the relevant quotes, since your overweight ass might exert itself too much scrolling down the page:

im not interested in (((journalism))). either post a good article or something directly from dropbox. im also not interested in reading what you copied out of this (((article))). at least you archived this kike shit.

I guess using a search engine is too jewish for you.
God forbid you might have to look for facts.
Oh shit, I meant Yahweh.

I tried to write something in Rust not so long ago. Most painful development experience of my life, and I have worked with Spring.
I was so fucking fed up with Rust right now I promptly dropped the project after this, but I remember something about match structures and patterns returning nonintuitive stuff from the capture expressions.

How this shit is more popular than Ada, I will never know. Almost every Rust feature becomes an antifeature the moment you deviate from the carefully crafted examples. Nevermind it is also a write-only language, and that weird as fuck syntax quirks appear scattered all over the place in the book, like the turbofish quadrigraph.

I've had the exact same experience.
Honestly, it felt like a language for geniuses. How the fuck Dropbox implements their exabyte storage solution with it seems like magic.

it sounds like you want a dynamically typed language
anyways your whole is just waaah i dont like. too hard
not an argument

i guess posting a proper article is too hard for you.
god forbid yoy have to put some effort into your posts.

Literally 99% of Roost arguments against C are [sic]"waaah i dont like. too hard"*, so guess what isn't an argument either?

* This is not correct English by most standards.

but i wasnt talking about c. why are you changing the subject?
not an argument

When you talk about Rust, you talk about C, literally every single Rust thread is an attack on my god.
Not an argument.

i want talking about c though. stop embarassing yourself.

...

i wasnt replying to the op though. stop embarrassing yourself.

Bitch, I have a background in strong statically typed languages, and I make a living with statically typed languages. None of them are nearly as batshit insane as Rust.

...

Eat shit

ITT: Tons of Ada shills, none of which actually use Ada. One might think they're actually C-tards, who realized they actually have no leg to stand on. Very scummy tactics.

Meanwhile, Emacs is getting its rewrite in rust¹, as is AwesomeWM².
¹ github.com/Wilfred/remacs
² github.com/way-cooler/way-cooler/issues/338

Is it just me or is everything written in rust just a port of something that was developed in another language already?

...

go away mozilla I won't trust you or your software ever again

...

...

java > c++ in terms of polymorphism

...

"Object-oriented programming" was a term made up in the spur of the moment to describe Smalltalk. It was not a very appropriate name in the first place ("I'm sorry that I long ago coined the term "objects" for this topic because it gets many people to focus on the lesser idea" -- Alan Kay), and the meaning of the term has since shifted to a different style of programming. Smalltalk is only the real OOP language in the sense of being the first to call itself that.

There are only two kinds of languages: the ones people complain about and the ones nobody uses. - Bjarne Stroustrup

Guess which category Rust falls into.

What would have been the appropriate name? message-oriented programming?

Both. I guess Stroustrup forgot to mention the categories aren't mutually exclusive.

That's a good point, I guess you are right.

Probably. Kay says that's the big idea.
Right now you have a lot of popular languages calling themselves object-oriented because they focus on objects, and you have a programming philosophy that describes itself as object-oriented that focuses on objects, and people tend to make the reasonable assumption that "object-oriented" is about objects. The term has been hijacked, and it's now in a place where it applies much better than in its original place.
Don't try to force the idea that Smalltalk is the true OOP, it's not going to happen in either case and it would be a step backward if it did happen. But if you use a new term with the word "message" in it then it becomes easy to convince people to group Smalltalk together with Erlang, and it becomes easy for people to understand what Smalltalk is really about because they won't be stuck on the word "object".

We have been using the term "actors" for a while now.

A fate worse than writing Rust

[citation needed]

pick one faggot

robert.ocallahan.org/2017/07/confession-of-cc-programmer.html
C/C++ BTFO
EVEN PROFESSIONALS CANT WRITE SAFE CODE

I can because I'm a autist genius

I can because I am a properly configured code generator
bleep bloop

I can't because I'm a rubyist

lol opinion discarded

Why don't we do programming with something like Coq?
Coq is an interactive theorem prover. It allows the expression of mathematical assertions, mechanically checks proofs of these assertions, helps to find formal proofs, and extracts a certified program from the constructive proof of its formal specification.

...

...

Why not SPARK? It serves the same purpose.

Yeah, it checks that math and logic of your software is correct and then it generates safe code from that proof.

That is a lot of $$ per line, but with traditional software development methods you will end up paying more.
Computers are cheap, programmers are not.

Sure, we could use SPARK, I mentioned Coq just because it is only theorem prover software that I heard about.

Still better than your parent's basement.

...

don't trip, you're at the peak of mount stupid

Rust is like the SJWs is came from. They create nothing and assimilate everything that already exists.

Rust is literally just Haskell with horrible syntax.

topkek the irony
both you and this entire board is proof of that effect.

The thing with Rust is that none of the preachers ever think of a cost-benefit analysis.

Let's look at the CVE trends for the Linux kernel:
cvedetails.com/product/47/Linux-Linux-Kernel.html?vendor_id=33

In 2016, there were 217 vulnerabilities. So far this year there have been 350; the number goes up and down wildly and, if you look at the numbers, it's not as simple as a constant increase in CVEs.

That sounds bad. But bear in mind two things:
1. There is no proof that Rust would prevent all of these bugs - even most of them. Rust champions memory safety but only 29 CVEs this year are classed as 'overflow' and 14 are 'memory corruption.' Rust might have been able to prevent some of the code execution ones but it's not certain. Rust does not prevent you from writing bad code.
2. There are something like 11 million lines of code in the kernel. Even excluding device drivers, there are still millions. To prevent a few dozen bugs a year, each and every of those millions of lines of code would have to be re-written to get back the same functionality.

It comes down to this: Rustfags proselytise to no end about how their language would prevent ALL the bugs. To do that, things have to be re-written in Rust. To re-write even a portion of the current FOSS stack in Rust is not worth the effort since the returns are comparably tiny. Note that I'm not saying 'hurr its 2 hard' - the difficulty could be worth it, but it's not. Especially when there are other technologies like reference-counting to eliminate bugs already implemented in C.

Sensible people understand that in most cases it's better to build on and improve things, and only scrub/rewrite code when it's such a pile of shit that it's worth the effort, or you have proof requirements you can't satisfy any other way or something. This is why the whole "rewrite in rust" forced meme is hilariously pointless busywork. Can't wait till they turn their sights on systemd.

Rust would reduce number of bugs in Linux kernel because it would take about a year for Linux kernel sized Rust project to finish compilation.

really, really low quality bait.

Unless you're serious.
Rewriting a kernel is no small task, regardless of the language. Something the size of Linux can't be summed up "within a year" unless you've got something backing that up.

If the Linux kernel gets rewritten in Rust, it'll have to start with small, modular, non-critical pieces like modules. If those rewrites do well, then yes, maybe there's a chance.

You misread the user's post. He's making fun of Rust having really slow compilation speed. Which is a legit thing to make fun of. They had to add incremental recompilation (aka caching) because the language wasn't designed to handle compiling units/modules/whatever separately.

Btw a kernel falls into the category of software that you really want to formally prove to have correct behaviour. So Rust isn't good enough. More appropriate languages are SPARK or Coq. Preferably combined with an architecture that minimises trusted code, like an exokernel. Merely rewriting the Linux kernel without a massive redesign is doomed from the start.

"Rewrite it in rust" and "safe language" are mostly advertisements. Slogans. They're aimed at making the language more popular but don't literally mean that everything should be rewritten in Rust (even if some fags literally claim so) or that Rust is safer in all situations.

There is a bit of truth to the slogan that Rust is safer, and everyone programming in it will obviously learn in which situations Rust is actually safer, so it's a harmless phrase. You're making a bigger deal out of than it really is.

It's like a "zero poverty" slogan to some politician's campaign. It doesn't literally mean there'll be zero poor people in the state/country.

I should start making regular Ada threads. It would have slogans like "in strong typing we trust" and "the original safe systems language".

Ohhh, is didn't see "compilation" kek
I was mulling kernel development, and something came to my mind.
Has anyone ever thought of designing one where it would have modules that communicate through an API?
This could make it more crash resistant, and possibly easier to extend.
Admittedly, this idea came from reading about Amazon's infrastructure.

If you want to actually make a difference, spread them all over the internet once they take off here. We might see an Ada revival.

Congrats, you've reinvented microkernels.

How about "add to it with Ada"? :^)

fuck.
thought I had something there.

If Ada was good, why did the industry abandon it like it was dogshit even though they'd invested billions in it?

All its compilers and tools happened to be proprietary and paid for a while. C took over before, and the C-like language craze flooded the market with new and exciting languages. It has nothing to do with the quality of the language: while COBOL was pretty fucking ugly, the industry invested a lot on it, and it's been dropped since for new projects because it fell out of fashion.

Ada still has a problem: not nearly enough libraries, nor community. Rust is starting to take ground because it has Cargo (as much as you like shitting on it, not having to depend on package maintainers to upload libraries to a repository so you can use it easily helps a lot) and very active and helpful IRC channels. Rust is all about free software as well, whereas Ada still has that old school proprietary cruft around it.

I never tried rust, so I don't have any opinion on it, but I don't get the hate C and C++ gets in here. All the cons you listed are why I like those languages. I like knowing how my code will be translated to the assembly, I like having the ability to manage the memory the way I want to do it. If you know what you're doing you can do a lot of stuff much faster than in other language. You say it's unsafe, but it's only as unsafe as people write software with it. It seems to me like the big corporations just need to shit out more and more programs, with least cost possible, so they want to create a language any pajeet can code in. I don't know man...

Every /g/-tier college freshman thinks they are the best and can write memory safe C code while nobody else, not even actual senior C programmers can. Until you accidentally make an off by one error in strings and therefore accidentally your whole system. C is not hard; C is too easy, too easy to fuck up.
Lol.

I don't claim to be an expert, but when you find a bug, you did it. What's the problem ?

Fix it *

Zero-days, hard to find/fix problems that leave the software vulnerable for a few days or slow to update installations (not usually the developer's fault, but still) can fuck your shit up very hard.

COBOL would have prevented buffer overflows and dangling pointer bugs too.

It's a push to flood the market with Pajeets. Imagine writing a web page in C++, you'd never trust something like that to a streetshitter. But if you contain the damage they do you can task 100 of them at $0.50/hr to code your black box Hello Worlds.
I work in embedded where we do still sometimes code webpages in C++ and those jobs don't go overseas.

Get rekt, faggots.

Allright, fair enough, but that only affects applications that are run on some kind of a server that you want to exploit, right ? Writing offline software would be fine from such things (if it crashes, read the coredumb and fix it)

I agree, but Rust isn't the future with its gross syntax and massive binaries, D is.

Kek.

I was thinking about that one day. Nothing serious of course, but it would be fun to try out (and honestly, someone had to do it already). Just one executable that takes and sends packets...

Colleges used to teach the importance of error handling and writing good software, but they have become C schools. The language taught in university does matter a lot more than people think. BASIC was better than C because they learned the importance of run-time errors.

They think that if it is taught in college, it must be good because colleges won't teach them crap. They're wrong.

Anyway, just because they found nothing doesn't mean it isn't there.

It depends. Any network facing application can be vulnerable, client or server. Even though browser JS engines are supposed not to have direct contact with the underlying architecture, RCE vulnerabilities still happen because someone fucked up while programming the runtime.
Depends on the program and the computer (ie. whether it is connected to the Internet or not). If the program has elevated privileges, a hijacked network facing program could take advantage of a supposed to be local only vulnerable program with elevated privileges. Sounds very specific, but imagine they manage to hijack Firefox, then they exploit a vulnerability found on your GPU' drivers, which in turn they use to take full control of the kernel because you are probably not running a microkernel.

Agree that C is not simple (those who say it is are just LARPing) but
JS, PHP, Java, Haskell, Go
take the FuckYou pill. every PL is complete shit and it's not even worth thinking about whether any is better in any way. Even outside of C you still (miraculously) have all kinds of RCE vulns.

I would call you a faggot for using a shortlink (yep, it's a shortlink even if it's on archive.is), but holy shit
you could not meme harder if you tried

Is RUST compiled to machine code ? If yes, then how is it safer than C/C++ ? Does every operation of an array check the array's size to make sure you don't go beyond it for example ? How does it work.

okay well go get uncucked and take your autistic C old guard LARPing back there

I'd say it's not hard but it is clearly hard for a lot of people today. But those are the people you don't want working on anything sensitive, anyway.

bounds checking

Yeah but it does it on run-time, right ? Then it has to be slower than not doing it. Besides, you could do it in C too.

Rust does compile to machine code. Well, it compiles to LLVM bytecode, which in turn compiles to machine code, but still.

Problem is, you are not thinking the Unix way. Part of the Unix philosophy says that writing code generators is better than writing code by hand because it is harder to fuck up when the machine writes error checking for you. This is exactly what happens with Rust: it generates code that always checks stuff for you so you don't have to. In addition, in order to do most of this at compile time, it has some batshit insane type and reference mechanics to better inform the compiler of how to make things safe.

It is compiled to machine code.

Rust compiler analyses your code at compile time to make sure that it is safe. Rust was made specifically with those checks in mind so it does not do anything that makes that analysis hard to do. Borrow checker is thing that is 'revolutionary' about Rust, it ensures memory safety at compile time so there is no need to have garbage collector. There were some efforts to port borrow checker to C but there was not much progress in it.

It does as much as possible at compile time. That is why Rust compiler is so slow.

It's not hard, it's just painfully masochistic without a reason, specially if you are doing it without a framework. When even routers can run a full blown OS with a webserver and Lua-generated websites, you have to wonder why would you even do such a thing.

For fun
t. C64 coder. There's no reason to code for it nowadays either.

C++ is way easier to fuck up. There's so much automatic memory management going on coupled with potentially unwinding the stack from any point that understanding exactly what code might do in every possible case is difficult. As an example of how wideapread this problem is, take any large C++ project and look at destructors for cases where an exception could potentially be thrown through them. Everyone has them.

Meanwhile, in C land, even the standard library can duck your shit up.

le C++ is safe meme

It's not. It is still better than C if you use actual C++

It does bounds checking but tries to elide it at compile time. It can't always do that so sometimes your code will be dog slow for reasons that are extremely hard to understand, or become dog slow from seemingly unrelated changes to other sections of code. It's why people posting microbenchmarks of rust as if you should expect that kind of performance are retarded. It takes a lot of analysis of the llvm ir generated to get rust code running fast.

You know pretty much every loop has to check whether to continue or not at least once per iteration, right? And that branch prediction is a thing. It barely adds up.

It's easier to reuse code (all our libraries are C/C++), it's easier to reuse programmers (the vast majority of our work is C/C++), it works on systems with no FPU unlike almost all webdev languages and frameworks, and it can fit in very little space which is still important for a lot of devices.

Did you have trouble understanding? The throw-through-destructors issue is how RAII made C++ error handling less safe. Everyone's got C++ code full of these time bombs whereas only bad C code has similar problems.

WHAT THE FUCK DID YOU DOOOOOOO?

Stick to Java, kid.

Where are those posts, famalamadingdong?

ITT: Fags who will never bother to understand architecture and micro-architecture.
ITT: Fags who won't sit down and think about the simplest solution to their problems.
ITT: Fags who feel comfortable for allowing a piece of software make decisions in their code for them, only because the process of complication has been made more complicated and less transparent.
ITT: Fags who can't into arithmetic.
ITT: Fags who don't test and double check before commit.
ITT: Fags who are ready to sacrifice performance by incorporating security in applications that don't require security.
ITT: Fags who are ready to sacrifice security because they don't have a clue how to approach and plan security.

This is the stuff that separates man from pajeet. If you think this is an argument for any solution, go fuck yourself, pajeet.

Here's an example because you have trouble thinking of them. One of our programs has a graph-based configuration and has a large amount of static analysis / validation code. We also have a visual graph designer for the web UI. To be ROBUST we need that code in the program, in the web backend, and in the browser, and they all need to be 100% identical in how they respond. A C library does this with ease and we can use the same code for all three. The browser side is produced via emscripten. Everything's very fast and low memory, the UI is snappy as it's entirely client-side, and we aren't maintaining two or three variants of the same thing in multiple langauges.

t. SICP larper.

...

Damned if you do, damned if you don't.

Well, feel free to implement your exabyte-scale datacenter designed to serve anyone with an internet connection around the globe.

Until then, I'm interested in the biggest, latest, and the best.
You don't have it.
Your "pure" languages aren't running it.
Put up, or shut up.

gosh user you sound really important :) I bet you work at a really big company and are really succesfull :) you're so cool :) quads confirm! xD :))

obviously.

can't tell if troll or hipster faggot who sucks dick trickled down from the likes of dropbox, facebook, instawhatever, and HN
maybe try reading the start of my post where I say all PLs are shit before arguing against my imaginary "pure" language

What's very clear is that you can't address the core statement.
You language betrays nihilism and elitism.

Also, shit tier reaction image.
What's next, a "rare Pepe"?

you already proved you don't know what you're talking about with your original post
If you're trolling, good job. now shut up. I am agreeing with you that Rust can be used for "real world code" (again, the fact that you think this concept exists proves you don't know what you're talking about).

Tell me when Amazon is using rust to run EC2. I don't give a shit if some website running on EC2 is using it to implement drag&drop.

kek.
Dropbox no longer runs on EC2.
Magic Pocket, running on Rust, is their EC2.
Keep up.

Shit my bad.
Of course Dropbox wouldn't bother getting interviewed by Wired about their tech.
Why would they, when they can personally contact you?

full stack engineers pls go

You do realize webdev companies just advertise the language-of-the-day to attract talent, right? They have very little code to write, almost everything about these companies is marketing, but they need to look like they're on the cutting edge of something if they want employees that aren't Pajeets. It's the same with feminism and tryhard progressiveness, even if the company is run by someone like Eich that wants to gas the faggots, they'll cheer on dicksucking if that's what the kids are into.

aeiou

It's your cult that's making a big deal out of it, invading communities and shouting people down for not using the ball vice known as Rust

This kind of poster is why Rust will never take off, thankfully.

I don't even know what we're talking about but we've just hit a hole new level of retard here

stop abusing redtext

REDTEXT

I'd just like to interject for moment. What you're referring to as critical infrastructure software, is in fact, safe-software, or as I've recently taken to calling it, software plus predictable behaviour. Critical infrastructure software is not secure unto itself, but rather another component of a fully functioning critical system.

Ada is a safe language. It is safe because it doesn't tolerate obvious programming mistakes/typos. It is like an auto-correction in your word processors. It checks for grammar errors, but it won't prevent you from writing a shitty essay.

Using Ada won't prevent you from writing insecure applications.

There is a huge difference between safety and security in programming. The first one can be defined by the language, but the second one is totally up to you.

We did indeed; pajeet

...

Every time I see the new "C killer", I think of modern art.

C is beautiful and elegant, like an academician painting by one of the masters of his craft. The C killer is more of a urinal, laying on it's side.

The experts and the plebs alike, they gawk in wonder at the C killer. It's new, unique, comes with garbage collection or type safety... Then they move on to the next exhibit, the functional one, or whatever the new flavour-of-the-month is.

The real experts, they laugh. They spend hours admiring the beauty of Cabanel or Eckersberg. They know C will never die.

What's witht his pedantic nonargument.

If Rust is a urinal laying on it's side, C is a can of "artist's shit."

Not really, rather "simple and practical".
Let's leave "beautiful and elegant" for D, may it rest in peace.

C is this art style that was invented in the seventies by a few guys fucking around. It somehow got picked up by a lot of artists, and now it's a popular opinion, mainly among wannabe-connoisseurs, that it's the best language ever invented. You'll ask them "how come everybody in this art style draws noses upside down, what's up with that" and they'll give a long bullshit answer about the supposed advantages upside-down noses have. Ask the same question to artists who actually use the style all the time, and they'll tell you that the style kind of sucks but they've made a considered decision to use it for a bunch of reason, most of them historical. Track down the people who invented the style, and they'll tell you that the upside-down noses seemed like a good idea at the time because they were easier to do, but basically have no excuse for existing and were only kept because everyone was already used to them.

consider suicide

I like that metaphor. They also say upside-down noses are "foundational to almost all art, both historically and practically" and that nobody drew noses the right way so we should be lenient because that was the first time anyone made art with noses at all. When you point out paintings with normal noses which are older than that style, they say that those people weren't "real" artists because "real" art has upside-down noses.

So you travel to an alternative art gallery and they all have perfectly good noses... in fact that's all they have. Row upon row of perfectly drawn noses. "But don't you draw anything else". "Oh yes we plan to draw all kinds of stuff, of course, but you see once you get the nose perfect then everything else will just fall into place". "But these upside down nose guys seem to drawing all kinds of stuff even though their noses are terrible". "Ha yeah upside down noses what kind of crap artist would draw an upside down nose.. hahaha"
Then you leave and vow to never enter another art gallery again.

The normal artists don't even think about noses as a separate thing from the rest of the face because that was already a solved problem years ago. The only time it came up was to laugh about that stupid art style, but now nose transplants are being done wrong because some upside-down nose artists became doctors and are teaching surgery. They said the art style is correct and the face is wrong. Now, they are starting to say that normal noses are a birth defect and all noses should be upside-down.

Normal artists draw anime/ation because it pays and then they imagine their shitty kids cartoons are going to spark a revolution.

Rust is basically: social justice, the language, just read the CoC. If some Rustnigger comes in telling you it's not important, ask him to take it down and see how quickly he'll deflect and get angry.

They've taken one or two old ideas from Ada, sprinkled in a linter and code analyser that most companies integrate into their C++ build system and called it "safe".

Then they go around assaulting communities and cursing programmers for writing "potentially unsafe code".

Their aim is to be the gate keepers of system programming, because they've seen the power they wield over people in other SJW take overs:

- Firefox: now with DRM and donates to feminism. Main driver of
- GitHub: cancer the community, gives Rust more facility and attention than it deserves
- systemd: a slow burn attempt to infiltrate kernel dev.

They even made an entire OS out of it, something is not right here. This isn't a language or a community, it's a cult.

Rust can be, in theory, as fast as C++ for certain things, but it can never be as expressive and it can never have the kind of code inlining that their module system pretty much prohibits. They've gone to the length of incremental compilation just to account for their module bullshit, it's hilarious to watch them melt down over this.

Fuck Rust and spit on all its advocates.

Nice strawman but C was designed as an improvement to ALGOL and BCPL. The syntax was initially minimised but this improved over time.

C's elegance lies in its applicability to every problem you can imagine without complicating its syntax. Unlike Rust, it wasn't designed by a committee (of feminists). Unlike C++ the standard is compact enough to keep in your head.

As you sail, you know the sea is forever.
The rust is annoying gunk on your vessel, but you know if you clean it off, it will wither away.

Something just became apparent.
All "system level" programmers are inevitably cancer.
C, C++, Rust,.. they are elitists and insufferable. Since their concept of a good language is dominated by a "correctness" instead of practicality, they feel the need to evangelize their language as a religious belief.

This, is a good post

...

...

And it's worse than ALGOL and BCPL in many ways. One of the things I had in mind with the nose analogy is C's null-terminated strings. BCPL had robust counted strings, C doesn't. Dennis Ritchie has gone on the record as saying that he doesn't consider C's char arrays to be proper strings, and that fundamental problems in the C language make true strings messy to add, not in the least because they would have to compete with the existing char array convention. I've seen long, complicated arguments about why null-terminated strings are so much better, but the fact of the matter is that they're a probably suboptimal design decision that we're stuck with for historical reasons.

C is defensible. I use C occasionally. But when people claim it's some sort of perfect language, and pretend it doesn't have warts all over the place, and that there is no reason to replace it (note: that's different from saying that none of the existing replacements get the job done), that's bullshit.

...

Wat. They needed incremental recompilation for any systems guys to give a single fuck about them and they shouldn't have called it 1.0 until they had it. It's still got all sorts of scaling issues on large projects but it was a fucking joke at release. They were recommending a language that can take an hour per 100k LoC compiled to people that need fast build-run-test cycles on 1M+ LoC codebases. It could barely handle toy problems.

Surely, 1M LoC Rust codebases could appear overnight.

that website:
I can feel the brain tumor growing in my head.

lmfao

...

Rust shills,every time

C++ TMP is not any more expressive than Rust macros because you don't know what expressive means.

Ugh. When it's slow, it's suddenly just "negligible" even when we know any "negligible" slowness can turn into an eternity in a worst case scenario. There are several places where safety is not prime, and until rust users stop going everywhere with this inquisitive behaviour I'm afraid people will keep ignoring any possible virtue.

Be cautious with the rust evangelizer tactics. When we compare things over safety, they go all "But rust is faster, your safe language choice isn't as safe(for some weird definition of safe that only covers rust) but also rust is faster!" however when they are meet with a faster language, they somehow switch to claiming safety is so important that any other feature or interest other than safety should be always secondary.

I think in the face of this barrage of rust spam we should request a containment thread to the mods, this is going too far.

We don't need a real containment thread, just enforcing the duplicate thread rule is enough. There are a lot of threads that are basically about Rust in general:

This is the oldest recently active one, so I'm designating it as the main thread for now, and locking/deleting/bumplocking others. Please report new Rust threads.

...

Based mods have wisened up to the rustniggers

All software should be written in Emacs Lisp

Remacs Lisp

No, Guilemacs Lisp

If this thread is supposed to be the rust thread, then adding the word "rust" to the OP doesn't seem like an unreasonable expectation.

Good idea. Done.

...

I'm so glad I have the presence of mind to not take programming advice from people who think using a web 3.0 wrapper around 20th-century telegraph network limitations is acceptable.

I don't code in Rust.
Block them/ignore them? Why do you care?
It's like the internet harassment argument. The internet has no harassment if you don't let it.

simplicity is elegance.

C is not simple or practical. It has more undefined behaviors than features. Even if you remove all undefined behavior and define C with x86 or ARM semantics like wrapping integers and flat memory addresses, it is still an unpleasant language to use. It won't make strings and arrays any nicer to work with. You still have slow null-terminated strings and buffer overflows.

blog.regehr.org/archives/1520

They even tried with
web.archive.org/web/20170716210802/http://sarah.thesharps.us/comment-policy/
This was a kernel dev.

You forgot some pieces:
-Github adds per default the contibutor convenant to all projects.
-There was also the forcing of the contributor convenant on every project that hosts freedesktop.org
-The libreboot project who tried to slander the FSF
-Torvalds who fortunately evaded multiple honeypots
-Drupal removed one of their staff even tho they transgressed their own CoC
-SJWzilla menace palemoon
-Sjw tried to stop lambdaconf
-The infection of the Gnu socials fork, mastodon.
-AMD and Nvidia drinking the cool aids
And more.

Also I am calling that shit will be stirred in the EFF.
One of the members of the EFF will cause trouble see:
web.archive.org/web/20170615085126/https://www.eff.org/deeplinks/2017/02/copyright-law-versus-internet-culture

I've just been using C ever since I started learning, never saw a reason to switch to anything else since I don't like the idea of OOP, can Holla Forums give me a reason? Also looking for a good non-OOP scripting language.

whats with the sudden influx of namefag shills this is really disturbing

Summer.

winter is coming xdddddddddddddddddddddd

C is for making things that are fast and/or low-level and/or portable to weird hardware. The cost of that is that it's harder, more time-consuming, and more error-prone.
If you're interested in doing useful things Python will be much, much better most of the time. I think this book is good.

Ok thanks, I do a lot of stuff in Blender so this would probably be a good choice.

ANNOUNCING RUST 1.19
blog.rust-lang.org/2017/07/20/Rust-1.19.html

>Rust 1.19.0 is the first release that supports unions (github.com/rust-lang/rfcs/blob/master/text/1444-union.md)
union MyUnion { f1: u32, f2: f32,}
>loops can now break with a value (github.com/rust-lang/rfcs/blob/master/text/1624-loop-break-value.md)
let x = loop { break 7; };
let f: fn(i32) -> i32 = |x| x + 1;

fn main() { let nigger = 'nigger: loop { loop { break 'nigger "nigger"; } }; println!("{}", nigger);}

I don't get wtf the ! at the end of function names in Rust is supposed to signify.

I think that shows it's a macro, not a proper function.

it means that it is a macro not a function
doc.rust-lang.org/stable/book/first-edition/macros.html

bump XD

Version 4.0 of the Suricata intrusion detection system (IDS) and network security monitor (NSM) has been released. The release has improved detection for threats in HTTP, SSH, and other protocols, improvements to TLS, new support for NFS, additions to the extensible event format (EVE) JSON logging, some parts have been implemented in Rust, and more.

*First Step into a Safer Future*

This is the first release in which we’ve implemented parts in the Rust
language using the Nom parser framework. This work is inspired by Pierre
Chiffliers’ (ANSSI), talk at SuriCon 2016 (pdf). By compiling with
–enable-rust you’ll get a basic NFS parser and a re-implementation of
the DNS parser. Feedback on this is highly appreciated.

The Rust support is still experimental, as we are continuing to explore
how it functions, performs and what it will take to support it in the
community. Additionally we included Pierre Chiffliers Rust parsers work.
This uses external Rust parser ‘crates’ and is enabled by using
–enable-rust-experimental. Initially this adds a NTP parser.

lwn.net/Articles/729064/

Those names couldn't be gayer

...

awesomewm sucks anyway

if you're going to use a window manager, go the whole way to enlightenment
if not, just use GNU Screen or similar termplexer

This is actually a pretty good point.

youtu.be/Hv6RbEOlqRo?t=24

forgot to add: Holla Forums thread simulator when? Hopefully it'll get lots of views so that in one year there will be 8 Java programming threads and all the board diversity quotas will be met.

By then hopefully there'll also be automated logo creation and Github README generator for "ideas people" so that all projects go dead in record sub-nanosecond times. And also so that there are at least 20 Skype alternatives and browser created a day that are initially written in C, then moved to Assembly and then to Python + Electron 1 GB app ( hopefully by then it'll have become best practice to ship Electron-based software in virtual machine images so that there is absolutely zero software incompatibility ).