Chapter 1: My Programming Journey

Throughout my coding career, I’ve dabbled in various languages, yet Java remains one I consciously choose to sidestep.

Photo by Carli Jeen on Unsplash

My programming background includes languages such as C, C++, PHP, JavaScript, TypeScript, VB, Python, and Bash, with additional experience in C#, D, Go, and Rust. Although I've encountered Haskell, Java is the one language I actively avoid including on my resume, irrespective of my familiarity with it. If queried about my skillset, I seldom mention Java unless specifically asked.

Most programming languages possess unique and enjoyable features—be it the rapid application development with Python or the intriguing paradigms found in C++, Go, and Rust. In contrast, Java stands out for its verbosity, restrictive structure, and dependency on the Java Virtual Machine (JVM) for execution.

Whenever I find myself needing to code in Java, it’s typically because I require a specific library exclusive to that language, leaving me with no viable alternatives. Unfortunately, my experiences with Java have been less than satisfactory.

For personal projects, I rarely see a purpose for Java beyond the essential requirements tied to specific libraries. More often than not, I create external programs to minimize the Java code I need to maintain.

Java enforces a strict object-oriented programming (OOP) paradigm, making classes the mandatory structure for nearly everything. This rigidity can lead to excessive coding, particularly in scenarios where OOP is unwarranted or where simpler solutions would suffice.

Java’s compiler can be cumbersome, demanding numerous explicit declarations that should be intuitive, yet it often fails to catch certain misuse cases that result in errors. The language’s commitment to OOP results in libraries that generate complex object hierarchies, leading to code that can be challenging to read and test effectively.

Additionally, the JVM is managed by a specific corporation that does not fully release its code, resulting in various incompatible versions. While I prefer using official Debian packages on servers, sometimes I must resort to official non-free installations due to dependency issues. This situation complicates the installation process as different programs may require incompatible versions.

Java's approach to memory management can be overly optimistic, leading to high memory consumption without adequate resource release. Consequently, applications often necessitate larger computing resources to function efficiently.

The integration of Java with operating system calls is often considered inadequate or overly complicated. For instance, adjusting a program’s working directory is deemed “unnecessary in Java,” yet processes do operate with designated working directories that can influence functionality.

Java's abstractions are costly in terms of performance, particularly when compared to C++ and Rust. This, combined with the language's focus on classes and abstractions, results in libraries that depend on multiple layers of other libraries. As a result, making a simple call within a complex library can trigger a cascade of calls that the compiler does not optimize fully, leading to slower program execution.

The size of Java installations and their memory usage are significant drawbacks, especially in containerized environments like Docker. Coming from a C++ background, I find memory management straightforward, and each encounter with Java reminds me of the limitations imposed by its compiler and the subsequent slowdowns.

In moments of reflection, I often question why I’m using Java when C++ would provide a more straightforward, faster, and easier installation process. Alternatively, with Python, I could typically accomplish the same task five times faster, benefitting from its readability and ease of installation, which is often included by default in many distributions.

While I generally avoid Windows development, I find C# offers a more refined alternative to Java, consuming less memory and exhibiting greater elegance. Even when using Mono on Linux, C# performs quite well.

Languages like Go and Rust are emerging as promising alternatives, distancing themselves from Java's paradigms. They lack strict OOP requirements, although some emulation is possible, and both are compiled. Rust, in particular, offers a nearly manual approach to memory management.