Some
programmers prefer to use Rust, others go for Java but at the end of
the day, both programming languages have highs and lows.
Rust
is a programming language which gets almost everything right, but some
programmers consider that its immaturity can seriously slow down their
job, according to Jimmy Cuadra. Still, this programming language may
increase users’ confidence that their programs perform what they want
them to perform without limiting expressiveness. However, Java cannot be
excluded from the list of favorites not only because of its age, but
also because of its effectiveness and community size.
Highs and lows of Rust
Programmers
who prefer dynamic languages may be afraid of static typing because of
their restrictive nature, but programs in dynamic languages have subtle
bugs, Cuadra explains. Rust taught him that a rich type system is a good
thing and even though testing remains a requirement, programmers’ only
task is to cover real logic. Rust’s type system is not restrictive -on
the contrary: by typing out a few extra words, one can be sure that this
programming language offers greatly improved clarity when reading and
reviewing code.
Still, Rust has its
disadvantages too. One of the most obvious drawbacks with the ecosystem
is the lack of libraries and the immaturity of existing ones. Not many
libraries are trustworthy in Rust and the lack of a stable serialization
library may be the reason why some programmers prefer to stay away from
Rust.
Rust vs Java
The
1.0 release of Java is dated January 1996 while Rust 1.0 was released
in May 2015. Although age may not be an essential differentiator, some
claim that the former has pedigree. Regardless of history, one obvious
difference between Java and Rust is that the former runs on the JVM,
which means it is just-in-time compiled. In short, Java can benefit from
profile-based optimizations which (in theory) allow better performance
than compile-time optimized code for certain workloads.
Another
aspect which matters is that a typical Rust program consumes orders of
magnitude less memory than an ordinary Java program. Although Java’s GC
is very optimized and makes programming rather painless, Rust has a
zero-sized runtime, for some large values of zero. There is a runtime,
but it consists of establishing landing pads for panics which can even
be overridden.
Rust is not as portable
as Java, but backends for a number of targets can be obtained with
reasonable effort as it is LLVM-based. Rust may be suitable for targets
that are considered to be too small for the JVM because of the absence
of a fat runtime and garbage collector.
What
Java lacks and Rust offers is the following: Rust’s ownership- and
lifetime-rules, which are upheld by the borrow checker allow it to get
by without a GC. This also has its perks and disadvantages, because even
though the compiler guarantees freedom from data-races, users will
eventually bash their head against the borrow checker.
Further differences
Java
may have class, but Rust has traits, which are unusually similar to
Java 8’s interfaces. The latter also has types and implementations of
traits for types, as well as inherent implementations. The visibility is
generally determined by the module. What Rust offers and Java lacks is
the possibility to create new traits which add behavior to existing
types. Plus, Rust has free-standing functions that live in their module
-in other words, there is less ceremony when writing procedural code.
Meanwhile,
Java appears to be more pattern-happy than Rust, probably because the
latter does not have so many patterns, given its youth. There are
meaningful differences in flow control, error handling, functions and
closures and metaprogramming, but also in the standard library, where it
appears that Rust cannot defeat Java.
Finally,
one massive difference is that Java has a huge community while Rust’s
is more modest. Because the development of Java is primarily directed by
Oracle, it is hard not to perceive Rust as the underdog. Regardless of
their size and potential, it is clear that both communities can learn
from each other.
Blogger Comment