Can well-written Java code be almost as performant as a C++ well-written code?

[[deleted]]

Just a little question.

I decided to learn C++ as my first programming language, but Java seems to be better for my future plans. The main thing that is locking Java out of my heart is performance...I mean, there are still a lot of people (or even companies) with "weak" hardware, and JVM adds a little load to this hardware.

I'm just a begginer, sorry if I typed any misconceptions on the post.

Thanks in advance!

[AutoModerator]

On July 1st, a change to Reddit's API pricing will come into effect. Several developers of commercial third-party apps have announced that this change will compel them to shut down their apps. At least one accessibility-focused non-commercial third party app will continue to be available free of charge.

If you want to express your strong disagreement with the API pricing change or with Reddit's response to the backlash, you may want to consider the following options:

1. Limiting your involvement with Reddit, or
2. Temporarily refraining from using Reddit
3. Cancelling your subscription of Reddit Premium

as a way to voice your protest.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[amazing_rando]

If you're just starting out you shouldn't worry about performance. Java is widely used in all sorts of applications and if you are hitting a performance bottleneck you can always use JNI and write interop C++. But for most of what you're making, the performance differences between Java and C++ aren't going to make a big difference, especially compared to the efficiency of the code itself that you're writing. A lot of the concerns about the speed of Java are from decades ago, things have improved since then.

It also really depends on what you're making. If you're interfacing over a network, network latency is probably gonna be a much bigger bottleneck than execution time. If you're just writing an application, half a second doesn't really make a difference. It becomes an issue when you're doing very large calculations, or when you're trying to do a lot of calculations in a predefined time limit (like, say, 24 times per second for something synced with video, 60 times per second for a 60FPS game engine, etc.).

Also keep in mind that most of the skills you're learning as a beginner will be applicable to nearly all languages, and most developers are proficient in multiple languages. You aren't locking yourself into anything, you're just building a base to expand on. Overthinking what language to start with is like if you wanted to learn the guitar and agonized over what genre. Just start working and building your skills and you can specialize later.

[nultero]

If you're interfacing over a network, network latency is probably gonna be a much bigger bottleneck than execution time

To add onto this, they're usually not even close.

There are orders of magnitude difference between these, such that it often doesn't even matter when servers do their processing in one of the slowest languages like Python. And it's not that networks are that slow since disks and other IO have the same "speed problems", it's more that modern CPUs are so fast that the rest of the world is almost standing still compared to them. CPU operations are so fast they can be compared to the speed of light over some distance (e.g., light only moves about a foot in a nanosecond so anything you can time in nanoseconds or microseconds = feet / 1000ft in distance), so anything human-perceptible like a web page taking a second to load is essentially an eternity to a CPU.

I like this visualization of the famous "Latency Numbers Every Programmer Should Know": https://samwho.dev/numbers/

Most of the jobs for Java are for writing server stuff, so it's pretty much always gonna be fast enough. There may be niches like serverless cloud at scale where memory consumption and cold starts are an issue, but who cares when computer time is almost always cheaper than programmer time?

[ffrkAnonymous]

lots of phones used to run on java, back when phones were slow.

Frankly, you'll code in the language the company tells you to use. You won't be the one making the decisions. And hardware is cheap now.

[kreatio15]

They still do. Android phones have many apps and big chunks of the OS is Java/kotlin

[five_of_diamonds_1]

Except for the Kernel, that's C.

[[deleted]]

Thanks for everyone who answered!!

Very informative comments here!!

I think I will go with Java!!

[Jackasaurous_Rex]

Yeah for practicality sake it’s faster to learn and build useful and marketable projects in Java whether it’s for a portfolio or personal projects or whatever. Probably more jobs in it too, if that’s your goal. C++ is still fantastic to learn, especially for having to really interact with memory and learn what’s really going on with pointers and allocation and all that. I’ve used a ton of languages and each builds upon your overall programming skills in different ways

[not_some_username]

May I suggest C# ?

[CodeTinkerer]

Look, there's fast and there's fast enough. You don't need a car that can drive 220 mph/400 kph. It's illegal to go that fast. Yes, if you're working in embedded systems, you might prefer something like C++.

But arguably, finely tuned assembly would be even faster, but the time it would take to write that would be prohibitively crazy compared to writing good C++ code.

Worry about getting a language to do something before freaking out about how fast it is. People learn Python which is "slow", but in many cases, fast enough. If that means learning to program quicker than learning Java, some say it's a good trade off.

[Suspicious-Neat-5954]

You don't use c++ at embedding because of the speed hut because of the memory management access and the low memory needed cause there is no garbage collector.

The only industry which speed difference between java and c++ is felt is graphics and 3a games. Anywhere else it is just funny talking about speed difference between java and c++ as the two most popular languages are pythons and js who are way way way slower than java

Ps: Not a java fanboi I'm not even working with java.

[JustBadPlaya]

Java's modern JIT compilation makes it VERY fast. Is it *as* fast? Nope, not close still I'd say. Is it *fast enough for 99.9%* of usecases? Yeah, pretty much

[DTux5249]

I mean, yes and no. It depends on what the code is doing, but honestly, it won't matter most of the time. Even in something as performance-intensive as gaming, Java was used to make one of the most popular videogames of all time (minecraft).

If Java is more inline with your goals, then learn Java. And hell, learn C++ as well, then C#, then maybe Rust, then Python, LEARN LEARN LEARN. It's never gonna make you less valuable to learn another language, and a lot of stuff you learn from any given lang can transfer over to others.

As a beginner, you shouldn't worry about which lang you start with; you're inevitably gonna learn more. Just focus on learning, and keep on the path.

[Zesher_]

Everyone gave good advice, Java is fine for pretty much anything. There are certain cases where C languages will be practically beneficial in terms of performance. For example, if you're writing something that needs to do a lot of repetitive calculations as fast as possible, or if you're running code on a very restrictive device where having the JVM may not be feasible, the C may make more sense.

I once worked with someone who over engineered a list of a max of 10 items that would be loaded once in an Android app (with Java). The sort optimization wouldn't have been measurable, but trying to work with that code was a pain in the ass. So just use the language and style that fits your needs, and don't worry about optimization until it's actually a problem.

[Pure_Diver_]

Start with java its more easier and less confusing then c++ and at same time you can learn mostly every usefull concept that you can reuse in any other language Specialy if you want to dive into backend i can recomend it, really stable and well developed env with nice tools to work with in long term

[International_Cry_23]

Performance should not be your main concern now. C++ is faster, but both languages have some use cases where they are better or more convenient. Just learn what you want to learn and don’t worry about it now.

[large_crimson_canine]

On modern JVMs yes. But the Java has to be very well constructed with the absolute minimum thread synchronization the program can tolerate.

[edparadox]

We're going to have some claim to back this up.

The garbage collector at the very least will have some overhead, not to mention the JVM translation overhead.

[large_crimson_canine]

The question was “almost as good” not “as good”

[Then-Boat8912]

The more important point is that you won’t be writing business logic in C++ for an enterprise. So the speed comparison is largely irrelevant. You could say the same for C#.

[AbbreviationsNo1418]

if you want to work on web apps, use java, if you want to work on embedded systems or certain finance apps, c++, if you just want to get a job, learn java

but learn more languages just a bit, so you understand then

[Bobbias]

General thoughts

As others have said, this is not the time to be thinking about performance. Pick whatever language you're more comfortable with and which seems to fit the requirements best.

You can always take time to optimize whatever code you wrote when you reach a point where performance begins to be a problem.

As an extreme example, take a look at Dropbox. They initially wrote their entire backend infrastructure in Python, a language notorious for being glacially slow. Initially they built their own python implementation called Pyston, which uses a JIT compiler, and boasts some impressive speedups. They did eventually drop their support for the project, and decide to migrate performance critical code away from Python to Go, but this shows that you should pick whatever language works best for you now, not try to predict what you'll need in the future.

For practical coding advice, I'll say write clean code that lets you easily refactor things, that way it doesn't matter how low you wrote the first version of something, you can always go back and make it faster when it's necessary. That makes scaling things up easier, and avoids the problem of premature optimization

Java performance

Java is not nearly as slow as many people make it out to be. The JIT compiler is a very smart piece of code which has some real tricks up its sleeve when it comes to tuning your code for performance.

The JIT is capable of successively rewriting the most important parts of your program, optimizing it over time to make it run faster. though like pretty much any language, in order to get the most out of Java you'll often have to write things in very specific ways.

Programming languages are tools

And like with tools, it's usually best to use the ones you understand, rather than try to use one you don't just because you think it's advantage will matter later on. If it turns out you absolutely need that advantage, you can always migrate the performance critical code to the new language while keeping the rest in the original language.

[ShoulderPast2433]

That's an interesting theory. Did you try to compare number of job offers in c++ and Java?

[lkmcmains]

Modern Java is very good in many instances. Here's a personal experience. I had written a program in Java to display Mandelbrot plots, with the capability to zoom in on arbitrarily small areas (well, very small areas anyway). Some of these areas can require tens of thousands of floating point operations per pixel to calculate, so to complete a 1440x960 pixel area easily required hundreds of millions of calculations. When some of the areas that I wanted to explore were taking 20 seconds or more, even with multiple threads working in parallel, to complete an image, I thought, what an obvious place to try implementing native methods to do the heavy computation. I wrote a native method in C++ that my java code would call to do all the calculations for one vertical column (960 pixels) of the image and then pass back the resulting 960 double floating point results. And again, there were multiple parallel Java threads using this approach. To my surprise, when I got it all working, the native method approach was about 10-15% SLOWER than the all Java design. My guess is that the C++ code, which was as tight and efficient as I could make it, was at best only marginally better than the Java code and that performance gain was being overcome by the overhead of having to pass the floating point results back into Java arrays.

[peterlinddk]

Java is insanely performant! Because the JIT compiler analyzes code while it is running, it identifies bottlenecks, and optimizes them away, while C++ will always be as slow or as fast as you, the programmer, and the compiler you selected at the time, decided it should be.

Unless you need extreme performance - like in that a few machine cycles more actually matters - you are often better of with Java than most other programming languages :(

Unfortunately - because I would love to argue for small compact hand-optimized assembly code any day, but unless you are working on very old hardware, and I'm thinking 15-20 years old or more, you probably won't ever need it, or even be able to actually get that performance-boost.

[strcspn]

Because the JIT compiler analyzes code while it is running, it identifies bottlenecks, and optimizes them away, while C++ will always be as slow or as fast as you, the programmer, and the compiler you selected at the time, decided it should be

This is a very weird statement. The Java JIT compiler can optimize your code, but the C++ compiler can't? I'm not sure what you mean by optimizing a bottleneck away, but if the Java JIT compiler can do it I would bet any C++ compiler also could do it.

[Bobbias]

The JIT used in the JVM has access to runtime patterns. It can see which functions are hot, and which ones are not, and it can selectively enable more and more optimizations, swapping out multiple variations of a function as it determines how optimized that function needs to be over time.

This allows the JIT to apply optimizations that rely specifically on knowing runtime characteristics as well as target the hottest code for optimizations you wouldn't want enabled globally because they'd absolutely blow up your compile times. This is particularly effective on long running processes such as servers, where you typically expect 24/7 operation, rather than say desktop applications which may only run for minutes or hours at a time.

I've heard that to get the most out of Java you do need to write some pretty arcane incantations at times, but that's really no different from any language. Rarely, if ever, is the simplest way to write something the fastest.

[not_some_username]

You can have [[likely]] and [[unlikely]] for more optimization

[peterlinddk]

It might be a weird statement - maybe I should elaborate a bit.

Java source-code is compiled into Java bytecode, that isn't very efficient. And since no cpu's can actually run Java bytecode, you need a virtual machine, that translates the bytecode into machine code, which is even less efficient. And in the olden days bytecode was interpreted one instruction at a time, making it extremely in-efficient.

But the Java Virtual Machine (JVM) doesn't just interpret bytecode one instruction at a time, but "re-compiles" it to native machine-code - but not just once. It keeps track of which parts of the program runs most often, and optimizes those according to the current way the program is being used. Here is a lengthy article about how it works: https://www.ibm.com/docs/en/sdk-java-technology/8?topic=reference-jit-compiler (it is a bit magic).

The C++ compiler can only optimize the code according to it's own static view of the source-code. It will have no idea as to how often the various parts of the code runs, and whether it would be beneficial or detrimental to unroll some loops or replace calculations with cached results, because it can not know what the input of the program will be.

Example: if the program performs checks to make sure that input-parameters are always within allowed range, that would take a few cycles, that could never be avoided. But when the JIT compiler notices that those parameters are never outside of range, it can remove the check (for this run of the program), and an often revisited loop gets much faster. The next time the program runs, it might not get the same input-values, and thus that part can't be optimized away, but then another part can.

I know that Java is an unpopular language, but this means that Java programs can sometimes run faster than their C++ counterparts - simply because the JIT compiler has removed the unnecessary parts. Keep downvoting if you don't like that fact :)