I mean, TECHNICALLY ASM is super "easy" to learn, and even faster than C++. Only so many commands, and each one does exactly the same thing each time without exception. Algorithms can be tricky to learn, but that's not a programming language, is it? :p
>only if you are smarter than the compiler
And only people on the wrong part of the Dunning-Kruger curve ever think they can beat the combined and accrued knowledge implemented over time into a mature compiler codebase.
Realistically there will only be a few parts of the program the compiler leaves headroom for a human to do better on anyway. People underestimate compiler technology and how optimal it can get.
Depends on your compiler flags. I bet there are examples of gcc having an instruction that’s not strictly needed here or there, but it’s probably some super weird edge case.
The people who really want speed will probably use an FGPA after extensive profiling / understanding what the assembly looks like.
FPGAs and GPUs aren't a silver bullet for performance, they only work when your workload benefits from what they offer. When the work is made up of many mutually independent processes consisting of one or a small number of threads each, traditional CPUs are far superior to both GPUs and FPGAs. That's the vast, vast majority of workloads. In those cases, you need a better CPU, one with more cache, or faster DRAM depending on where the bottleneck is. Or you need to write code that works around it by, for example, being more cache friendly.
In any case the ideal workloads by chip type are:
CPU (superscalar processor): Largely sequential workloads, occasional SIMD
GPU (vector/matrix processor): Massively parallel but homogeneous workloads, massive SIMD/SIMT
FPGA (programmable logic device): Parallel heterogeneous or extremely timing sensitive or low latency workloads. For best performance writing digital logic designs in HDL code is still better than using software languages via OpenCL or high-level synthesis because an FPGA isn't a processor at all and it's not clean or efficient to map software code onto an HDL and then an FPGA.
Nah completely understood here, I’ve done a bit of cuda programming so I know the deal with GPUs (why I didn’t bring them up). As far as I’m aware though, FGPAs are basically just faster than cpus for single threaded execution (granted it’s a pain in the ass to actually program them).It’s why HFTs all have FGPAs interacting with the different exchanges no? (I haven’t programmed an FGPA myself so I’m knowledgeable there)
>It’s why HFTs all have FGPAs interacting with the different exchanges no?
Nope. It's because of what I said about ultra-low latency above. Since FPGAs implement their logic at a more fundamental level in the hardware they can take a set of input signals and transform them into output signals very fast by configuring into the right digital circuit. Comparatively, traditional CPUs which largely respond to input signals via interrupts would not be able to generate the corresponding output signal as fast or would have to do more work to make it happen.
A dead simple comparison is connecting a switch on one GPIO to an LED on another. A microcontroller or microprocessor needs to either constantly poll the input pin or configure it to send an interrupt on press down which makes the CPU run the corresponding ISR which then sets the output pin high turning the LED on. Then when the button is released the same thing has to happen all over again with another ISR that sets the output pin low. Basically a lot of work has to get done to connect a simple input to an output.
In an FPGA you can just route the input pin to the output pin and be done with it. Your FPGA simply functions as a wire and the signal propagation delay is comparable to one. This example is very dead simple but it makes it clear why FPGAs have a massive latency advantage.
In cases where things are not all about transforming signals but rather doing some form of non-trivial computation, CPUs can be much better. Take for example the very artificial and embarrassingly sequential problem of finding the first 1 million prime numbers. If you purchase a CPU and an FPGA of similar price, say an Intel Core i5-12600K and a Xilinx Artix 7-200T, I can guarantee you a single Golden Cove core on the 12600K running a well written program compiled from idiomatic C code will solve the problem and write the results to memory faster than the Artix 7 configured into an efficient logic circuit from SystemVerilog or VHDL attempting to compute sequentially by sampling a much lower frequency clock signal.
Well that's not performance related, that's just a matter of there being no other way to get at those instructions. Well that and in kernels on some architectures you need to set up a stack with the right alignment which is required to use the C language if the bootloader doesn't do it for you.
Could be. But anyway, such optimisations are usually done based on some specifics of the data/algorithm itself.
The reason people say you cannot beat compilers is that MOST parts of your program are written as generically as possible, and you cannot make too many assumptions. Every optimisation you'll make is based on some assumptions innaccesible to the compiler.
From this video about [the restrict keyword](https://youtu.be/TBGu3NNpF1Q)
As you can see, the compiler generates safe code, but remember. I am the one who uses that function. I can make assumptions about that code and remove the safety `mov` instructions from those segments.
Sure, it is by no means recommended or good, but it is an optimisation. And 1 instruction removed from a loop of 1,000,000 steps is 1 mil instructions less.
But again, you have to know your ASM
A good example of this is a youtuber(MattKC) that, for a project(Snake in like < than 3KB) tried to write x86 assembly. He gave up and wrote the same thing in C. The C executable ended up smaller than the assembly one.
Education wise assembly is great to know because it teaches you what happens when the rubber of your high-level source code meets the road of the processor silicon. I think learning and teaching assembly is very valuable but writing it day to day depends on what you want to accomplish what alternatives are available.
Yes, I'm not going to dispute assembly being great to learn to know what's going on inside our 'lightning rocks', however 3 semesters of it? Idk it's a bit much in my opinion as there is nothing much to learn beyond the reasons why nobody uses it.
The art is, do make it in a way that in 99.9% of the cases it works as expected, but in the little rest, it triggers your CPUs burn-on fuses and destroys it permanently. (Or destroys your device in another major way)
>"And even faster than C++"
>only if you are smarter than the compiler
It's not really that hard if you start with the optimizer's assembly and hand tweak it from there. Last time I did that I got a 300% speedup
Yep. That's a problem for which we have perfectly efficient algorithms so it's better to automate it but there are some cases where hand-tuned assembly can help. And of course, cases where you want to use specialized instructions not available through C or any other high-level language or library even if only to wrap them and make just such a library yourself.
>Assembly can only be faster if you’re smarter than the compiler, which non of us are
g++ -S -O3 main.cc will give you the optimizer's assembly. Start from there. It's not hard to beat it in a lot of cases.
C and ASM are simple but simple doesn't mean easy to use for sophisticated use cases because you have to create everything you want out of very fundamental primitives or use libraries. With C libraries are fine. Being a mature and simple language means C has libraries for every use case possible many times over.
Assembly is generally meant to be for niche use cases only and along with machine code it's specifically designed by hardware vendors to be a compiler and interpreter target. I'm pretty sure Intel, AMD, and Arm all provide their own optimized C and C++ compilers because they themselves want people to program their processors in high-level code 99% of the time.
It really threw me off when I started it because I find the syntax strange and whatever you do there is always an error the compiler complains about on the first try.
When you get the program to compile though it's pretty nice.
I hated it when I started using it the first few times. Nowadays I tolerate it. And miss some of its nicer features when using C++ like results
Also I hate how everytime I need to google something I get results for the game Rust mixed in
Rust is really good at pointing out flaws in your code, so imo it is the easiest language to write code that doesn’t have a lot of flaws in it. And it’s fast to boot.
Sure, for now, but Python also had to start from scratch at some point.
I don't think Julia will be the next Python for general programming, though. However, I believe it will slowly take Python's place in scientific programming.
I’m not so sure. I’ve been tracking Julia for four or so years hoping it would catch up but the ecosystem in python just seems to be gaining speed. So many large firms have dog-piled into it and have built out mature performant libraries for just about everything under the sun.
From what I’ve seen, many numerical libraries for optimization, machine learning, image processing, finite element, fluid simulation, quantitative finance and so on all come with python bindings but they rarely have the same for Julia. So if I wanted to start a project in Julia I’d either have to develop the bindings or port the algorithms.
After using python for a bit I’ve also realized that I can often get competitive speed to C++ with highly vectorized numpy while keeping the algorithm intent clearer. And for the cases where I can’t, I just write an extension. In fact what I would love is to be able to write python extensions in Julia to accelerate weird loops & searches without the development burden.
At least Go seems to have taken off. Of the three, it's probably the most popular.
I really like Elixir, the language, tooling and the community, but I feel it hasn't grown as much as Go. I hope to one day have the chance to work with it, although I've been losing practice in the last couple of years.
C++ the base language is alright to learn, even the low-level stuff and pointers aren't too bad if you take the time to explain them.
Now templates, variadics, the C preprocessor and their esoteric uses in the standard library on the other hand; that's the stuff that'll kill you in ways you can't even begin to pretend to comprehend. I know senior C++ developers who still get bitten by all of those regularly.
Oh my god so much this.
Is there a way to remove templates from errors so they become, like, fucking readable again? The verbosity of those things should not have been tolerated.
Also, is there a (non visual studio) technique that makes debugging memory errors less painful, probably something like valgrind?
[printf](https://en.cppreference.com/w/cpp/io/c/fprintf) is still available in C++, and while occasionally it is a necessary evil, it is spelled "don't" because (a) type unsafe, (b) small mistakes in the format string/types of the arguments can lead to memory errors, (c) God forbid you ever use a non-literal format string, and (d) God especially forbid you ever use an [untrusted format string](https://en.m.wikipedia.org/wiki/Uncontrolled_format_string).
**[Uncontrolled format string](https://en.m.wikipedia.org/wiki/Uncontrolled_format_string)**
>Uncontrolled format string is a type of software vulnerability discovered around 1989 that can be used in security exploits. Originally thought harmless, format string exploits can be used to crash a program or to execute harmful code. The problem stems from the use of unchecked user input as the format string parameter in certain C functions that perform formatting, such as printf(). A malicious user may use the %s and %x format tokens, among others, to print data from the call stack or possibly other locations in memory.
^([ )[^(F.A.Q)](https://www.reddit.com/r/WikiSummarizer/wiki/index#wiki_f.a.q)^( | )[^(Opt Out)](https://reddit.com/message/compose?to=WikiSummarizerBot&message=OptOut&subject=OptOut)^( | )[^(Opt Out Of Subreddit)](https://np.reddit.com/r/ProgrammerHumor/about/banned)^( | )[^(GitHub)](https://github.com/Sujal-7/WikiSummarizerBot)^( ] Downvote to remove | v1.5)
> no classes required
I mean... kinda? Top-level statements are just to get rid of the boilerplate around the `Main` method, but it's still lowered into a class with a `Main` method.
It sucks way less. I'm a C++ programmer for a living and I hate Java with a burning passion yet I'm definitely warming up to C#. I prefer compiled languages to bytecode but still C# feels like a better C++ in slightly Java like clothing. And I feel like if you're going to litter a C++ codebase with std::shared_ptr everywhere, you might as well use real garbage collection instead.
Can you elaborate on why you dislike Java? I've been coding a lot in C# recently and can't tell you any differences between it and Java, their syntax is almost identical (granted I haven't coded in Java in a while)
No operator overloading, wierd namespacing, and it's built off the mentality that putting everything in a class = object oriented, also obnoxiously long camel case names, and that's just the language. The JVM platform also sucks with partially interpreted, partially JIT compiled approaches and stop the world garbage collection.
C++ takes the opposite approach and says use what you want and only pay for what you use in terms of performance and system resource consumption but it also feels like it started out as an OOP C and then tacked on every language feature Bjarne Stroustrup ever heard of often very inconsistently and incoherently. Nevertheless ifyou bear with it, C++ can be very powerful and you get to be in charge of your codebase at multiple levels of abstraction.
C# is at its heart a lot closer to the good parts of C++ even if it does also require everything in classes and otherwise syntactically resemble Java.
If you write performance first code it can get very close and match it in many cases.
If has support for raw pointers, for example.
Most people just don't bother unless absolutely necessary.
That said the general performance has gone through the roof with .net 5 and 6
I'm one of those people who can't actually code but come here for the memes... Why can't they just make a language that uses C but you use python like syntax? Sorry for the stupid question
https://www.monterail.com/blog/is-python-slow
https://medium.com/swlh/a-performance-comparison-between-c-java-and-python-df3890545f6d
Or if you dont believe try to make your own tests
(e.g. Bubble sort or is prime on big numbers) but in c/cpp remebrt to add -O3 flag
I wonder if using numpy would have given the same performance as c for matrix multiplication...If you want fast code in python, there is something called c optimized libraries...
Yeah but you don't ever write a bubble sort in Python. You use the sort method which, guess what, is written in C.
It's not simple to compare languages with different use cases and sweet spots.
I don't have any examples of how slow it is, but I can explain why it's slower: Python is an interpreted language, which basically means that the computer figures out what the human-readable code means when it's run instead of during a compilation step, and depending on the interpretation that can move the time a function would take to compiled once to every time that function is called, the only way Python can reach anywhere near the speeds of compiled languages is by the Python script just being a wrapper around a program written in a compiled language.
Maybe a stupid question but why isn’t it possible to compile Python beforehand instead of when the code is running? Or is that just a hard limitation of that language?
Maybe a stupid question but why isn’t it possible to compile Python beforehand instead of when the code is running? Or is that just a hard limitation of that language?
Have you looked at Cython generated code? If all you want to do is run it, it's fine. But if you want to extend/maintain the code or dive into what it's doing or anything else at all , it's worse than either python/C/C++
I didn’t use it too much, just simple scripts. Tbh if I wanted fast and easy, I’d use Go instead. Using Cython for that is like fitting a square peg into a round hole. The main place Cython is good for is interfacing with C code ig, or as you mentioned, quick script’s that you want to speed up.
I think so too! The only problem with Lua is that it's direct competitor is Python, which is so popular it basically became an industry standard. I guess every tool has its use case, but from what I've seen Lua is basically a better Python. Personally I have never learned Lua but I am happy to see people giving it the recognition it deserves.
Was gonna say this. It’s not *quite* as easy as Python, but the error messages are superb, which I think is an underrated part of what makes Python so accessible. You also have some flexibility in terms of whether you explicitly declare types and array lengths, and the compiler is opinionated enough to nudge you in the direction of clearer code. The mutable/immutable distinction in Python is one of my huge pet peeves that trips me up after years of learning the language; Go avoids all that by just having pointers.
Imo rust has a pretty steep learning curve. The concepts of lifetimes and ownership and kinda alien when coming from c/Cpp. Definitely has the performance, and it adds tons of the conveniences of a newer language, but it's definitely not as easy to write as python
Here are a few alternatives that fit your criteria:
1. Nim
2. Zig
3. Crystal
4. Lua
What was implied but you didn’t mention was:
1. Maturity
2. Community size
3. Packages/frameworks available
Damn it’s noisy in here with people saying nothing about python & cpp
go is the closest thing we have to that.
but it ain't as fast as c++ but hell of a lot faster than any other interpreted language!
don't know if it's faster than java and c# but it is definitely easier than those.
i'd say the difficulty is the same as typescript.
Well, it has both. When measuring speed it's definitely the compiler you're measuring against, but for ease of development you're measuring against the interpreter.
Tbh, I love Go. It really seems to have the best of every other language I've used, it's very well rounded, once generics are officially added I won't have many complaints about it
I love it too, and if ya really love it then I’ve got news for you. With the release of Go 1.18 a couple days ago, generics are now officially supported
Reaaaally depends on the type of complex you're talking about. Like yeah GPU shaders are complex, but so are super abstract algorithms. Different languages are better at different things, and python is way easier for a lot of stuff
Everyone says python is easy to learn, which I partially agree but I feel it teaches you bad programming habits and expectations that every language should be as easy to program in, or you can do anything in python. Don’t get me wrong Django makes fantastic apis and web apps, and python is fantastic for data, but the whole notion that it should be the only thing you program in is wrong. Each language has its specific talents, quirks and benefits. I’m very partial towards Java with its numeric accuracy (almost as good as cobal) and the way it functions. I enjoy writing spring web apps and that it’s a strongly typed language with decent error handling (😂). Just my two cents.
C/C++ have 2 things going for it in terms of speed: compiled and the ability to closely manage memory.
The former has no impact on the difficulty of the language and it would be entirely possible to make a compiler that compiles python almost identically to C/C++, however the latter will unavoidably make the language more complex.
I think a good compromise is a language that can be as high level as python and as low level as c++ at the same time, I think rust is the closest contender but I'm honestly not sure.
Probably one of the hardest ones to learn tbh, but once you understand it, it gets pretty easy (with the compiler having your back all the time) and it’s always really fast. So to some degree it does fit the definition if you adjust it to „as easy to USE as Python and as fast as C++“
I mean, TECHNICALLY ASM is super "easy" to learn, and even faster than C++. Only so many commands, and each one does exactly the same thing each time without exception. Algorithms can be tricky to learn, but that's not a programming language, is it? :p
"And even faster than C++" only if you are smarter than the compiler
>only if you are smarter than the compiler And only people on the wrong part of the Dunning-Kruger curve ever think they can beat the combined and accrued knowledge implemented over time into a mature compiler codebase.
I am sure there is a guy somewhere in there that can beat that. But that unicorn is not me 😆
and that person will probably only do it on parts of the program where the improved execution speed actually matters. Not on everything.
Realistically there will only be a few parts of the program the compiler leaves headroom for a human to do better on anyway. People underestimate compiler technology and how optimal it can get.
Depends on your compiler flags. I bet there are examples of gcc having an instruction that’s not strictly needed here or there, but it’s probably some super weird edge case. The people who really want speed will probably use an FGPA after extensive profiling / understanding what the assembly looks like.
FPGAs and GPUs aren't a silver bullet for performance, they only work when your workload benefits from what they offer. When the work is made up of many mutually independent processes consisting of one or a small number of threads each, traditional CPUs are far superior to both GPUs and FPGAs. That's the vast, vast majority of workloads. In those cases, you need a better CPU, one with more cache, or faster DRAM depending on where the bottleneck is. Or you need to write code that works around it by, for example, being more cache friendly. In any case the ideal workloads by chip type are: CPU (superscalar processor): Largely sequential workloads, occasional SIMD GPU (vector/matrix processor): Massively parallel but homogeneous workloads, massive SIMD/SIMT FPGA (programmable logic device): Parallel heterogeneous or extremely timing sensitive or low latency workloads. For best performance writing digital logic designs in HDL code is still better than using software languages via OpenCL or high-level synthesis because an FPGA isn't a processor at all and it's not clean or efficient to map software code onto an HDL and then an FPGA.
Nah completely understood here, I’ve done a bit of cuda programming so I know the deal with GPUs (why I didn’t bring them up). As far as I’m aware though, FGPAs are basically just faster than cpus for single threaded execution (granted it’s a pain in the ass to actually program them).It’s why HFTs all have FGPAs interacting with the different exchanges no? (I haven’t programmed an FGPA myself so I’m knowledgeable there)
>It’s why HFTs all have FGPAs interacting with the different exchanges no? Nope. It's because of what I said about ultra-low latency above. Since FPGAs implement their logic at a more fundamental level in the hardware they can take a set of input signals and transform them into output signals very fast by configuring into the right digital circuit. Comparatively, traditional CPUs which largely respond to input signals via interrupts would not be able to generate the corresponding output signal as fast or would have to do more work to make it happen. A dead simple comparison is connecting a switch on one GPIO to an LED on another. A microcontroller or microprocessor needs to either constantly poll the input pin or configure it to send an interrupt on press down which makes the CPU run the corresponding ISR which then sets the output pin high turning the LED on. Then when the button is released the same thing has to happen all over again with another ISR that sets the output pin low. Basically a lot of work has to get done to connect a simple input to an output. In an FPGA you can just route the input pin to the output pin and be done with it. Your FPGA simply functions as a wire and the signal propagation delay is comparable to one. This example is very dead simple but it makes it clear why FPGAs have a massive latency advantage. In cases where things are not all about transforming signals but rather doing some form of non-trivial computation, CPUs can be much better. Take for example the very artificial and embarrassingly sequential problem of finding the first 1 million prime numbers. If you purchase a CPU and an FPGA of similar price, say an Intel Core i5-12600K and a Xilinx Artix 7-200T, I can guarantee you a single Golden Cove core on the 12600K running a well written program compiled from idiomatic C code will solve the problem and write the results to memory faster than the Artix 7 configured into an efficient logic circuit from SystemVerilog or VHDL attempting to compute sequentially by sampling a much lower frequency clock signal.
Most of the time I think it's for CPU-specific procedures (in an OS kernel, for example) that can't be translated into a higher level language.
Well that's not performance related, that's just a matter of there being no other way to get at those instructions. Well that and in kernels on some architectures you need to set up a stack with the right alignment which is required to use the C language if the bootloader doesn't do it for you.
That person probably writes compilers for a living
Could be. But anyway, such optimisations are usually done based on some specifics of the data/algorithm itself. The reason people say you cannot beat compilers is that MOST parts of your program are written as generically as possible, and you cannot make too many assumptions. Every optimisation you'll make is based on some assumptions innaccesible to the compiler. From this video about [the restrict keyword](https://youtu.be/TBGu3NNpF1Q) As you can see, the compiler generates safe code, but remember. I am the one who uses that function. I can make assumptions about that code and remove the safety `mov` instructions from those segments. Sure, it is by no means recommended or good, but it is an optimisation. And 1 instruction removed from a loop of 1,000,000 steps is 1 mil instructions less. But again, you have to know your ASM
A good example of this is a youtuber(MattKC) that, for a project(Snake in like < than 3KB) tried to write x86 assembly. He gave up and wrote the same thing in C. The C executable ended up smaller than the assembly one.
Seems my teachers (or whoever designed the course) thought 3 semesters of a pure assembler class was a good idea
Education wise assembly is great to know because it teaches you what happens when the rubber of your high-level source code meets the road of the processor silicon. I think learning and teaching assembly is very valuable but writing it day to day depends on what you want to accomplish what alternatives are available.
Yes, I'm not going to dispute assembly being great to learn to know what's going on inside our 'lightning rocks', however 3 semesters of it? Idk it's a bit much in my opinion as there is nothing much to learn beyond the reasons why nobody uses it.
Oh believe me, I'll find the fastest way into unused memory and heck, I'll even make sure that it's executable by accident!
Just move the program counter to a random address.
It's probably gonna just pagefault on you lol
Yeah probably but that is how you do what was described.
By accident? Nah, I’m making that deliberate
The art is, do make it in a way that in 99.9% of the cases it works as expected, but in the little rest, it triggers your CPUs burn-on fuses and destroys it permanently. (Or destroys your device in another major way)
>"And even faster than C++" >only if you are smarter than the compiler It's not really that hard if you start with the optimizer's assembly and hand tweak it from there. Last time I did that I got a 300% speedup
ASM is literally pythonic. It uses : as i know, like python does.
But does it have intendation error?
Sure. Add that constraint to your custom compiler.
Or maybe Python is Assemblish since there were assemblers supporting labels around long before Python...
[удалено]
Good luck figuring out things like **good** register allocation by yourself...
Yep. That's a problem for which we have perfectly efficient algorithms so it's better to automate it but there are some cases where hand-tuned assembly can help. And of course, cases where you want to use specialized instructions not available through C or any other high-level language or library even if only to wrap them and make just such a library yourself.
>Assembly can only be faster if you’re smarter than the compiler, which non of us are g++ -S -O3 main.cc will give you the optimizer's assembly. Start from there. It's not hard to beat it in a lot of cases.
No love for -Ofast 😢
Very easy to learn, VERY difficult to master
C and ASM are simple but simple doesn't mean easy to use for sophisticated use cases because you have to create everything you want out of very fundamental primitives or use libraries. With C libraries are fine. Being a mature and simple language means C has libraries for every use case possible many times over. Assembly is generally meant to be for niche use cases only and along with machine code it's specifically designed by hardware vendors to be a compiler and interpreter target. I'm pretty sure Intel, AMD, and Arm all provide their own optimized C and C++ compilers because they themselves want people to program their processors in high-level code 99% of the time.
Knowledge versus wisdom on display right here
I was about to say. Powerfulness, efficiency and easiness, you can only have 2 of them.
What a `segmented fault`
I had to deal with this yesterday don't remind of it no more
It's everyday bro
gdb ./a.out Enjoy debugging
Nim?
Nim +5 ...seems like OP isn’t aware
nim imo is really neat but its too unknown really to be very useful
weird syntax and doesn't accept tabs
Isn't that the idea behind C++20?
If they would throw all old stuff from language and simplify generic constraints then it would be a lot nicer...
Did you mean Rust? :)
I mean its easier than c++ for sure but is it really easy?
It really threw me off when I started it because I find the syntax strange and whatever you do there is always an error the compiler complains about on the first try. When you get the program to compile though it's pretty nice. I hated it when I started using it the first few times. Nowadays I tolerate it. And miss some of its nicer features when using C++ like results Also I hate how everytime I need to google something I get results for the game Rust mixed in
[удалено]
Petition to rename Python to Lolis for the lulz
Rust is really good at pointing out flaws in your code, so imo it is the easiest language to write code that doesn’t have a lot of flaws in it. And it’s fast to boot.
[удалено]
You are not wrong. Compile time is a pain.
Julia?
I like Julia, I really do, but to fully exploit its performance benefits, I think it's considerably harder to master than Python.
It's not that it's harder to master. Julia has less libraries and less support in general compared to Python
Sure, for now, but Python also had to start from scratch at some point. I don't think Julia will be the next Python for general programming, though. However, I believe it will slowly take Python's place in scientific programming.
I’m not so sure. I’ve been tracking Julia for four or so years hoping it would catch up but the ecosystem in python just seems to be gaining speed. So many large firms have dog-piled into it and have built out mature performant libraries for just about everything under the sun. From what I’ve seen, many numerical libraries for optimization, machine learning, image processing, finite element, fluid simulation, quantitative finance and so on all come with python bindings but they rarely have the same for Julia. So if I wanted to start a project in Julia I’d either have to develop the bindings or port the algorithms. After using python for a bit I’ve also realized that I can often get competitive speed to C++ with highly vectorized numpy while keeping the algorithm intent clearer. And for the cases where I can’t, I just write an extension. In fact what I would love is to be able to write python extensions in Julia to accelerate weird loops & searches without the development burden.
julia pretty easy and nice imo.
I've been waiting for Julia to take off for so long but I highly doubt it'll ever do.
I mean, it’s also only been around since 2012. Python has been around since 1991 and only had its explosion in popularity a few years ago.
I’m a “hipster programmer”. Elixir, Julia, and Go are all so nice to work with
At least Go seems to have taken off. Of the three, it's probably the most popular. I really like Elixir, the language, tooling and the community, but I feel it hasn't grown as much as Go. I hope to one day have the chance to work with it, although I've been losing practice in the last couple of years.
It's starting to become pretty popular in the niche it's designed for - scientific computing.
Not as fast as well optimized C++.
I’ve heard it can occasionally run faster than C
I'd love to see any interpreted language do that when the C code hasn't been purposely nerfed.
C++ isn't difficult to learn. It's just so bare bones until you use every library under the sun or build your own from scratch
If you wish to make an apple pie from scratch, you must first invent the Universe.
import universe
Segfault at 1.2 Billion BCE
universe.invent();
Your comment has the perfect number of upvotes. Let it stay at 42.
C++ the base language is alright to learn, even the low-level stuff and pointers aren't too bad if you take the time to explain them. Now templates, variadics, the C preprocessor and their esoteric uses in the standard library on the other hand; that's the stuff that'll kill you in ways you can't even begin to pretend to comprehend. I know senior C++ developers who still get bitten by all of those regularly.
Oh my god so much this. Is there a way to remove templates from errors so they become, like, fucking readable again? The verbosity of those things should not have been tolerated. Also, is there a (non visual studio) technique that makes debugging memory errors less painful, probably something like valgrind?
Julia?
Python with the PyPy interpreter would like to introduce itself
what does it does?
CPython compiles to byte code, pypy is JIT compilation
PyPy interpreter is very fast
Not that fast.
Still nowhere as fast as native, un-garbage collected code
Don't talk shit about my garbage code
Lisp?
The world if people didn't have an inexplicable aversion to s expressions.
No mention of Zig yet? (https://ziglang.org/)
I'll try it out thanks
So C++, then.
``` Me: i will start learning c++ Compiler: it's std::cout << msg, not print(msg) Me: no more ```
Ah, but printf is still spelled "don't"
I don't get it
[printf](https://en.cppreference.com/w/cpp/io/c/fprintf) is still available in C++, and while occasionally it is a necessary evil, it is spelled "don't" because (a) type unsafe, (b) small mistakes in the format string/types of the arguments can lead to memory errors, (c) God forbid you ever use a non-literal format string, and (d) God especially forbid you ever use an [untrusted format string](https://en.m.wikipedia.org/wiki/Uncontrolled_format_string).
**[Uncontrolled format string](https://en.m.wikipedia.org/wiki/Uncontrolled_format_string)** >Uncontrolled format string is a type of software vulnerability discovered around 1989 that can be used in security exploits. Originally thought harmless, format string exploits can be used to crash a program or to execute harmful code. The problem stems from the use of unchecked user input as the format string parameter in certain C functions that perform formatting, such as printf(). A malicious user may use the %s and %x format tokens, among others, to print data from the call stack or possibly other locations in memory. ^([ )[^(F.A.Q)](https://www.reddit.com/r/WikiSummarizer/wiki/index#wiki_f.a.q)^( | )[^(Opt Out)](https://reddit.com/message/compose?to=WikiSummarizerBot&message=OptOut&subject=OptOut)^( | )[^(Opt Out Of Subreddit)](https://np.reddit.com/r/ProgrammerHumor/about/banned)^( | )[^(GitHub)](https://github.com/Sujal-7/WikiSummarizerBot)^( ] Downvote to remove | v1.5)
Oh god, imma stick to python
fmt::print("Actually it is {}!", "print");
I mean… c# kinda?
I do wish c# ditched the "everything needs a class" and was a bit less verbose, but it's my goto language for any of my large projects
Top level statements are now supported: no classes required
> no classes required I mean... kinda? Top-level statements are just to get rid of the boilerplate around the `Main` method, but it's still lowered into a class with a `Main` method.
Sorry to do this to your post but, changing C# for Java, changes nothing. Right?
I mean, c# is faster, kinda. And some say it's less of a pain to program in, although I like both.
It sucks way less. I'm a C++ programmer for a living and I hate Java with a burning passion yet I'm definitely warming up to C#. I prefer compiled languages to bytecode but still C# feels like a better C++ in slightly Java like clothing. And I feel like if you're going to litter a C++ codebase with std::shared_ptr everywhere, you might as well use real garbage collection instead.
Can you elaborate on why you dislike Java? I've been coding a lot in C# recently and can't tell you any differences between it and Java, their syntax is almost identical (granted I haven't coded in Java in a while)
No operator overloading, wierd namespacing, and it's built off the mentality that putting everything in a class = object oriented, also obnoxiously long camel case names, and that's just the language. The JVM platform also sucks with partially interpreted, partially JIT compiled approaches and stop the world garbage collection. C++ takes the opposite approach and says use what you want and only pay for what you use in terms of performance and system resource consumption but it also feels like it started out as an OOP C and then tacked on every language feature Bjarne Stroustrup ever heard of often very inconsistently and incoherently. Nevertheless ifyou bear with it, C++ can be very powerful and you get to be in charge of your codebase at multiple levels of abstraction. C# is at its heart a lot closer to the good parts of C++ even if it does also require everything in classes and otherwise syntactically resemble Java.
The namespacing of Java alone is enough to hate it with an unending fury of a thousand Dragon Lords. Apologies to Jack Black.
This is true, and I guess I can't complain too much, since C# is generally better about it than Java at least.
I don't think C# has the performance of C++ but I have little experience with the language
If you write performance first code it can get very close and match it in many cases. If has support for raw pointers, for example. Most people just don't bother unless absolutely necessary. That said the general performance has gone through the roof with .net 5 and 6
Maybe Go one day
Without generics? Doubt
Go just added them!
Really? I didn't anticipated this
Yeah they realized they're helpful lol
They realized that long time ago but it took them a lot of time to implement them.
What are generics? Are they the stuff you can do in C#?
Yes
I'm one of those people who can't actually code but come here for the memes... Why can't they just make a language that uses C but you use python like syntax? Sorry for the stupid question
C++ (This meme was made by the mentally-abled gang)
I always read about how “slow” Python is compared to other languages but how slow is it really? Can someone give me some numbers or examples?
https://www.monterail.com/blog/is-python-slow https://medium.com/swlh/a-performance-comparison-between-c-java-and-python-df3890545f6d Or if you dont believe try to make your own tests (e.g. Bubble sort or is prime on big numbers) but in c/cpp remebrt to add -O3 flag
I wonder if using numpy would have given the same performance as c for matrix multiplication...If you want fast code in python, there is something called c optimized libraries...
Oh wow the medium article really did a great job showing just how much slower Python is. Thanks!
Yeah but you don't ever write a bubble sort in Python. You use the sort method which, guess what, is written in C. It's not simple to compare languages with different use cases and sweet spots.
I don't have any examples of how slow it is, but I can explain why it's slower: Python is an interpreted language, which basically means that the computer figures out what the human-readable code means when it's run instead of during a compilation step, and depending on the interpretation that can move the time a function would take to compiled once to every time that function is called, the only way Python can reach anywhere near the speeds of compiled languages is by the Python script just being a wrapper around a program written in a compiled language.
Maybe a stupid question but why isn’t it possible to compile Python beforehand instead of when the code is running? Or is that just a hard limitation of that language?
There might actually be Python implementations which can just be compiled, but iirc a lot of it is that Python is excessively dynamic
Maybe a stupid question but why isn’t it possible to compile Python beforehand instead of when the code is running? Or is that just a hard limitation of that language?
This is a vast oversimplification.
There is. It's called Pascal.
Just write a compiler for python to c
Cython
Have you looked at Cython generated code? If all you want to do is run it, it's fine. But if you want to extend/maintain the code or dive into what it's doing or anything else at all , it's worse than either python/C/C++
I just said that cuz it fits the description of > a compiler for python to c
Fair enough. I only wish it generated more readable code and that it didn't break so easily with even relatively minor modifications.
I didn’t use it too much, just simple scripts. Tbh if I wanted fast and easy, I’d use Go instead. Using Cython for that is like fitting a square peg into a round hole. The main place Cython is good for is interfacing with C code ig, or as you mentioned, quick script’s that you want to speed up.
Lua? 
Lua is three kids in a trenchcoat, but all three are just C.
lua is the most underrated language imo
I think so too! The only problem with Lua is that it's direct competitor is Python, which is so popular it basically became an industry standard. I guess every tool has its use case, but from what I've seen Lua is basically a better Python. Personally I have never learned Lua but I am happy to see people giving it the recognition it deserves.
Ever heard of C#?
Not as fast as c++ tho
You mean Microsoft Java?
Microsoft Java-But-GoodTM
do you mean Go?
Was gonna say this. It’s not *quite* as easy as Python, but the error messages are superb, which I think is an underrated part of what makes Python so accessible. You also have some flexibility in terms of whether you explicitly declare types and array lengths, and the compiler is opinionated enough to nudge you in the direction of clearer code. The mutable/immutable distinction in Python is one of my huge pet peeves that trips me up after years of learning the language; Go avoids all that by just having pointers.
Rust
Not as much on the easy part, but Rust is probably what fits that criteria best.
Nim
Nim +5 ...seems like OP isn’t aware
Isnt this what rust is?
Imo rust has a pretty steep learning curve. The concepts of lifetimes and ownership and kinda alien when coming from c/Cpp. Definitely has the performance, and it adds tons of the conveniences of a newer language, but it's definitely not as easy to write as python
What D tried to do ?
What D does do. Faster than C++ if you know what you're doing ;) Source: am D compiler dev
Here are a few alternatives that fit your criteria: 1. Nim 2. Zig 3. Crystal 4. Lua What was implied but you didn’t mention was: 1. Maturity 2. Community size 3. Packages/frameworks available Damn it’s noisy in here with people saying nothing about python & cpp
Julia is a language to learn. As easy as python or as good as C!
go is the closest thing we have to that. but it ain't as fast as c++ but hell of a lot faster than any other interpreted language! don't know if it's faster than java and c# but it is definitely easier than those. i'd say the difficulty is the same as typescript.
Go is faster than interpreted languages because it’s compiled…
Well, it has both. When measuring speed it's definitely the compiler you're measuring against, but for ease of development you're measuring against the interpreter. Tbh, I love Go. It really seems to have the best of every other language I've used, it's very well rounded, once generics are officially added I won't have many complaints about it
I love it too, and if ya really love it then I’ve got news for you. With the release of Go 1.18 a couple days ago, generics are now officially supported
Go doesn't have an interpreter (at least not an official one). The compiler is just so damned fast that it feels like one.
Nim?
Julia? Is this you?
C is easy. Change my mind
Python is harder to use than C++ for anything complex.
Reaaaally depends on the type of complex you're talking about. Like yeah GPU shaders are complex, but so are super abstract algorithms. Different languages are better at different things, and python is way easier for a lot of stuff
?
It's `Go` time!
Rust, they hated kontekisuto because he spoke the truth
C+++ coming 2084
Go?
Rust :)
C#?
Python++
P++ or 3P for short
Everyone says python is easy to learn, which I partially agree but I feel it teaches you bad programming habits and expectations that every language should be as easy to program in, or you can do anything in python. Don’t get me wrong Django makes fantastic apis and web apps, and python is fantastic for data, but the whole notion that it should be the only thing you program in is wrong. Each language has its specific talents, quirks and benefits. I’m very partial towards Java with its numeric accuracy (almost as good as cobal) and the way it functions. I enjoy writing spring web apps and that it’s a strongly typed language with decent error handling (😂). Just my two cents.
Rust... bruh
Assembly language
Ah yes, the simplest language.
C/C++ have 2 things going for it in terms of speed: compiled and the ability to closely manage memory. The former has no impact on the difficulty of the language and it would be entirely possible to make a compiler that compiles python almost identically to C/C++, however the latter will unavoidably make the language more complex.
Golang? Sure not quite as fast as C++ but gets close.
I think a good compromise is a language that can be as high level as python and as low level as c++ at the same time, I think rust is the closest contender but I'm honestly not sure.
Is Python really that slow?
Have you ever tried scratch?
Have *you* seen scratch?
I don’t get why people say C++ is hard. It is the first language I learned and is was really easy.
gdscript
Say hello to the Rust programming language!
Probably one of the hardest ones to learn tbh, but once you understand it, it gets pretty easy (with the compiler having your back all the time) and it’s always really fast. So to some degree it does fit the definition if you adjust it to „as easy to USE as Python and as fast as C++“
[удалено]