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

## STM in Clojure
STM results in a separation of State and Identity. For example, the stock price at a given time is
immutable. We must use a Transaction to modify anything.
We can include the Clojure jars and use them within Java. For example, in the following code, `referenceToAmount` can only be modified inside of a Transaction:

``` java
import Clojure.lang.*
Ref referenceToAmount;
LockingTransaction.runInTransaction(new Callable() {
        referenceToAmount.set(value);
});
```

We will get an error if we try to modify the `Ref` outside of a Transaction. This makes concurrent programming easier because modifying data outside of a `synchronize` block is impossible.

## Actors
The Scala-based actor framework, Akka, can also be used from Java.

The following code shows a simple example using the Akka framework with one actor:

``` java
import akka.actor.*
public class XActor extends UntypedActor {
     public void onReceive(Object message) throws Exception {
          if (message instanceof String)
             System.out.println((String) message);
     }
}
public static void main(String... args) {
         ActorSystem system = ActorSystem.create("MySystem");
         ActorRef actor = system.actorOf(new Props(XActor.class), "actor");
         // the message could be anything implementing Serializable
         actor.tell("Message String");
}
```

An actor runs in a dedicated thread, so it can only do one thing at a time. This makes concurrency
much easier to implement.


# STM in Clojure
STM results in a separation of State and Identity. For example, the stock price at a given time is
immutable. We must use a Transaction to modify anything.
We can include the Clojure jars and use them within Java. For example, in the following code, `referenceToAmount` can only be modified inside of a Transaction:

``` java
import Clojure.lang.*
Ref referenceToAmount;
LockingTransaction.runInTransaction(new Callable() {
        referenceToAmount.set(value);
});
```

We will get an error if we try to modify the `Ref` outside of a Transaction. This makes concurrent programming easier because modifying data outside of a `synchronize` block is impossible.

# Actors
The Scala-based actor framework, Akka, can also be used from Java.

The following code shows a simple example using the Akka framework with one actor:

``` java
import akka.actor.*
public class XActor extends UntypedActor {
     public void onReceive(Object message) throws Exception {
          if (message instanceof String)
             System.out.println((String) message);
     }
}
public static void main(String... args) {
         ActorSystem system = ActorSystem.create("MySystem");
         ActorRef actor = system.actorOf(new Props(XActor.class), "actor");
         // the message could be anything implementing Serializable
         actor.tell("Message String");
}
```

An actor runs in a dedicated thread, so it can only do one thing at a time. This makes concurrency
much easier to implement.


Learn about STM and actors in the Akka framework.

STM in Clojure and Actors

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

STM in Clojure and Actors

STM in Clojure