We used JMeter to run our load tests. The tests call the services many times and collect data about response time, throu

Java seems to be much more able to use multiple cores and execution threads provided by the hardware (compared to Go) — this makes some sense because Go is intended as a system and network programming language, and it is a younger language, so it is reasonable to assume that Java has had a lot more time to develop and tune optimizations,In this round we used a Kubernetes 1.16.8 cluster with three worker nodes, each one having two cores (with two threads of execution each), 14GB of RAM and Oracle Linux 7.8. We ran one pod for each variant in some tests, and one hundred in others.,The best performance in this round was from GraalVM native image, with a 0.25 ms average response time and 82,426 transactions per second, compared to Go’s best result of 1.59 ms and 39,227 tps, however this was at the cost of two orders of magnitude more memory usage!,Fans were absolutely thrilled when Tom began responding to some of their videos on his Tiktok page. Not only did he began responding but Tom began duetting videos which made many longtime fans rejoice, and even challenging them to give them their best Draco impressions.,We are comparing different execution models in this test — the Go application was compiled into a natively executable binary whereas the Java application was compiled into byte code that was then run on a virtual machine. We decided to introduce GraalVM native image so bring the Java application’s execution environment much closer to the Go application’s environment.,In the first round, we ran the test on a “small” machine, in this case a 2.5GHz dual-core Intel Core i7 laptop with 16GB of RAM running macOS. We ran 100 threads with 10,000 loops per thread and a 10 second ramp up time. Java applications ran on JDK 11 and Helidon 2.0.1. Go applications compiled with Go 1.13.3.,In this case we did not see any substantial improvement in throughput or response time by using GraalVM native image over running the application on a JVM, however the memory footprint was smaller.,Notice that in all three Java variants the first requests had much higher response times (look for that blue line right up against the left axis). In all cases we also saw some peaks, which we assume to be caused by garbage collections or optimizations.,Logging seems to be a major performance hit, especially java.util.logging. Because of this, we ran tests with and without logging. We also noticed that logging was a significant factor in the performance of the Go applications.,Modern versions of Java, and new frameworks like Helidon, are making large strides in removing/reducing the pain of some of Java’s well-known and long established issues (e.g. verbosity, GC performance, start up time, etc.),This executable includes the application classes, classes from its dependencies, runtime library classes, and statically linked native code from JDK. It does not run on the Java VM, but includes necessary components like memory management, thread scheduling, and so on from a different runtime system, called “Substrate VM”. Substrate VM is the name for the runtime components (like the deoptimizer, garbage collector, thread scheduling etc.).,Speaking of a website, I strongly recommend building a data science portfolio in the form of a website as well. HTML and CSS are very simple to learn and it would be a fun project! If you don’t have the time, something like Squarespace would work well too.,Application access was through a Traefik ingress controller with JMeter running outside the Kubernetes cluster for some tests, and for others we used ClusterIP and ran JMeter in the cluster.,In many of the tests we ran JMeter on the same machine as the application under test. There did not seem to be any interference or difference in results if we ran JMeter on a different machine, so this simplified the setup. When we later deployed the applications into Kubernetes, JMeter was running on a remote machine, outside the cluster.,In this round we observed that Go was sometimes faster and GraalVM native images were sometimes faster, but the difference between these two was small (generally less than 5%).