Welcome to the jOOQ Tuesdays series. In this series, we’ll publish an article on the third Tuesday every other month where we interview someone we find exciting in our industry from a jOOQ perspective. This includes people who work with SQL, Java, Open Source, and a variety of other related topics.
Why Is Javaslang so Popular?
Thank you, Lukas, for giving me the opportunity to share my thoughts.
I think that many users were disappointed about Java 8 as a whole, especially those who are already familiar with more advanced languages. The Java language architects did an awesome job. Java 8 brought groundbreaking new features like Lambdas, the new Stream API, and CompletableFuture. But the new abstractions were only poorly integrated into the language from an API perspective.
There is already an increasing amount of write-ups about the disadvantages of Java 8, starting with the drawbacks of the Optional type. We read that we have to take care when using parallel Streams. These are self-made problems that keep us busy, stealing our expensive time. Javaslang provides us with alternatives.
There is no reason to reinvent the wheel. My vision is to bring as much as possible of the Scala goodness to Java. In fact, Scala emerged from Java in the form of the Pizza language. Back in 2001, it had features like generics, function pointers (aka lambdas), case classes (aka value types) and pattern matching. In 2004 Java got generics, in 2014 came lambdas, and hopefully Java 10 will include value types. Scala left Java far behind. It used the last 15 year to evolve.
Object-functional programming is nothing new. It is the best of both worlds, object-oriented programming and functional programming. Scala is one of the better choices to do it on the JVM. Java’s Lambdas are an enabling feature. They allowed us to create a Javaslang API that is similar to Scala.
Java developers who get their hands on Javaslang often react in a way that I call the nice-effect: “Wow that’s nice, it feels like Scala”.
You Published a Guest Post on the jOOQ Blog About Javaslang More Than a Year Ago. Since Then, Javaslang has Moved Forward Quite a Bit, and You've Recently Published the Roadmap for Version 3.0. What Have You Done Since Then, and Where Are You Going?
Yes, that is true, it has changed a lot since then. We released Javaslang 1.2.2 two weeks before the first jOOQ guest post went online. Aside from enriched functions, that release offered popular Scala features like Option for null-safety, Try for performing computations headache-free in the presence of exceptions, and a fluent pattern matching DSL. Also notably, we shipped two common persistent collections, an eagerly evaluated linked List and the lazy form of it, also called Stream.
Roughly one year later, we released Javaslang 2.0.0. We hardened the existing features and most notably included Future and Promise for concurrent programming and a full-fledged, Scala-like persistent collection library. Besides that, we replaced the pattern matching DSL with a more powerful pattern matching API that allows us to recursively match arbitrary object trees.
I spent a significant amount of time and energy abstracting on the type level over the mentioned features, as far as this is possible in Java. For Java developers, it is not important to call things monads, sum-types or products. For example, we do not need to know group theory in order to calculate 1 + 1. My duty as library developer is to make it as simple as possible for users of Javaslang to reach their goals. The need to learn new APIs and DSLs should be reduced to the minimum. This is the main reason for aligning Javaslang to Scala.
Our efforts for the next release concentrate on adding more syntactic sugar and missing persistent collections beyond those of Scala. It will be sufficient to add one import to reach 90% of Javaslang’s API. There will be new persistent collections BitSet, several MultiMaps, and a PriorityQueue. We are improving the performance of our collections, most notably our persistent Vector. It will be faster than Java’s Stream for some operations and have a smaller memory footprint than Java’s ArrayList for primitive elements.
Beyond library features, we pay special attention to three things: backward compatibility, controlled growth, and integration aspects. The web is important. Our Jackson module ensures that all Javaslang types can be sent over the wire as serialized JSON. The next release will include a GWT module, first tests already run Javaslang in the browser. However, the Javaslang core will stay thin. It will not depend on any other libraries than the JDK.
Toward the next major release — 3.0.0 — I’m starting to adjust the roadmap I sketched in a previous blog post. I’ve learned that it is most important to our users that they can rely on backward compatibility. Major releases should not appear often, following the 2.x line is a better strategy. We will start to deprecate a few APIs that will be removed in a future major release. Also, I keep an eye on some interesting developments that will influence the next major release. For example, a new major Scala release is in the works and there are new interesting Java features that will appear in Java 10.
Looking at the current issues, I don’t have to be an oracle to foresee that the next minor release 2.1.0 will take some more time. I understand that users want to start using the new Javaslang features, but we need the time and the flexibility to get things right. Therefore, we target a first beta release of 2.1.0 in Q4 2016.
In the Meantime, There Is a Variety of Functional(-ish) Libraries for Java 8, Like Our Own jOOλ, StreamEx, Cyclops, or the Much Older FunctionalJλvλ. How Do All These Libraries Compare, and how Is Yours Different?
This question goes a little bit in the philosophical direction, maybe it is also political. These are my subjective thoughts, please treat them as such.
Humans have the ability to abstract over things. They express themselves in various ways, e.g. with painting and music. These areas split into different fields. For example in literature things are expressed in manifold ways like rhythmic prose and poetry. Furthermore, different styles can be applied within these fields, like the iambic trimeter in poetry. The styles across different areas are often embossed by outer circumstances, bound to time, like an epoch.
In the area of mathematics, there are also several fields, like algebra and mathematical analysis. Both have a notion of functions. Which field should I take when I want to express myself in a functional style?
Personally, I’m not able to afford the time to write non-trivial applications in each of the mentioned libraries. But I took a look at the source code and followed discussions. I see that nearly all libraries are embossed by the outer circumstance that lambdas finally made it to all curly-braces languages, especially to Java, in our case. Library designers are keen to modernize their APIs in order to keep pace. But library designers are also interested in staying independent of 3rd party libraries for reasons like stability and progression.
The field of jOOQ is SQL in Java, the field of Cyclops is asynchronous systems. Both libraries are similar in the way that they adapted the new Java Lambda feature. I already mentioned that the new Java features are only poorly integrated into the language. This is the reason why we see a variety of new libraries that try to close this gap.
jOOQ needs jOOλ in order to stay independent. On the technical level, StreamEx is similar to jOOλ in the way that both sit on top of Java’s Stream. They augment it with additional functionality that can be accessed using a fluent API. The biggest difference between them is that StreamEx supports parallel computations while jOOλ concentrates on sequential computations only. Looking at the SQL-ish method names it shows that jOOλ is tailored to be used with jOOQ.
Cyclops states to be the answer to the cambrian explosion of functional(-ish) libraries. It offers a facade that is backed by one of several integration modules. From the developer perspective I see this with skepticism. The one-size-fits-all approach did not work well for me in the past because it does not cover all features of the backing libraries. An abstraction layer adds another source of errors, which is unnecessary.
Many names of Cyclops look unfamiliar to me, maybe because of the huge amount of types. Looking at the API, the library seems to be a black hole, a Cambrian implosion of reactive and functional features. John McClean did a great job abstracting over all the different libraries and providing a common API but I prefer to use a library directly.
FunctionalJλvλ is different. It existed long before the other libraries and has the noble goal of purely functional programming: If it compiles, it is correct. FunctionalJλvλ was originally driven by people well-known from the Scala community, more specifically from the Scalaz community. Scalaz is highly influenced by Haskell, a purely functional language.
Haskell and Scala are much more expressive than Java. Porting the algebraic abstractions from Scalaz to Java turned out to be awkward. Java’s type system isn’t powerful enough, and it does not allow us to reach that goal in a practical way. The committers seem to be disillusioned to me. Some state that Java is not the right language for functional programming.
Javaslang is a fresh take on porting Scala functionality to Java. At its core, it is not as highly influenced by Scalaz and Haskell as FunctionalJλvλ is. However, for purely functional abstractions, it offers an algebra module that depends on the core. The relation algebra/core can be compared to Scalaz/Scala.
Javaslang is similar to StreamEx in the way that it is not bound to a specific domain, in contrast to jOOλ and Cyclops. It is different from StreamEx in the sense that it does not build on top of Java’s Stream. I understand Javaslang as language addition that integrates well with existing Java features.
You Have Never Spoken at Conferences — You Let Other People Do That For You. What’s Your Secret?
In fact, I never attended a conference at all. My secret is to delegate the real work to others.
Joking aside, I feel more comfortable spending my time on the Javaslang source code than preparing conferences and traveling. Currently, I am working on Javaslang aside from my job, but I’m still looking for opportunities to do it full-time.
It is awesome to see other people jumping on the Javaslang train. We receive help from all over the world. Besides IntelliJ and YourKit, we recently got TouK as a new sponsor and produced Javaslang stickers that are handed out at conferences.
Because of the increasing popularity of Javaslang, there is also an increasing amount of questions and pull requests. Aside from the conception and development, I concentrate on code-reviews, discussions and managing the project.
Where Do You See Java’s Future With Projects Like Valhalla?
Java stands for stability and safety. New language features are moderately added, like salt to a soup. This is what we can expect from a future Java.
In his recent mission statement, Brian Goetz gives us a great overview about the goals of Project Valhalla. From the developer point of view, I really love to see that the Java language architects attach great importance to improve the expressiveness of Java. Value types, for example, will reduce a lot of redundant code and ceremony we are currently confronted with. It is also nice to see that value types will be immutable.
Another feature I’m really looking forward to is the extension of generics. It will allow us to remove several specializations that exist only for primitive types and void. Popular functional interfaces like Predicate, Consumer, Supplier and Runnable will be equivalent to Function. In Javaslang we currently provide additional API for performing side-effects. Having extended generics that API can be reduced to the general case, like it should have been from the beginning.
There are two more features I’m really interested in: local variable type inference, that will come to Java, and reified generics, that might come. Reified generics are needed when we want to get the type of a generic parameter at runtime. We already have type inference for lambdas. Extending it to local variables will increase conciseness and readability of method and lambda bodies while preserving type-safety. I think it is a good idea that we will still have to specify the return type of methods. It is a clear documentation of the API of an application.
I’m deeply impressed how Java and the JVM evolve over time without breaking backward compatibility. It is a safe platform we can rely on. The gap between Java and other, more modern languages is getting smaller but Java is still behind. Some popular features might never come and most probably outdated API will not get a complete refresh or a replacement. This is a field where libraries such as Javaslang can help.