Gain insights into Java 17, cloud and microservices, reactive programming, and top JVM languages. Explore hands-on projects using Scala, Groovy, and Gradle to boost your software development career.

Modern Java Second Edition by Adam L. Davis.png

file.tar.gz

modern_java

Groovy

Scala

Java 12

Java 14

Java 16

Java 17

Java 16-copy

Play

jshell

SPA-play

Gradle-uppercase

Gradle-copyimages

Gradle-properties

Java 14-copy

Java 16-fruits

Java 16-strings

Gradle-java

This course is meant for Java programmers or aspiring programmers who want to know about the latest Java and JVM technology. Throughout this course, you will get several opportunities to get hands-on experience with various Java concepts. 

This course will help you understand the latest in Java up to version 17; cloud and microservices; build, testing, and web frameworks; reactive programming in Java; and the best JVM languages so you can advance your career in software development. 

Moreover, you will also get to work with Scala, Groovy, and Gradle. The course explains Java concepts in detail and also draws comparisons with its older versions, as well as JVM languages.

The All-in-One Guide to Java Programming

One of the hallmarks of functional programming is **tail-call recursion**. It solves the same problem as iterative approaches . Unfortunately, it can cause stack-overflows if not properly optimized by the compiler.

Tail-Call optimization refers to when a compiler converts a recursive function call into a loop to avoid using the call stack. For example, a function that uses tail-call recursion in Lisp will be automatically optimized this way.


## Java 8 support
Java 8 does not currently support tail-call optimization like some other languages. However, it is possible to approximate it using something like the following interface:

``` java
@FunctionalInterface
public interface Tail < T > {

        Tail < T > apply();

        default boolean isDone() {
            return false;
        }

        default T result() {
            throw new UnsupportedOperationException("Not done yet.");
        }

        default T invoke() {
            return Stream.iterate(this, Tail::apply)
                .filter(Tail::isDone)
                .findFirst()
                .get()
                .result();
        }
```
The `Tail` interface has three default methods and one abstract method (`apply`). The `invoke()` method contains the meat of the “tail-call optimization:”

* It takes advantage of Stream’s `iterate` method to create an infinite Stream, which will continuously call Tail’s `apply` method.
* Then it uses `filter` and `findFirst` to stop the Stream when `isDone()` returns true.
* Finally, it returns the result.

To implement the “done” condition, there is the following additional static method on Tail:

``` java
static < T > Tail < T > done(final T value) {
    return new Tail < T > () {
        @Override
        public T result() {
            return value;
        }
        @Override
        public boolean isDone() {
            return true;
        }
        @Override
        public Tail < T > apply() {
            throw new UnsupportedOperationException("Not supported.");
        }
    };
}
```
With the `Tail` interface, we can mimic tail-call recursion quite easily in Java 8. Here’s an example of calculating factorial using this interface (using BigInteger so that very large factorials can be computed):

``` java
public static BigInteger factorial(int n) {
    return streamFactorial(BigInteger.ONE, n).invoke();
}
private static Tail < BigInteger > streamFactorial(BigInteger x, int n) {
    return () - > {
        switch (n) {
            case 1:
                return Tail.done(x);
            default:
                return streamFactorial(x.multiply(BigInteger.valueOf(n)), n - 1);
        }
    };
}
```
Using this method, we can make extremely fast programs while still maintaining the functional
style.

Of course, the JVM does a lot of optimization by itself, so this may not always be the best course.
However, it is something to keep in mind.

> In this particular case, a simple recursive factorial is faster than the code above. However, it causes a "StackOverflowError" for sufficiently large numbers, whereas `streamFactorial` does not.

Combining it all together:

# Java 8 support
Java 8 does not currently support tail-call optimization like some other languages. However, it is possible to approximate it using something like the following interface:

``` java
@FunctionalInterface
public interface Tail < T > {

        Tail < T > apply();

        default boolean isDone() {
            return false;
        }

        default T result() {
            throw new UnsupportedOperationException("Not done yet.");
        }

        default T invoke() {
            return Stream.iterate(this, Tail::apply)
                .filter(Tail::isDone)
                .findFirst()
                .get()
                .result();
        }
```
The `Tail` interface has three default methods and one abstract method (`apply`). The `invoke()` method contains the meat of the “tail-call optimization:”

* It takes advantage of Stream’s `iterate` method to create an infinite Stream, which will continuously call Tail’s `apply` method.
* Then it uses `filter` and `findFirst` to stop the Stream when `isDone()` returns true.
* Finally, it returns the result.

To implement the “done” condition, there is the following additional static method on Tail:

``` java
static < T > Tail < T > done(final T value) {
    return new Tail < T > () {
        @Override
        public T result() {
            return value;
        }
        @Override
        public boolean isDone() {
            return true;
        }
        @Override
        public Tail < T > apply() {
            throw new UnsupportedOperationException("Not supported.");
        }
    };
}
```
With the `Tail` interface, we can mimic tail-call recursion quite easily in Java 8. Here’s an example of calculating factorial using this interface (using BigInteger so that very large factorials can be computed):

``` java
public static BigInteger factorial(int n) {
    return streamFactorial(BigInteger.ONE, n).invoke();
}
private static Tail < BigInteger > streamFactorial(BigInteger x, int n) {
    return () - > {
        switch (n) {
            case 1:
                return Tail.done(x);
            default:
                return streamFactorial(x.multiply(BigInteger.valueOf(n)), n - 1);
        }
    };
}
```
Using this method, we can make extremely fast programs while still maintaining the functional
style.

Of course, the JVM does a lot of optimization by itself, so this may not always be the best course.
However, it is something to keep in mind.

> In this particular case, a simple recursive factorial is faster than the code above. However, it causes a "StackOverflowError" for sufficiently large numbers, whereas `streamFactorial` does not.

Combining it all together:

Learn about tail-call optimization in Java 8.

Introduction

Java Syntax and Conventions

Java 7

Idiomatic Java 8: Lambdas, Streams, and Dates

New Date and Time API

Java 8 Miscellaneous

Advantages of Java 9

Java 10 - 17

Java Ecosystem

Maven and JUnit

Utilizing Essential Libraries

Modern Java Concurrency

RxJava

Other JVM Languages

Groovy

Gradle

Spock

Scala

RESTful

Microservices and Clouds

Grails

Spark

Spring Boot

Play Framework

Ratpack

Final Thoughts

Appendix

Functional Programming: Tail-Call Optimization

What is Tail-Call optimization?

Java 8 support