Best language

A compiler that second-guesses your code is like training wheels. You outgrow them pretty fast, or you don't have what it takes to ride a bike.

Just a friendly reminder that the anons in this thread who clearly have not used Rust or don't even understand its advantages aren't worth listening to. Have a nice day.

Attached: what_to_drink.jpg (766x1024, 67K)

>A compiler second-guesses your code is like training wheels
no, it forces you to write correct code where it is able to.
people make mistakes and typos in their code all the time, just look at any projects issue tracker. even very experienced programmers who did nothing else their entire lives make mistakes.
some projects are better at managing them then others, but having the compiler take that extra (unnecessary) burden off the entire team is worth it.

there are things a compiler can't check for, but catching more bugs is generally good for any project. if you've ever written a program in a very strongly typed language like haskell or rust, then you can be pretty certain that once you compile your program, it will work as intended.

Well, people are in fact fallible, and safety nets are a good thing.
Cowboy coder mentality and expecting people to be perfect is bullshit.
We have tools. USE THEM.

THIS. They are just too lazy to learn it and shitting on it easier for them.

C++ is C++ for retards

>safety nets are a good thing
No, self-reliance is a good thing. Safety nets in any form make people complacent. Take them away and people develop grit.

seat bags, air bags, abs, traction control, pedestrian auto emergency braking, driver attention detection, etc. are shit because you should be self reliant when driving a car.
those safety features in cars just make people complacent, take them all away.

fuck you for making me reply to your retarded argument.

It's true, though. The best drivers on the road are the ones in the least safe vehicles.
Besides, wearing a seat belt makes it harder to reach the hand brake when you're getting ready to drift.

Its not true though.

Your parents fed you as a child and it shows.

Rust is already far better than C++ or the C abomination. NEETs in Jow Forums who LARP as kernel developers would disagree but they don't matter.

Attached: 1548072720735.png (1866x1944, 317K)

How on earth does it prevent race conditions?

It doesn't, that's just hype talking

Rust is unironically white man's based and redpilled language

>No shared resources that you can mutate
Promotes capitalism, and private property rejects communism
>has own build system
Means that it has own means of production, does not rely on others like socialists
>has unsafe blocks to keep C interfacing code segregated
Social classification.

Rust is the ultimate redpill, a thinking man's language.

Attached: 1542629541459.png (1200x800, 43K)

It prevents data races, not race conditions.
Easy terms to confuse.

Assembly ftw!

It's not as fast yet. (rust is my language of choice but speed is still an issue)

There is nothing about Rust that offends me but I'm not going to learn it unless someone pays me to do so. It just doesn't stand out as the kind of thing I'd learn for fun and personal pleasure.

C is as fast as assembly

If that were true performance intensive C libraries wouldn't have handwritten Assembly in them.

>people develop grit
People don't develop grit. They have levels of "grit" (conscientiousness) programmed into them from the start by their genes. Remove safety nets and those who aren't conscientious either die or fail to breed. Not a bad thing, but let's not sugarcoat how it works.

A safety net is something that lets you proceed when you make a mistake or somebody else makes a mistake that affects you. It's what a literal safety net does. It saves you when you fall. This is not a what a type system does. Type systems prevent you from making mistakes in the first place. Type systems aren't safety nets.

Type systems aren't too different from Rust's borrow checker in that regard. In both cases the compiler yells at you and refuses to compile your shitty code.

>Type systems aren't too different from Rust's borrow checker
No shit, retard. The borrow checker is part of Rust's type system. Learn a thing or two before you talk about PL theory.

REEEEEEEEEEEEEEE

It sounds like neither of you know what you're talking about, so you're no help at all.
Since the designers are the pro-safety-net type, it probably does work like a safety net.

Every optimizing compiler second-guesses your code every step of the way. Therefore, this is an argument against optimizing compilers in general and for writing everything assembly language. I hope you follow through and do it.

This. Autists should grow a spine and use the only true programming language.

Fuck yeah.

>Since the designers are the pro-safety-net type, it probably does work like a safety net.
Can you elaborate? You appear to be saying that the designers' mindset "probably" fundamentally changes how type systems work, transforming them from something that prevents mistakes to something that lets you live with them.

Insanely ugly syntax due to 'design by committee'

Every language feature under the sun due to 'design by committee'

If you are a white male and want to be part of the community you need to grovel at the feet of the minority members and denounce your white oppressiveness at every possible turn, and you will still be hated.

No fucking thanks!

Attached: Ashley Williams, Rust Community Lead.png (1169x1001, 656K)

Linear typing is great. The problem with Rust is the culture. I don't want to interact with Rust's community. All I can hope for is more languages based on the same idea. Maybe someone in Asia or Eastern Europe will clone Rust.

I'm learning haskell and elixir, should I learn rust too?

This is her now.

Attached: e-n_dik9_400x400.jpg (400x400, 31K)

Do you know any language with manual MM?

>Insanely ugly syntax
that pretty much sums up my experience with rust, its syntax is way too ugly and messy. Its not like there arent languages with uglier syntax, hell look at brainfuck for example, but in my personal experience, for being the """replacement""" for C/C++, it felt unatural to write instructions.

He meant to say c++ for faggots.

>handwritten Assembly in them.
Assembly inside C is for problems like cache coherence or consistensy and for implementing h/w specific operations.
Do you know why faggot? No you don't because you are a rust faggot.
Assembly inside c is not optimized by the compiler.
Imagine that you want to implement "print" in a risc machine.
Mainly you have to add a number to a register, then run so ething like "syscall"
Syscall reads that special register and does sonething. The compiler sees independent operations and either optimizes them, maybe eliminate them, and/or reschedukes them.
Imagine throwing the syscall call several instructions later.
I am white. I've written my own compiler, I am not a nigger like you, rustfags, who know shit about s/w yet you post on your blo/g/s how pretty is rust and how cisscum is C.

I'm not a rustfag. I'm white and have written several compilers, including one for Haskell. Rust is the most syntactically ugly language I have ever seen. I personally enjoy working with Assembly and writing compilers is one of the areas I can do that in a productive way.

Fuck, why did you remind me

If the compiler is its best component then Rust already lost the battle, you are speaking about a complementary tool to a Language, programming languages are about semantics the tools and frameworks come and go

i don't get it either, how in their sane mind though that making that bloated monstrosity was a great idea?

>t. never written 10,000+ line applications in my life
I hope you're having fun writing toy programs every day and complaining about functional languages and ownership tracking on a Cambodian wood carving forum. Even GC'd languages manage to hit null pointers every now and then.

based
kill whitey

t. assuming anons' prior work experience and missing it completely

This

>Rust is the most syntactically ugly language I have ever seen
More so than other curly brace OOP languages, like C++, Objective-C, Swift, or Scala?

C++ and Objective-C look like dogshit and somehow Rust manages to look even worse. I found myself quitting Rust projects just because I didn't like looking at them. Swift is actually very pretty.

Why not just admit that you're mentally challenged?

are yall srs rust looks just like c++

D is the prettiest curly brace language. Too bad it has no users.

Give an example.
Most C++ code I see looks worse than most Rust code.

>are yall srs
the rustfags are.

C is actually FASTER than assembly
You can use C API's for CUDA, there is no assembly language for GPU's.

Pure functional programming is bug free.
Write language in a functional style if you want to avoid bugs, don't rely on endless checks to make imperative programming bug free. That defeats the purpose of imperative programming (which is to take advantage of the fact that a Von Neumann architecture can self-modify itself).
Ironically, LISP is super bug prone, homoiconicity fundamentally creates bugs by embracing the philosophy of the Von Neumann architecture.
There are benefits to this of course, which is why immutability/FP isn't always the right solution.

>Pure functional programming is bug free.
t. unfeeling psychopath with robot tentacles for arms

blog.adacore.com/getting-rid-of-rust-with-ada

BTFO

The replies in this thread are a great example of why rust will never amount to anything.
Rust: garbage language for garbage "people".

Ok, tell me when you're finished compiling a Hello World program. Can take a few hours, I'll wait.

more like, c++ for people who finally understood how messy c++ is

>no concurrency
No thanks. Not using a language for retards.

The Linux kernel has had bugs related to race conditions, buffer overruns, and dangling pointer dereferences (not the same as null pointer derefs), even after two decades of development with excellent systems developers at big companies.

You simply can't fully eliminate those bugs in codebases past a certain size without provable memory safety.

No. Other way around. You don't need it when starting out, but you start to really appreciate the need for it when projects grow past a certain size and you cooperate with other teams.

>rust
>no concurrency
user...

No, it provably does prevent race conditions with the sync trait. Threads can't race to access data, or generally to communicate with other threads without locks.

>Pure functional programming is bug free.
Depends on the language. Haskell is a purely functional programming language but it has partial funcitons which are defined as pure functions but throw exceptions. Head is a partial function and it's defined as:
head :: [a] -> a
you'll notice from that signature that it isn't possible to return a if the list is empty, hence it throws an exception when you pass it an empty list.
it should have been:
head :: [a] -> Maybe a
or
head :: [a] -> [a]
so that you are forced to handle empty lists instead of it throwing an exception from pure code like a fucking moron.
whoever came up with pure partial functions, especially for the default prelude for Haskell, should be hanged from a tree and set on fire.

The only time you should _ever_ throw an exception from pure functions if it truly is an exception, such as out-of-memory or hardware failure, which you are unable to forsee until it happens.

Here's a really good article by FP Complete comparing Haskell and Rust safety, well worth the read:
fpcomplete.com/blog/when-rust-is-safer-than-haskell

Rust's literal slogan is "fearless concurrency"

It has no support for epoll, or anything like it, without third party libraries that are not cross-platform

>It has no support for epoll, or anything like it, without third party libraries that are not cross-platform
CONFORMING TO
The epoll API is Linux-specific. Some other systems provide similar mechanisms, for example, FreeBSD has
kqueue, and Solaris has /dev/poll.

eh..

It's up to the language to make a cross platform interface

>epoll is about concurrency

you confuse parallelism with concurrency with asynchronous with blocking

Attached: 1549480446049.jpg (638x558, 64K)

Why are CTards so embarrassingly clueless?

Attached: 1544729016111.png (1098x1126, 492K)

mio is that and it's cross platform.

the language itself is ok but the community behind that language , jesus fucking chirst. all thefucking mental illnesses you can imagine. trannies, faggots, non binary whatever sjw niggers literally all the leftist commie cancer you can name it has all. total ruby copy in terms of the community. pushes away from using it.

they ones who created it probably thought that writting safe C++ code was incredibly hard, so they chose to create something that has that memory safety already by default to save themselves all the time that it takes writting and testing for memory leaks. As to why writting an entire programming language with this in mind insted of using something like ada, which follows the same principles and has real use cases, i have no clue.

this

Here, more accurate image

Attached: DyeM30gWkAEGgFu.jpg:large.jpg (1536x2048, 503K)

LMAOing at your life

What the fuck is this disgusting creature

Attached: DxzTxyhWsAAS7bY.jpg:large.jpg (1536x2048, 490K)

Why should I use Rust over Zig?

Attached: 1466419328712.gif (209x229, 2.3M)

> or maybe you should kept in mind that none of your destructors actually got invoked because some exception was thrown
Destructors are called on stack-unwind, which includes when exceptions are thrown
> can't iterate over unicode strings
that's why utf-8 is designed the way it is. It allows your unicode unaware code to iterate over utf-8 strings and also to find ascii characters, such as newline if you want to split by newline. But yes, sucks that c++ standard library still doesn't have basic utf-8 functionality.

D killed off their userbase back in 2000s.

Too bad the reference compiler wasn't free for a very long time. What were they thinking? also D uses ancient linking system which gives you c++'s ugly linking errors.