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

## Command chains
Groovy 1.8 added command chains, which allow for a completely fluent DSL for an even number of words.

For example, `pull request` on github will be executed as `pull(request).on(github)`.
Groovy 1.8 also added the following:
* Closure annotation parameters: `@Invariant({number >= 0})`
* Closure memoization: `{...}.memoize()`
* Built-in JSON support - Consuming, producing, and pretty-printing
* New AST Transformations: `@Log`, `@Field`, `@AutoClone`, and `@AutoExternalizable`, ...

## Modules
In Groovy 2.0, the monolithic Groovy jar was broken down into multiple jars so we can pick and choose what our project needs and keep our final project’s size down.
It also added the ability to create our own modules using
 [Extension modules](http://groovy-lang.org/metaprogramming.html#module-descriptor).

## Static type checking
Adding the `@TypeChecked` annotation to our class causes the compiler to enforce compile-time type-checking. It will infer types for us, so our code can still be Groovy.
* Infers Lowest Upper Bound (LUB)
* Gotcha’s:
  * Runtime meta-programming won’t work!
  * Explicit type needed in closure: `a.collect {String it -> it.toUpperCase()}`

Adding the `@StaticCompile` annotation to your class causes the compiler to compile your Groovy code to byte-code.
* Type-checking: No one else can change byte-code.
* Binary identical to compiled Java (almost).

In summary:
* `@StaticCompile`: Compiles your Groovy code to byte-code.
* `@TypeChecked`: Enforces compile-time type-checking.

## Invoke dynamic support in Groovy
Groovy 2 added total support for Java’s `invokedynamic` bytecode command, greatly improving performance. However, it is not enabled by default.

To enable `invokedynamic` support (lovingly called “indy”), you can do the following in a Gradle build file:
```
tasks.withType(GroovyCompile) {
     groovyOptions.optimizationOptions.indy = true
}
```

Also, make sure to change your dependency to use the indy classifier:
```
compile "org.codehaus.groovy:groovy-all::indy"
```

# Command chains
Groovy 1.8 added command chains, which allow for a completely fluent DSL for an even number of words.

For example, `pull request` on github will be executed as `pull(request).on(github)`.
Groovy 1.8 also added the following:
* Closure annotation parameters: `@Invariant({number >= 0})`
* Closure memoization: `{...}.memoize()`
* Built-in JSON support - Consuming, producing, and pretty-printing
* New AST Transformations: `@Log`, `@Field`, `@AutoClone`, and `@AutoExternalizable`, ...

# Modules
In Groovy 2.0, the monolithic Groovy jar was broken down into multiple jars so we can pick and choose what our project needs and keep our final project’s size down.
It also added the ability to create our own modules using
 [Extension modules](http://groovy-lang.org/metaprogramming.html#module-descriptor).

# Static type checking
Adding the `@TypeChecked` annotation to our class causes the compiler to enforce compile-time type-checking. It will infer types for us, so our code can still be Groovy.
* Infers Lowest Upper Bound (LUB)
* Gotcha’s:
  * Runtime meta-programming won’t work!
  * Explicit type needed in closure: `a.collect {String it -> it.toUpperCase()}`

Adding the `@StaticCompile` annotation to your class causes the compiler to compile your Groovy code to byte-code.
* Type-checking: No one else can change byte-code.
* Binary identical to compiled Java (almost).

In summary:
* `@StaticCompile`: Compiles your Groovy code to byte-code.
* `@TypeChecked`: Enforces compile-time type-checking.

# Invoke dynamic support in Groovy
Groovy 2 added total support for Java’s `invokedynamic` bytecode command, greatly improving performance. However, it is not enabled by default.

To enable `invokedynamic` support (lovingly called “indy”), you can do the following in a Gradle build file:
```
tasks.withType(GroovyCompile) {
     groovyOptions.optimizationOptions.indy = true
}
```

Also, make sure to change your dependency to use the indy classifier:
```
compile "org.codehaus.groovy:groovy-all::indy"
```

Learn about command chains and modules used in Groovy.

Command Chains and Modules

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

Command Chains and Modules

Command chains