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

Groovy seems like a natural step forward for Java developers, especially with the Grails framework.
It is an open source project backed by the Apache Software Foundation and has evolved over many
years. Besides Grails, Groovy has a large ecosystem that bodes well for its future.



Scala is also a strong contender for Java developers. It has grown in popularity very quickly over
the past few years and has strong support from TypeSafe with their “Scala, Akka, Play” stack.

# Adoption
Although not the only one, adoption is an important measure since the more widely adopted the language is, the more jobs will be available with it and the better its ecosystem will be.

A great way to find out about language adoption is [Ohloh](https://www.ohloh.net/languages/compare?commit=Update&l0=groovy&l1=scala&l2=clojure&l4=-1&measure=contributors&percent=true). As you can see (if you follow that link), Scala overcame Groovy around 2010, but it really took off in 2012.

# Performance
Performance is another important issue with languages. However, this can change very quickly as language developers or the JVM improves over time. Also, for most projects, runtime performance is
not the biggest priority. Developer-time is often a higher priority, so the language's ease of use and ecosystem is important.

If performance is a big issue, you’d probably choose Scala although Groovy 2.0 now has optional static-compilation, and so its [performance can be close to Java](http://java.dzone.com/articles/groovy-20-performance-compared). However, in real life, performance
is greatly affected by what framework and/or libraries you use and how easy (or hard) they make it
to be performant.

# Web frameworks
Especially now, with the introduction of the [Play framework 2.0](http://blog.typesafe.com/introducing-play-20), Scala is looking like a huge contender in the “highly-scalable” web world. Scala proponents claim it makes things like multithreading and error handling (and thus  [scaling), easier](https://jazzy.id.au/default/2012/11/02/scaling_scala_vs_java.html) while still making small projects a breeze.

Grails 2.0 has introduced some compelling features for scalability as well. For example, it supports
the [Servlet 3.0 async features](http://burtbeckwith.com/blog/?p=1251), has a `@Cachable` annotation, supports NoSQL backends (like
MongoDB), and has plugins for automatically gzipping and caching resources.

Wouldn’t it be nice if someone made a head-to-head comparison of Grails and Play? It turns out Matt
Raible and James Ward did just [that](http://raibledesigns.com/rd/entry/play_vs_grails_smackdown_at). The main difference between the two comes from their
differing goals. Grails was built to get up-and-running fast with a database-driven web-application
and provide a huge ecosystem of plugins to speed up development. Play’s primary goal is to create
highly scalable web applications, so it puts more emphasis on the asynchronous framework (Akka).
Also, Scala is statically typed, whereas Groovy is not by default.

# Conclusion
As a Java developer, you should spend time learning and using both of these languages. While
Scala appears to have the performance, type-safety, and scalability edge, Groovy is easier to learn,
has a big ecosystem and is in many ways more similar to Java (and with Groovy 2.0, it now has `@StaticCompile` and `@TypeChecked`).


Learn about different aspects of Groovy and Scala.

Groovy vs. Scala

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

Groovy vs. Scala

Java.next(): Groovy vs. Scala