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

# A brief history of Scala
It may be helpful to look back on how Scala has changed and improved over the last few major releases.




## Scala 2.9
Scala 2.9 introduced some new features, including:

* **Parallel Collections:** Every collection can be converted into a corresponding parallel collection using the `par` method.
* **`App` Trait:** `App` replaces Application as a better way to write a top-level application class (`args` is available).
* **`DelayedInit` Trait:** If a class or object inherits from this trait, all its initialization code is packed in a closure and forwarded as an argument to a method named `delayedInit`, which is defined as an abstract method in trait `DelayedInit`.
* **Repl Improvements:** More robust cursor handling, bash-style ctrl-R history search, and new commands like `:imports`, `:implicits`, and `:keybindings`.
* **Scala Runner:** `scala` can accept a jar file, class name, or source file as an argument.
* **Java Interop**:
  * The `@strictfp` annotation is supported.
  * Primitive types and their boxed versions are implicitly converted bidirectionally.
* **New methods in collections:** `collectFirst`, `maxBy`, `minBy`, `span`, `inits`, `tails`, `permutations`,
`combinations`, and `subsets`
* **AnyRef specialization:** It’s possible to specialize on type parameters for subtypes of AnyRef
`(class Foo[@specialize(AnyRef) T](arr: Array[T]) {...})`, which allows for more efficient
array indexing and updates.

## Scala 2.10
Some of the prominent new features of Scala 2.10 include:
* [**Values Classes**](https://docs.scala-lang.org/overviews/core/value-classes.html): The ability to extend AnyVal.
* [**Implicit Classes**](https://docs.scala-lang.org/sips/implicit-classes.html): A simplification of the definition of implicit wrappers.
* [**String Interpolation**](https://docs.scala-lang.org/overviews/core/string-interpolation.html): Similar to Groovy’s GString.
* [Futures and Promises](https://docs.scala-lang.org/overviews/core/futures.html)
* [Dynamic and applyDynamic](https://docs.scala-lang.org/sips/type-dynamic.html)
* New ByteCode emitter based on ASM
* Can target JDK 1.5, 1.6, and 1.7 (Emits 1.6 bytecode by default)
* A new Pattern Matcher rewritten from scratch to generate more robust code.
* **Scaladoc Improvements:** Implicits (-implicits flag), Diagrams (-diagrams flag, requires Graphviz), and
Groups (-groups)
* **Modularized Language features:** Get on top of the advanced Scala features used in your
codebase by explicitly [importing them](https://docs.scala-lang.org/sips/modularizing-language-features.html).
* [Parallel Collections are now configurable with custom thread pools](https://docs.scala-lang.org/overviews/parallel-collections/overview.html).
* Akka Actors are now part of the distribution (the original Scala actors are now deprecated).
* Addition of `???` and `NotImplementedError`.
* Addition of `IsTraversableOnce` and `IsTraversableLike` type classes for extension methods.
* Some Performance improvements (Faster inliner, `Range#sum` is now $O(1)$, update of ForkJoin library, Fixes in immutable TreeSet/TreeMap, Improvements to PartialFunctions)

## Scala 2.11
This release of Scala removed a lot of deprecated code and moved some things out of the standard
library, such as XML literals.
* The following packages have been deprecated: `scala.actors` and `scala.text`.
* Akka is suggested to replace the old actor model.
* To compile code that contains XML literals, we must add a dependency on scala-xml or some
alternative.
* The REPL saw many improvements.

## Scala 2.12
The Scala compiler has been completely overhauled to use Java 8 JVM features, such as
`invokedymanic`, the same bytecode used by lambda-expressions. This means that performance will
be greatly improved, but Scala 2.12 is not compatible with pre-Java-8 JVMs.

# Conclusion


Blast From the Past

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

Blast From the Past

A brief history of Scala

Scala 2.9