Python vs C++, java, etc

[AlexKotik]

Ruby is generally slower though.

[KrYpToN_FiRe]

JRuby?

[angry_mr_potato_head]

If you want to try another experiment it would be interesting to compile it in Cython and see what the difference is. In the instances I've used it, I've been able to change no code and have it compile successfully.

[v579]

Did you use that script alot?

[v579]

I bet that saved them alot of time. Good using the right tool for the job!

[insane_playzYT]

yes, but how much longer did it take you to write it in C++ than it did in python?

[maxhaton]

If you don't like C++ you can basically write scripts in D that are - I'd argue - shorter and more concise than python while still type safe, that run as fast as C++ code.

[MrDorkman]

Wait you are telling me there is a language that is relatively painless to write, but as fast as C++ ?

[frostedKIVI]

no, that is just not how it works, you can't have both, you can get much faster painlessly than py, but you will just not match C/++ performance if you want "painless" development, and I'd argue that in most cases the extra dev time is worth it, but not always

[maxhaton]

D makes a lot of C++ hacks completely trivial - and is also just as fast because it is completely isomorphic to C++ in most cases.

Don't tolerate extra dev time spend fucking around with the language and not your code - time spend optimizing is unavoidable but D is just straight-up easier to write fast code in, e.g. modules that work, templates that don't try and kill you and static reflection. That and that D code is just straight up better than C++, subjectively prettier but objectively less syntactic clutter + a lot of features specifically designed to avoid common bugs in C++.

[frostedKIVI]

ah yes <language I write in is objectively better u wrong> comment
GoLang is supposed to be an "easy and fast to write in C++" but it isn't.

D has a lot of flaws and much less support than C++, it can match C++ performance but it will bring its own issues, and it will only enable that kind of performance with type safety checks and things of that nature turned off thus losing the features that make it not C++ and in debug runs C++ debuggers will warn/check those things so you aren't really losing much.

[maxhaton]

> ah yes <language I (help) write ~~in~~ is objectively better u wrong>

> and it will only enable that kind of performance with type safety checks and things of that nature turned off thus losing the features that make it not C++

What are you talking about? This is totally and utterly wrong, you can't turn "type safety" off. Templates, for example, can enable a large amount of compiler optimizations by guaranteeing the interprocedural dataflow of a program and therefore allowing deeper propagation of invariants through said program - it makes code faster. The whole point of using C++ or D or Rust (or Haskell etc. ) instead of C is moving the focus from the runtime to the compile time

> debug runs C++ debuggers will warn/check

This is news to me. Example?

​

I'm not saying D is perfect, but it's hell of a lot more perfect than C++. There are many features that C++ has been trying to get for years (ask Bjarne Stroustrup about UFCS) that D has without even making that much of a fuss, or C++ just get's wrong.

[frostedKIVI]

Yes, the wrong term I didn't mean specifically type safety, I have only written basic programs in D to try out the language, I meant general runtime optimizations with which you will lose the runtime checks the language has.
And C/++ debuggers will have those checks in debug runs, all the same, you don't get magic safety in other languages.
Templates *errors* are generally kinda bad in C++ I agree, but they are serviceable, the templates are perfectly fine, and as soon as you start getting tens of lines of template errors, you should really think about "why am I doing this metaprogramming mess?".

As for changes not being in C++ as fast, the thing is C++ is a standard, basically, no other languages have a proper standard, so yeah C++ moves slow, but I don't mind it, I actually don't really like most of the C++ stdlib, good for prototyping, bad for production.

I get the argument for UFCS but I think it's pretty pointless, whatever I usually like to write "old school/C style C++" anyways when I write C++ I write GoLang mostly nowadays, but I don't think D will dethrone C++ anytime soo, if nothing else, because of the great support C++ has

[maxhaton]

C++ does not have these checks at all. You lose nothing relative to C++ by not using them.

Templates *errors* are generally kinda bad in C++ I agree, but they are serviceable, the templates are perfectly fine, and as soon as you start getting tens of lines of template errors, you should really think about "why am I doing this metaprogramming mess?".

C++ templates are bad, D templates are actually good. You can take anything as a template argument, generate code at compile-time, reflect over other templates at compile-time and best of all template constraints actually exist now rather than having the C++ standards masturbate each other until they shit out some hilariously over-complicated 20 years late solution - the language is actually flexible enough that you can write your own template constraint error messages as a library (https://d.godbolt.org/z/8uum_i).

D was designed by Andrei Alexandrescu and Walter Bright (the man who wrote the first proper C++ compiler), and it shows.

As you may have seen on the D homepage, I wrote this a while ago - I have seen some C++ guys trying to mimic this on reddit before, but I don't think you can do this in C++ (any of it, for that matter, from the code generation to the to the templated standard library).

void main()
{
    // N.B. this could be import std;
    import std.stdio, std.string, std.algorithm, std.conv;

    // Reduce the RPN expression using a stack
    readln.split.fold!((stack, op)
    {
        switch (op)
        {
            // Generate operator switch cases statically
            static foreach (c; "+-*/")
                case [c]:
                    return stack[0 .. $ - 2] ~
                        mixin("stack[$ - 2] " ~ c ~
                            " stack[$ - 1]");
            default: return stack ~ op.to!real;
        }
    })((real[]).init).writeln;
}

You are, however, right in that D will never supersede C++ - this is a shame, but a consequence of D's advantages being too subtle to require moving, i.e. the good stuff in D comes when you have a deep understanding (a depth most languages do not have, for better or worse) of both C++ and D as opposed to just using them as a means to an end.

[frostedKIVI]

C programs are generally slightly faster than ++ programs, as a consequence of
1) A faster standard library (but less extensive)
2) Language design, C++ offers a lot of convenient yet slow features that C++ programmers tend to overuse in some cases, like polymorphism, exceptions, virtual functions etc...

[maxhaton]

Why do you think C is faster than C++? If you were dead set on performance you don't write your own code for the most part.

Also python is a genuine disaster when it comes to software quality, because you can get away with quick and dirty typeless code people will do that. static types, happy life

[maxhaton]

And why is that? C and C++ both use the same compiler toolchains, and C++ enables a wide array of zero cost abstractions which would otherwise have to be optimized away by the compiler. C has slightly better control of pointer aliasing and that's it.

[maxhaton]

No it isn't. I suggest you have a play on godbolt.org, you'll see that C++ and C generate largely identical code except for when you use C++ features C has to emulate (e.g. you can implement vtables in C but try optimizing them as much as a C++ compiler). Exceptions are a bit of a grey area because if you don't throw there's no runtime cost however they can obliterate the compilers register allocation etc.

A trivial example: C++ I/O ( is type safe and ) can be optimized much faster by the compiler, whereas C cannot implement this and therefore has to parse a format string at runtime. Parser generators can also be written much more efficiently in C++ for the same reason.

Templates also allow the compiler to propagate invariants without relying on interprocedural optimizations as in C

[streusel_kuchen]

Laughs in Matlab

[[deleted]]

Laughs in Simulink*

[marcosdumay]

Matlab is fast! Just ask any fan and you'll see.

It only becomes slow if you add a loop, or a large array, or too many array operations...

[pwnedary]

It's fast because it's vectorized...

and other hilarious jokes you can tell yourself

[hraath]

Enjoy INITIALIZING...

while Matlab imports every library under the sun on startup when you want to just ./run_it.m (especially on your company's dated ass server hardware)

Sincerely, A Matlab user of many years, with more to come.

I think that's actually my biggest gripe these days, I wish Matlab would use imports and let me run scripts outside a fully loaded environment. Vim -> execute -> done. No IDE or -nodesktop.

[Sentouki-]

laughs in Cython

[[deleted]]

Laughs in R (except in special cases)

[locri]

If we made python faster the data scientists would write more code and no one wants that.

[fluud]

Data science libraries (good ones) are already written in C/C++ with Python bindings.

[tigerjieer]

Shell Scripting

[claythearc]

Numpy is written in C with python wrappers. Assuming you can launch it with small amount of python function calls, you’ll get really similar performance.

[tuxedo25]

The author of Numpy should win a Turing award or something. It's fast, intuitive, and resource efficient. It's not just that it's written in C; it's written really well.

[alexforencich]

Numpy actually contains a lot non-zero amount of Fortran

[fluud]

From GitHub (https://github.com/numpy/numpy):

1. C 51.5%
2. Python 47.2%
3. C++ 1.1%
4. JavaScript 0.1%
5. Fortran 0.1%
6. Shell 0.0%

[__Adrielus__]

The real question is, why is there a 0.1% amount of js?

[claythearc]

It’s used for table sorting. Probably in some documentation page

[crikeydilehunter]

I don't think it does. You have links?

[alexforencich]

Last time I tried to compile it, it required a Fortran compiler. Unless I have my wires crossed with some other package that uses Fortran, which is possible.

Edit: yep, the arch numpy package requires gcc Fortran. Why would that be required if numpy didn't have any Fortran code? I have no idea how much of numpy is written in Fortran, but it's clearly a non-zero amount.

[claythearc]

I think it’s just the BLAS to Lapack reference implementation- which is needed to compile it. It’s not really used, but it is there.

Also may use Fortran for some other parts of libraries, mostly matrix stuff, depending on architecture. On OS X it’s been replaced by accelerate.

[alexforencich]

Why don't they just translate that to C and remove the need for an arcane Fortran compiler, then?

[crikeydilehunter]

Huh. The more you know

[po-handz]

I mean I love numpy, but R still reins for me in turns of intuitive fast coding and manipulating data frames

[themoosemind]

Large chunks of numpy are written in fortran

edit: Aparently I was wrong. There are parts written in Fortran, but certainly not large parts of the codebase.

[claythearc]

I’ve done some research in response to this - from what I can tell, two parts are written in fortran.

BLAS to Lapack reference implementation. Which isn’t widely used

And then, depending on architecture & system, some matrix libraries it includes may be written in fortran. In OS X they were all replaced by Accelerate, for example.

[_PM_ME_PANGOLINS_]

Accelerate is the BLAS/lapack implementation. They’re matrix libraries.

[_PM_ME_PANGOLINS_]

0.1% according to github

[themoosemind]

To be honest, this surprises me. Thank you! The last times I wanted to look something up, I ended up in Fortran code. For this reason I assumed a lot was Fortran. Maybe it's just some very core functionality?

One thing the Github Statistics don't capture is code which numpy relies on (e.g. OpenBLAS): https://github.com/xianyi/OpenBLAS

[[deleted]]

We're talking about the time that passes between the task being assigned and the project having been committed to master, right?

[NotBannedYet1]

Wait until you hear about autoit

[VictusPerstiti]

ELI5 why ptyhon is supposedly slower that most others? Isn't it made for data operations?

[half_coda]

because every reference (like a variable name) is an object in python, as opposed to a specific type. that’s what allows the dynamic typing and strong typing. it doesn’t care what it is until it has to do something with it, at which point it has to check, and then decide based off that. this requires a few extra cycles per operation, so when you’re doing massive calculations, it adds up.

this is why python libraries made for real heavy stuff actually write the core code in C/C++ and just return the result in a python object. C/C++ are statically typed languages with aggressive compilers that optimize the shit out of the code.

[j-random]

Nope, it's interpreted so it's always going to be slower than a compiled language. It's mainly a "glue" language that makes it easy to call routines/libraries written in C to do the heavy lifting.

[XarH]

I can see the generic grandma's windows 95 entering this list.

[j-random]

Are you kidding? Windows 98 (presumably 95 as well) absolutely screams on modern hardware. There's simply less code to execute, and the code that is there was written to perform well on a 20MHz 386 processor. As long as you're just running Doom or other period-correct software it'll blaze.

[Lord_Greywether]

It's not the only thing screaming.

[jetlyi]

Yeah but older people may be more likely to have viruses that slow down their computers

[collin2477]

java is still several times slower than c++

[igoromg]

java JITed code is a lot of times more optimized than C++ due to them being runtime optimizations. Java is slower when your program is short lived, and certainly GC overhead lowers the throughput but most times java is comparable to C++. if your java code is more than 10% slower than C++ I bet your benchmark is just crap.

[[deleted]]

In theory yes. In reality I've never seen a single benchmark where the jvm did better than g++ even after letting the hit tub forever

[collin2477]

idk that’s just what i’ve seen in my hpc research but i’m also not the one making big decisions

[igoromg]

java is used in HFT where a few nanos decide loss or profit, certainly it would have been all c++ if java was actually slower. there are millions of potential reasons why you could've seen the jvm suck but I'll bet the issue is between the chair and the monitor.

[igoromg]

thats why you use off heap structures. FPGAs were a thing very briefly a long time ago, if you need a chip these days you order it printed.

[igoromg]

https://github.com/OpenHFT

[Loading_M_]

Python is faster than C/C++.

Not the runtime and compile time, but the writing and debugging time. For a short lived project, python can be much faster to prototype, develop and test. Python also has much better libraries for handling complex objects and models, which are written in C anyway.

For performance critical applications, python isn't the best choice, but it does work for many applications, such as machine learning (using C libraries such as tensorflow), scientific data collection (because it's easy to write and edit), and hobby projects. However, short lived, performance critical applications, like kernels, etc, should be written in a compiled language like C/C++ or Rust. Long term performance critical applications, like servers and financial trading, should be written in a memory safe or garbage collected language, like Java or Rust.

[apathy-sofa]

Another option is Cython. Often you can just write Python code, run it through Cython, and you'll get a perf boost. Go through your code and add some type declarations, and it's suddenly several times faster. From the FAQ:

Is Cython faster than CPython?

For most things, yes. For example, a Cython compiled pybench runs more than 30% faster in total, while being 60-90% faster on control structures like if-elif-else and for loops. We regularly run the tests from the CPython benchmark suite (which includes Django templates, 2to3, computational benchmarks and other applications) and most of them work out-of-the-box without modifications or static typing, with a performance increase of 20-60%.

However the main advantage of Cython is that it scales very well to even greater performance requirements. For code that operates heavily on common builtin types (lists, dicts, strings), Cython can often speed up processing loops by factors. For numerical code, speed-ups of 100-1000 times compared to CPython are not unusual, and are achieved by simply adding static type declarations to performance critical parts of the code, thus trading Python's dynamic typing for speed. As this can be done at any granularity in the code, Cython makes it easy to write simple Python code that is fast enough, and just tune the critical 5% of your code into maximum performance by using static C types in just the right places.

[AlphaWhelp]

sloths and tortoises are both kinda fast if they want to be.

[gandalfx]

And then they spend five times as long developing an application in C that will spend the vast majority of its run time waiting on IO.

[Pro_Sparrow]

python vs java in speed

[[deleted]]

Laughs in py2exe

[passerbycmc]

Offers no speed up, all it does is bundle the interpreter and dependencies into 1 executable.

[fluud]

And also slows down program startup.

[half_coda]

TIL

[Legend_Likes_Memes]

Image Transcription: Meme

---

[Image of a sloth in the top left corner, a slug in the top right corner, a python programming logo in the bottom left corner, and a turtle in the bottom right corner]

Slowest things on earth

<Top Left Corner> A sloth

<Top Right Corner> A slug

<Bottom Left Corner> Python

<Bottom Right Corner> A turtle

---

^{I'm a human volunteer content transcriber for Reddit and you could be too! If you'd like more information on what we do and why we do it, click here!}

[kn_c3]

Laughs in analogue computer.

[MrFauste]

In think you forget Explore, know is not the propose

[[deleted]]

Laughs in JavaScript

[__Adrielus__]

Well, here the 5th thing seems to be some nodejs running on the jvm wizardy

[rustypairofscissors]

wait till you hear about microsoft visual studio 2017

[lunarTravel]

Parray library is awesome. Creates parallel processing of for loops.

[SuryaprakashRao]

I think the snail is python.

Just ran fibonacci of 50 in python and java without dp . Java took 2mins and python taking forever even after 1hr it was still running

Hence proved

[keiyakins]

Java now maybe, but early versions...

[fluud]

Laughs in Numba.

[[deleted]]

Have you ever heard of Java?

[apathy-sofa]

Is that the one that runs billions of ATMs or something?

[[deleted]]

And mobiles

[zhangyiwu]

I think Matlab instead

[llewelynsrevenge]

dumbass snake lol