Java for Small Coding Tasks

.jpg

The Presenter

.jpg

Cay Horstmann
Author of Core Java (14 editions since 1996), Java/JavaScript/Scala for the Impatient, etc.
Java Champion
https://horstmann.com

The Sponsors

The Participants

.jpg

Your Java expertise: How many years? Which version?
Your scripting expertise: How much? What platform? What language?
Your goals for the workshop
Did you install
- Java 25
- VS Code
- IntelliJ
- JBang

Launching Without Compiling

.jpg

JEP 330: Launch Single-File Source-Code Programs
JEP 458: Launch Multi-File Source-Code Programs
java path/to/MyProg.java
Note extension .java
Code compiled with each launch
“Shebang”: First line
```
#!/usr/bin/env java --source 25
```
Invoke as path/to/MyProg
With shebang, the file name can't end in .java
Unpleasant when editing script

Remedy:

///usr/bin/env java --source 25 "$0" "$@" ; exit $?

~/bin/BackupFileFilter.java

Instance Main Methods and Compact Source Files

.jpg

JEP 512

Instance main method:

class MyClass {
    void main() { ... }
    ...
}

Can optionally have String[] parameter
Can optionally be public, protected, static, but why?

Compact source files: No class MyClass, but just

var variable = initialValue;
Type method(Type param, ... ) { ... }
void main() { ... }

Become instance variables and instance methods of a class
Class name = file name - extension
IO class with static println, print, readln
Saves a few lines, maybe gives a Pythonic vibe
~/bin/Audio.java and its shell predecessor ~/bin/audio

Imports

.jpeg

JEP 511: Module import declarations

import module java.base;
import module java.sql;

Compact source files automatically import java.base module
A small number of name collisions: java.lang.Annotation/java.text.Annotation, java.lang.reflect.Proxy/java.net.Proxy, etc.

Static imports work well for small programs:

import static java.lang.System.*;
import static java.lang.Math.*;

err.println(sqrt(PI));

Records

.jpg

Records are your friend

Python programs often use ad-hoc lists, dicts for “data carrier” objects:

brick = [ { 'x': 0, 'y': 0 }, { 'x': 10, 'y': 20 }] // top left, bottom right

In Java, cost of giving a name is very low:

record Brick(Point topLeft, Point bottomRight)

Free toString, equals, hashCode

Record is natural home for adding related methods:

record Brick(...) {
    static Brick parse(String s) { ... }
    boolean overlaps(Brick other) { ... }
}

Good for the same reasons: enum

Other Helpful Language Features

.png

Yeah for compile-time typing:

var userIdMap = new HashMap<String, User>();

beats

userIdMap = {} # Map from user ID to User object

var, diamond
Text blocks (to keep data with the code)
No collection literals, but List.of, Map.of are good enough

Tip: Prefer lists over arrays to avoid painful refactoring

var seasons = List.of("Spring", "Summer", "Fall", "Winter");

Scripting with the Java API

.jpg

Strings, regex, collections, date/time: excellent
“New” I/O: excellent
- Check out https://dev.java/learn/modernio/ if you still use BufferedReader
Stream ops map, filter, count, collect, max/min/sum
HTTP client/server: ok
Processes: need a little help
XML: serviceable
JSON will come eventually (JEP 540)
Missing in action:
- CLI arg parsing

Lab: Random Files

Your mission: Write a script that lists ten random files that are descendents of the current directory (Path.of(".")).
Put the file into mydir, not mydir/src/main/java
Use VS Code (or some other simple editor), not IntelliJ
Ask your favorite chatbot for the Java code
- Depending on your chatbot's mood, it may just shuffle a list or use reservoir sampling
- It doesn't matter for this exercise
Use modern features: no class name, no imports, just void main() throws Exception
Run in terminal
Linux/Mac: Make file executable

Sneaky

.jpg

Chatbots love streams, but streams don't love exceptions:

paths.stream().map(Files::readString) // Error: incompatible thrown types...

Any alternative to this? (Asking for a friend)

p -> { try { return p->Files.readstring(p); } catch (IOException ex) { ... } }

“Sneaky throw” uses hole in Java type system:

paths.stream().map(Sneaky.Function.of(Files::readString))

Depending on context, you can sometimes drop the interface name:
```
paths.stream().forEach(Sneaky.of(this::dump))
```

The following is useful for "global" variables in compact source files:

Sometype variable = Sneaky.call(() -> constructor or factory with checked exception);

Lab: Modify the previous script to find the ten largest files.
Can you use Sneaky.of?

Is it slower than

find . -type f -printf '%s %p\n' | sort -nr | head

Where do you put Sneaky.java?

Command-Line Arguments

Sadly the JDK doesn't have a standard library for argument parsing
Good third party libs, but...Maven
Remedy: Single-file implementation
- Single-file version of picocli (almost 20,000 lines)
- My favorite: Rémi Forax' argvester (603 lines)
Lab: Modify our file walker to optionally set the number of files and the root path.

Break

.jpg

Lab: JShell

.jpeg

Nice for experiments
90% of my uses seem to be fussing with regex 😿

Try this:

var json = new String(URI.create("https://dog.ceo/api/breeds/image/random").toURL().openStream().readAllBytes())
var kv = Pattern.compile("\"(?<key>[^\"]+)\"\\s*:\\s*\"(?<value>[^\"]+)\"")
kv.matcher(json)
$3.find()
$3.group("value")

A bit awkward with longer code
Try the /edit command
Use /save filename to save your snippets

Set classpath on command line

jshell --class-path /home/cay/bin

or inside JShell:

/env --class-path /home/cay/bin

Some IDEs include JShell (poorly)
Could be used for scripting, but Brian Goetz doesn't recommend it

Lab: JSON

My favorite single-file implementation for JSON is Essential JSON
Write a script that downloads a random dog picture. Start with:

var json = new String(URI.create("https://dog.ceo/api/breeds/image/random").toURL().openStream().readAllBytes())

Yields a string such as

{"message":"https://images.dog.ceo/breeds/appenzeller/n02107908_754.jpg","status":"success"}

Now parse that JSON and get the message value. Use your choice of Essential JSON or Java 28 with JEP 540.
Finally, open that URL and save the bytes to a file. (Hint: URL.openStream, Files.newOutputStream, InputStream.transferTo)
Try with jshell first to see if you like that exploratory workflow. If you use Java 28, start with
```
jshell --enable-preview --add-modules jdk.incubator.json
```

Lab: Processes

Executing processes is better with a tiny helper
Try smalljava.Exec.exec("ls", "-al", ".") or smalljava.Exec.exec("cmd", "/c", "dir") in jshell
Realistic use case: Find all Markdown files in a directory and turn them to HTML with Pandoc
Try this with IntelliJ. Put a starter Java file into an empty project directory, then create the project from existing sources
Or fiddle with the project structure.
- Open IntelliJ
- Make a new project at ~/books/cji4/katacoda
- Menu → Project structure... → Modules
- Check the content root. If wrong, remove and add parent instead. Then mark as Sources.
- Open MakeLab.java

jpm

jpm is “npm for Java”
Easiest installation: First install JBang (which we need anyway), then
```
jbang app install jpm@codejive
```

Then run

jpm search jfiglet
jpm copy com.github.lalyos:jfiglet:0.0.9
ls deps
jshell --class-path deps/\*
import com.github.lalyos.jfiglet.FigletFont;
IO.println(FigletFont.convertOneLine("Hello, Basel"));

Lab: JBang

.png

Killer feature: Maven dependency declarations as comments:

//DEPS com.github.lalyos:jfiglet:0.0.9

import com.github.lalyos.jfiglet.FigletFont;

void main() throws Exception {
    IO.println(FigletFont.convertOneLine("Hello, Basel"));
}

Try it out
```
jbang HelloBasel.java
```
Flags as comments:
```
//COMPILE_OPTIONS ...
//RUNTIME_OPTIONS ...
```
Try it out with a preview feature of your JDK

Export to JAR or fat JAR

jbang export fatjar HelloBasel.java
java -jar HelloBasel-fatjar.jar

Native image
```
sdk use java 25-graal
jbang export native HelloBasel.java
```
- How long did it take?
- How big is the executable?
- Did it work?

Lab: JBang (Continued)

.png

Launch JShell with dependencies
```
jbang --interactive HelloBasel.java
```
How can you tell the dependencies were loaded?
Install the JBang extension into VS Code.
Click on Synchronize JBang, then run with JBang
Does debugging work?
Launch an editor in a sandbox with symlinks. Replace codium with emacs, vim, etc. if you like.
```
jbang edit -b --live --verbose --open=codium HelloBasel.java
```
What links were made?
Install the IntelliJ plugin
Make a new IntelliJ project from existing sources, pointing to the directory containing HelloBasel.java. Decline any offers of Maven, Gradle, etc.
Right-click on HelloBasel.java and select Sync JBang DEPS
Test that autocomplete and debugging work as usual

Break

.jpg

Lab: Notebooks

.png

For interactive, explorative programming
Code cells, visual output of tables and graph, sliders, ...
Mainstay of data science in Python
JTaccuino is a JavaFX app with Jshell cells
Download latest release and install
Type 6 * 7 and run (Alt+Enter)

Make a new cell if not automatically created, enter

var generator = new Random();
generator.nextInt()

Try tab completion with

BigInteger.probablePrime(100, generator)

Easier to edit previous code than JShell

Import Maven artifact:

addDependency("org.knowm.xchart:xchart:3.5.2");
import org.knowm.xchart.*;
double[] xData = IntStream.range(0, 100).asDoubleStream().map(i -> 2 * Math.PI * i / 100).toArray();
double[] yData = DoubleStream.of(xData).map(x -> Math.sin(x) + Math.cos(2 * x)).toArray();
XYChart chart = QuickChart.getChart("Sample Chart", "x", "y", "y(x)", xData, yData);

What is displayed? Why?

Lab: Notebooks (Continued)

.png

Try
```
chart
```
Try
```
BitmapEncoder.getBufferedImage(chart)
```
Mouse over BitmapEncoder. What happens?

Add a cell above with

import java.awt.image.BufferedImage;
import javafx.scene.image.ImageView;
import javafx.embed.swing.*;

void show(BufferedImage bi) {
    ImageView iv = new ImageView();
    var fxi = SwingFXUtils.toFXImage(bi, null);
    iv.setImage(fxi);
    display(iv);
}

and change the last cell to

show(BitmapEncoder.getBufferedImage(chart))

Have a look at some of the examples on Github
Lab: Using tablesaw, read in this CSV file and make an xy plot of areas vs. populations, labeling each point.

Lab: Jupyter Notebooks

.png

Jupyter notebook server displays web UI
“Kernels” for various languages: Python, R, Julia, Java, ...
Multiple incompatible Java “kernels”: IJava (outdated), JJava, Ganymede, Rapaio

Install kernel locally with jbang:

jbang install-kernel@jupyter-java jjava

Python/Jupyter installation can be fussy—easier in VS Code
Add the Python and Jupyter extensions from ms-toolsai
File → New → Jupyter notebook
Select java (JJava/j!) kernel in top right corner
Try some Java and autocomplete:
```
TimeZone.getAv // Hit Tab now
```
Ugh, try
```
TimeZone.availableIds().toList()
```

Use Maven “magic”

%maven org.knowm.xchart:xchart:3.5.2

followed by

import org.knowm.xchart.*;
import java.util.stream.*;
double[] xData = IntStream.range(0, 100).asDoubleStream().map(i -> 2 * Math.PI * i / 100).toArray();
double[] yData = DoubleStream.of(xData).map(x -> Math.sin(x) + Math.cos(2 * x)).toArray();
XYChart chart = QuickChart.getChart("Sample Chart", "x", "y", "y(x)", xData, yData);
BitmapEncoder.getBufferedImage(chart)

Note that the BufferedImage is displayed

Notebook Sharp Edges

.jpg

Java Jupyter support is not on par with Python
Numpy equivalent? Maybe tablesaw? DFLib? dataframe-ec?
Matplotlib equivalent? Maybe charts? ECharts Java? chart-fx?

Try this in VS Code:

%maven org.dflib:dflib-jupyter:2.0.0-M7
import org.dflib.*;
import org.dflib.echarts.*;

DataFrame df = DataFrame.foldByRow("name", "salary").of(
                "J. Cosin", 120000,
                "J. Walewski", 80000,
                "J. O'Hara", 95000);

var chart = ECharts
        .chart()
        .xAxis("name")
        .series(SeriesOpts.ofBar(), "salary")
        .plot(df);
chart

Does the chart show up? As image?

IntelliJ supports Jupyter notebooks
- With good autocompletion, debugging
- But so far only for Python and Kotlin
Can share notebooks e.g. at https://colab.research.google.com/

Jupyter Java Anywhere: (https://github.com/jupyter-java/anywhere):

!pip install jbang # change to pip3 if pip command not found
import jbang
jbang.exec("trust add https://github.com/jupyter-java")
print(jbang.exec("install-kernel@jupyter-java --java 25 --enable-preview").stdout)

Lab: Try out Google Colab, Binder, Github. Can you get text to work? A chart?
- Today, for Google Colab, you need to prepend
```
import os
os.environ["JAVA_TOOL_OPTIONS"] = "-Xlog:os+container=off"
```
- And select the Java (JJava-j!)-tcp kernel
- And hope for the best

The End

.jpeg

Modern Java features (no class files, no psvm) and powerful API make scripting a breeze
When the API needs help, use JBang and //DEPS or look for simple one-file solutions
For exploration, Java/Jupyter notebooks are getting there
Thank you!
🤔 🙋‍♀️ Final Questions?
Feedback

.png