A Comprehensive Guide to JVM Languages: 2 in 1
4.2 (4 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
49 students enrolled

A Comprehensive Guide to JVM Languages: 2 in 1

Your one-stop guide to learn JVM languages - Java, Scala, Clojure, Kotlin & Groovy
4.2 (4 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
49 students enrolled
Created by Packt Publishing
Last updated 10/2018
English
English [Auto]
Current price: $129.99 Original price: $199.99 Discount: 35% off
1 day left at this price!
30-Day Money-Back Guarantee
This course includes
  • 7 hours on-demand video
  • 1 downloadable resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Understand the popular JVM languages and the Java Class Library
  • Get to know about various programming paradigms such as imperative, object-oriented, and functional
  • Work with common JVM tools such as Eclipse IDE and Gradle
  • Explore frameworks such as Vert.x, Akka and JavaFX
  • Boost your knowledge about dialects of other well-known programming languages that run on the JVM, including JavaScript, Python, and Ruby
Course content
Expand all 50 lectures 07:10:31
+ Introduction to JVM Languages - JVM, Java, Scala
23 lectures 03:35:37

This video gives an overview of the entire course.

Preview 04:11

Here, we will look at the reasons to develop our project on JVM.

  • Look at popular features of Java

  • Create an application using a JVM application server, high-level web application framework, and a micro-service framework

Why Develop on JVM?
06:40

We have learnt the importance of JVM. Here we will look at some places where its usage is popular.

  • Explore web applications, big data, and IoT

Popular Use Cases
03:23

Each JVM developer should be familiar with the concepts of it. Also, Java has different editions aiming at different use cases. Let’s learn all of this in this video.

  • Understand important concepts like Virtual Machine, Compiler, data types and classes

  • Look at the three important editions like Java SE, Java EE, and Java ME

JVM Concepts and Java Editions
13:32

This video will provide options on other languages on JVM besides Java.

  • Look at the reasons for not selecting Java

  • Mix JVM languages in a project

Other Languages on JVM
03:45

JDK installation is important for JVM developers. It contains some development tools that are essential for application development.

  • Install and explore JDK

  • Install JRE

JDK
10:10

Interoperability between classes is enabled by class organization in JVM. Let’s learn about that in this video.

  • Understand packages

  • Work with packages

Class Organization with Packages
04:18

Java Class Library is a huge collection of pre-built classes like toolkits, input output libraries, and so on.

  • Look at the Java Class Library organization

  • Understand packages and work with the java.lang package

  • Prepare classes for the Collections API

Java Class Library
15:07

Running JVM applications on command line is a complex topic. There are a few rules that must be followed before we run the code. Let’s look at them.

  • Take a look at the rules

  • Perform a hand-on demonstration in Java

Running JVM Applications on the Command Line
10:56

Coding Java in a simple text editor is difficult. Hence, we have the Eclipse IDE which provides us with additional features.

  • Download and install Eclipse IDE

Eclipse IDE
04:08

To use Java, you need to understand OOP. This section will refresh your memory regarding OOP concepts.

  • Understand OOP related subjects like classes, packages, variables, methods, and so on

  • Work with inheritance, interfaces, and upcasting and downcasting

OOP in Java
21:19

After understanding the concepts, we will now start writing Java code to implement classes. We will look at concepts here that will guide you in the process.

  • Look at Java concepts like operators, Conditional checks, arrays, collections, threads and lambdas.

Writing Java Code
15:07

We need to configure Eclipse as per our requirements to have more control over our application.

  • Add the Gradle feature to the EclipseIDE

Configuring Eclipse IDE
02:06

In this video, we will create a simple web service in Java using the test-driven development approach.

  • Create the project and modify the Gradle build file

  • Code the backend and web service code

Creating a Web Service in Java
23:39

This video will provide you with the installation of Scala and working of the Scala REPL shell.

  • Install Scala and go through the Scala documentation

Scala Installation and REPL Shell
03:35

We need to understand the difference between functional and imperative programming to know which one to use when.

  • Write a class in functional and imperative ways and compare

Functional Versus Imperative Programming
02:46

Before starting working in Scala, we need to know the Scala syntax and rules.

  • Learn static typing in Scala

  • Look at mutable and immutable variables

  • Understand the common Scala types

Scala Language Syntax and Rules
05:18

In this video, we will learn how to write OOP in Scala.

  • Define packages, subpackages, and import members

  • Define classes, instance variables and methods

  • Learn about constructors, extending a class, method overloading, and so on

OOP in Scala
13:43

Now that we have discussed OOP thoroughly, let's start writing classes and methods that do something useful.

  • Work with generics, collections, and XML processing

Scala's Standard Library
07:02

Functional programming is different from imperative programming. Let’s see how functional programming works with Scala.

  • Iterate through collection using functions

  • Understand the map, filter, and reduce design pattern

Functional Programming in Scala
05:56

Eclipse IDE does not come with Scala support. We need to install the plugin to run Scala.

  • Install Scala IDE for Eclipse

  • Switch to the Scala IDE perspective

Scala IDE for the Eclipse Plugin
03:47

Scala has its own built tool, SBT. We will add Eclipse support to SBT.

  • Install SBT and create a new SBT-based project

  • Add the SBT plugin to add Eclipse-related commands

  • Work with scalac

SBT
09:37

Akka is a modular toolkit for creating robust, distributed applications. Let’s create one here.

  • Add Akka dependency to SBT build file

  • Create an Akka actor – QuotesHandlerActor

  • Implement a message handler and wrap it up in the main application

Creating an Akka Project
25:32
Test Your Knowledge
5 questions
+ Introduction to JVM Languages – Clojure, Kotlin, and Groovy
27 lectures 03:34:54

This video provides an overview of the entire course.

Preview 03:57

In this video, we will get started with Clojure by installing it and creating a start script.

  • Install and validate Clojure

  • Create a start script

Installing Clojure
02:29

Before starting, we will look at the REPL shell and learn all about the Clojure language in this video.

  • Run Clojure’s REPL interactive shell

  • Learn about syntax, expressions, variables, functions, and conditions

Clojure's Interactive Shell (REPL) and Language
20:12

The Clojure team added several features to Clojure to ensure that Clojure can properly consume and create classes from the Java class library and other JVM libraries. Let’s see how that works in this video.

  • Create an instance of a class. Call methods and add variables

  • Use deftype and defrecord

Working with Java Classes
04:21

To safely manage a mutable state in a multithreaded program, Clojure offers agents. In this video, we will learn to manage states with the help of agents.

  • Understand working of an agent

  • Learn about functions related to agent such as validator and watchers

  • Create an agent for checking invoice status

Managing States with Agents
06:51

To add Clojure support to Eclipse IDE, a plugin is required. In the Clojure world, this plugin is called Counterclockwise.

  • Install the Counterclockwise plugin

  • Switch to Java perpective

Preview 02:46

Leiningen is the de facto build tool used for Clojure development. So it is important to learn about it.

  • Install Leiningen

  • Test your installation

Leiningen's Build Tool
04:15

Until now, we have only entered snippets of code in Clojure's interactive REPL shell. To create executable programs in Clojure, you'll have to call an ordinary Clojure macro in your code that will instruct the built-in compiler to generate JVM .class files.

  • Compile class files with and without Leiningen

Creating Executable Programs in Clojure
06:59

Now that we've tried out Leiningen, we are ready to build our first project in Eclipse IDE using the Counterclockwise plugin. Let’s do that in this video.

  • Generate the project and add a line to the bottom of the file

  • Verify installation. Run Clojure's source code inside a Clojure REPL instance

  • Update the project’s Clojure version

Creating a New Counterclockwise Project
06:23

Monads are used in functional programming to build simple components. They are used to chain a series of operations in a safe way. Let’s look at the working of monads.

  • Create a monad and define the source file that will store unit tests

  • Run the code and take a look at the main code

Exploring Monads by Applying Test-Driven Development
10:21

Luminus is a microframework for quickly building powerful web applications in Clojure.

  • Create a Luminus project

  • Import project in Counterclockwise

  • Add page to the web application

The Luminus Web Framework
09:49

Our first step as always is to install the required software. In this video, we will install Kotlin.

  • Download Kotlin from GitHub. Install it

  • Launch scripts

Installing Kotlin
02:24

Kotlin also has a REPL interactive shell that can be used to try Kotlin snippets interactively. Let’s have some fun with it!

  • Start REPL

  • Work with Notepad++

Kotlin's REPL Interactive Shell
01:30

We need to know the fundamentals of the Kotlin language before starting programming in it. This video will give us an insight of the Kotlin language.

  • Define local variables and functions

  • Learn about Kotlin’s types and loops

Kotlin Language Fundamentals
12:28

Kotlin is first and foremost an OOP language. We will look at some of the basic concepts here. While Kotlin is a pure OOP language, it also supports procedural programming. So let’s begin, shall we?

  • Define classes, constructors and packages

  • Import members and add them to classes

  • Learn about inheritance and interfaces. Perform procedural programming

OOP and Procedural Programing in Kotlin
20:11

There is a Kotlin plugin available for Eclipse IDE to make things easy for us. Let’s explore it in this section.

  • Install the Kotlin plugin

  • Switch to Kotlin perspective

Kotlin for the Eclipse IDE Plugin
02:06

Apache Maven is a famous build tool and is used by Kotlin developers. Hence it becomes essential for us to know about it.

  • Install Apache Maven

  • Download Kotlin starter kit

  • Explore and update the pom.xml build file

Apache Maven
09:11

In this video, we will be building a simple desktop application in Kotlin, that makes use of the JavaFX GUI desktop toolkit.

  • Prepare the project and create runnable application

  • Write an extensible function. Implement a BorderPane-based layout

  • Implement animation and debug the program

Creating a JavaFX Desktop GUI Application
20:35

Installing Groovy is not much different from the other languages covered so far. So let’s do it in this video.

  • Install GroovyConsole and GroovyShell

Installing Groovy
05:13

As the Groovy language is largely compatible with the Java language, it's an easy language to learn for Java developers. Also, Groovy comes with a large library of classes that can be used to make the life of a developer Easier in the Groovy Development Kit

  • Learn OOP in Groovy, learn about access modifiers, properties, and POJO

  • Work with Groovy Strings and collections

Groovy Language and Development Kit
21:40

There is a difference between static and dynamic programming. Let’s look at it in this video.

  • Understand meta and static programming

Dynamic and Static Programming
05:44

Groovy Eclipse, the plugin that adds Groovy support to Eclipse IDE, is on the Eclipse Marketplace. Let’s use it in our course.

  • Install the Groovy plugin

  • Switch to Java perspective

Installing the Groovy Eclipse Plugin
02:57

Groovy has a built-in dependency manager called Grape, but it has issues when using it within Groovy Eclipse. Therefore, we will be using Apache Ivy for our dependency management in this section.

  • Install Apache IvyDE plugin for Eclipse IDE

Apache Ivy and IvyDE
02:09

Now that we have installed all required plugins in Eclipse IDE, we can create the project.

  • Create a new Groovy Eclipse project

  • Create an ivy.xml file for Ivy

Creating and Configuring the Project
04:46

The Java Database Connectivity (JDBC) standard is a standard that makes it possible to access Database management system (DBMS) servers in JVM applications. We will learn about it in this video.

  • Explore the H2 database

  • Create an in-memory database

Java Database Connectivity (JDBC)
11:15

Groovy's XML MarkupBuilder class is an example of a class that has been created using Groovy's dynamic programming features. We will work with it in this video.

  • Write code using MarkupBuilder class

  • Generate XML based on SQL

Generating XML Using MarkupBuilder
04:47

Vert.x is a modern micro web service framework for the JVM platform. It has high performance and scalability.

  • Add vert.x dependency to Ivy

  • Create the web service

The Vert.x microservice Platform
09:35
Test Your Knowledge
5 questions
Requirements
  • Basic practical knowledge of a modern programming language that supports object-oriented programming (JavaScript, Python, C#, VB .NET, and C++) is assumed.
Description

JVM is responsible for interpreting Java bytecode and translating it into actions. In the beginning, Java was the only programming language used for the JVM. But the increasing complexity of the language and the remarkable performance of the JVM created an opening for a new generation of programming languages.

This Learning Path is a step-by-step guide which will walk you through the modern programming language: JVM. The course will start by giving you a basic understanding of JVM and its features, which are common to the JVM languages, helping you get abreast of its concepts. It will then dive into explaining languages such as Clojure, Kotlin, and Groovy and will show how to work with each language, their features, use cases, and pros and cons. By writing example projects in those languages and focusing on each language’s strong points, it will help you find the programming language that is most appropriate for your particular needs.

By the end of the course, you will have written multiple programs that run on the JVM and will know the differences between both languages. Also you'll be able to Work with various programming paradigms and gain knowledge about imperative, object-oriented, and functional programming

 Contents and Overview

This training program includes 2 complete courses, carefully chosen to give you the most comprehensive training possible.

The first course, Introduction to JVM Languages - JVM, Java, Scala begin with a general introduction to the JVM and its features, which are common to the JVM languages, helping you get abreast of its concepts. It then dives into explaining languages such as Java and Scala and shows you how to work with each language, their features, use cases, and pros and cons. By writing example projects in these languages and focusing on each language’s strong points, it will help you find the programming language that is most appropriate for your particular needs.

The Second course, Introduction to JVM Languages – Clojure, Kotlin, and Groovy starts with a general introduction of the JVM and its features, which are common to the JVM languages, helping you get abreast with its concepts. It will then dive into explaining languages such as Clojure, Kotlin, and Groovy and will show how to work with each language, their features, use cases, and pros and cons. By writing example projects in those languages and focusing on each language’s strong points, it will help you find the programming language that is most appropriate for your particular needs.

About the Authors: 

  • Vincent van der Leun is a software engineer living in the city of Utrecht in The Netherlands. Programming since the age of 8, he has worked with many different languages and platforms over the years. Rediscovering Java a few years ago, he loved it so much that he became an Oracle Certified Professional, Java 7 Programmer, and started the JVM Fanboy blog. Currently, he works for CloudSuite, a company specializing in modern e-commerce solutions. At CloudSuite he works on various back-end systems and web services, writes JavaScript code for front-end applications, supports consultants by providing complex SQL queries, and consumes coffee while having design-related discussions with fellow developers.

Who this course is for:
  • This video is meant for programmers who are interested in the Java Virtual Machine (JVM) and want to learn more about the most popular programming languages that can be used for JVM development.