Mfw no perfect programming language exists

Perl 6 : Beautiful, but you need to declare Int as Int:D

Well C++ isn't C now is it?

Huh it's almost as if certain languages are better at certain things like others and you should make sensible logical choices instead of ideological ones. Really makes my think become the big think.

>Java: everything is an object

Java programmers wish that were true. Fucking primitive types.

>Javascript: everything is broken
I chuckled OP, thanks.

Attached: 1558848090328.jpg (600x600, 63K)

unironically Haskell.
1st class lists
mutable/immutable arrays/vectors for performance
monads and monads transformers are nice
parallel strategies are top tier

Guix

Dart, unironically

You can use cython to at least compile it to C-like speeds.

Assembler: everything is in your head (and hopefully on the comments as well)

Ruby: everything is beautiful

Would you rather spend all day looking at a glimmering gem, or a bunch of "code?" Oh wait, you're a tranny on Jow Forums nvm I already know the answer.

Attached: index.jpg (225x225, 9K)

>Python: everything is slow

D

You think you do. Then you look at Ruby and you see what a mistake making everything an object is.

Take Java, C++ and OCaml off that list! You might hurt someone! (OCaml is fine tho)
The rest deserve their place on the everything-list, but you forgot Smalltalk, which is the only real OO language and based for it. Also, everything-is-a is good design. It enables programmers to focus on solving problems instead of fighting their special needs languages that are not on the list.

C(uck)

Ruby is fucking magical. You can type anything you want after the dot and it will just work. I don't see the "mistake".

Rust exists.

Storing strings and numbers as objects is hugely inefficient. Boxing everything leads to inflated sizes and pointer chasing for minimal benefit.

>Using a meme language that doesn't even have a proper increment operator because the people that use it are brainlets

Coq or Agda

Incrementation operator causes lots of undefined behaviour, while providing barely any advantage.
Unlike C, safe Rust has no undefined behaviours.

Assembly: reality can be whatever I want

So? Ruby is optimized for development speed. There's nothing wrong with that. If you have hot code that needs to go super fast, write it in C.

Compared to all other languages in OP’s list, except C++, Python is lightweight and extremely fast.

Good for webdev and scripting, wouldn't use it to write a graphics library though

>Javascript: everything is broken
I think it's more the ecosystem than the lang that's broken, see John Shlinkert

>mfw no perfect tool exists

Hammer: Can't be used as sandpaper
Philips screwdriver: Can only screw in screws
Jackhammer: Too violent to glue some wood together
Angle Grinder: Can't sow together two pieces of cloth
Spanner: Can't hammer
Forklift: Can't be used for tiling a bathroom floor

USE WHATEVER FITS YOUR REQUIREMENT

CPython is slower than literally everything on that list...

>Conveniently not mentioning C# just to make a false point.
You tricked a lot of anons into posting in your thread though, bravo.

That’s demonstratively wrong.

Demonstrate it, then. Head to the Debian language shootout or some other benchmark set and find me something on which CPython does better than Java, OCaml, V8, SBCL and Racket.
(I will concede that CPython is probably faster than BEAM, and I have no data on any Forth implementations.)

Kotlin.

Note that I said on ops list, retard

That's OP's list, dumbshit.
V8 is the current standard JavaScript implementation and all the others are just as fast anyway.
SBCL and Racket are the two most mainstream Lisp implementations, except for the one that pretends to be a text editor.
Is there something else that confuses you, or can we skip to the part where you somehow provide proof that Python is faster than all of those?

If a modern language doesn't have shit any reasonable or halfway usable language does by default, it's shit. Also, if you aren't a retard, you can get rid of undefined behavior by writing quality code

>extremely fast
I make a living writing python and I can assure you no python implementation is faster than Javascript's V8. I don't know about Lisp, I only used Steel Bank Common Lisp, but I'm guessing it's also slower than that. And there is no way Python is faster than Java.

>If a modern language doesn't have shit any reasonable or halfway usable language does by default, it's shit.
So C is shit because it doesn't have classes?

Moving the goal post much? You said that CPython is slower than everything on that list, but it's faster than Haskell, OCaml, Forth and Elixir.

>If a modern language doesn't have shit any reasonable or halfway usable language does by default, it's shit.
>C lacks classes
It's shit
>C++ lacks pattern matching and modules
It's shit
>Java lacks structs
It's shit
Etc.

>Also, if you aren't a retard, you can get rid of undefined behavior by writing quality code
It's not about writing quality code. Rust is a well designed language, it doesn't have any undefined behaviours. You can't have incrementation without confusing shit like
i = i++ + ++i;
That's why Rust doesn't have it, just write:
i += 1;

Oh, I see. You're right, I was wrong - it's probably faster than Elixir.

Java and JS are of course very fast, especially JS with some superoptimised engine, I'm not convinced that Racket would perform better.

Classes are just glorified structs tbqh.

Then don't write shitty code. The problem I have with Rust is that it tries to solve problems that only exist because people are shitty programmers, not because it has something genuinely needed like C++, Ada, Fortran (95 onward) and Scheme do with object orientation or Haskell does with its back to basis functional programming (which is also useful for mathematics) or even Python (whichh is glorified psuedocode). All of the problems Rust is trying to solve can be solved by not being fucking incompetent. Even GO at least has an edge since it's good for networking shit.

Rust exists

if it is slow you are not knowing python very well - not utilizing its ecosystem properly

Not writing shitty code won't make your language well defined and provably correct.
Ada doesn't have incrementation nor += operator. I guess that makes it even more shitty? They literally say in documentation that these operators are confusing. Ada developers are more incompetent than Rust ones, aren't they?
Oh, Fortran doesn't have them either.

I don't have time to waste to list actual problems Rust solves, because you clearly just memeing. Seriously, educate yourself and came up with real, consistent arguments.

>povably correct
>Rust
pick one and one only

prolog exists

javascript exists

>javascript
>better than prolog
try again pajeet

Golang exists

Everyone writes shitty code, including you. Pros like language-level safety, pajeets think it's useless.

>moving the goalpost

Attached: 1535433862008_0.jpg (584x575, 50K)

Golang: everything is a meme

you can build everything from the backend to the front-end with javascript. You can also create desktop apps. You can even use firebase to host everything on it, from DB to front-end.

With PWA's you can also replace writing native apps for mobile.

which goalpost? it's my first reply itt, i just like triggering Rustfags like you by pointing out there's no way to write provably correct Rust as of anno domini MMXIX
you can write provably correct C and Ada

Rust is build around the idea of compile time checks for valid pointers, data races, null references, etc. It's impossible to write safe Rust code with undefined behaviour. That's the idea. Technically you can write provably safe code in any language, but Rust forces you to do so.
Any kind of undefined behaviour prevents static analyzers from analyzing your code by definition. C has lots of it.
Not sure about Ada, but it's similar to Rust its goals so I suppose it also tried to get rid off undefined behaviour.
Anyway, there is no reason for Rust to be any less provably correct than C, but there is plenty of reasons for the other way around. All boils down to what you consider provably correct language.

>everything is a monad
As if that was a bad thing, but your list shows that you don't even know what a monad is. Lists and stacks, class constructors, promises, even pointers to an extent, so basically anything that you use to: "Modify or wrap a type/value but still use it as it wasn't but the wrapping is for case/error handling purposes" is a monad.

>hurrr lack of ub means provably safe
>rust forces you to write provably safe code using an unproven borrow checker
>static analyzers can't analyze ub
The only correct statement in your post is that there's no reason for Rust code to be less provably correct than C code.
The issue is that, as of now, it is impossible (as in you actually can't do it) to verify correctness of your Rust program, while it is possible (and frequently done) to verify correctness of your C program. Furthermore, it is impossible to verify correctness of your Rust binary, while it is possible (and done not-as-frequently) to do so with your C binary.
>All boils down to what you consider provably correct language
It only has one meaning. You rust trannies might be used to cucks changing definitions to conform to your degeneracy, but formal verification is, well, pretty formal and we have strict definitions for everything. You're not changing what it means.

SBCL is faster than Java most of the time and a little bit slower then C++. Pretty good given that you can write software almost as fast as with Python.

>It only has one meaning. You rust trannies might be used to cucks changing definitions to conform to your degeneracy, but formal verification is, well, pretty formal and we have strict definitions for everything.
Can you provide proper definition so we will have equal ground?
What I meant by provably correct is that it's free from undefined behaviours, is memory safe, hazard free, etc.

HolyC: everything is as God willed it.

>Pros like languages that are fast and don't have extra meme bullshit as the selling point of the language. Baseddevs think that it's useful in an industry setting
FTFY

Only sensible post itt

> Rust
Everything is gay

"Proven correct" means it's free from logic errors. In C, memory errors are logic errors. Rust can only detect memory errors. Logic errors in a Rust program are undetectable.

Ruby: everything is an object

Alright, gotta read more about that.
What I originally mean was probably safe, if that's a term.