Small Java

.jpg

Slide navigation: Forward with space bar, →, or swipe left. Backwards with ← or swipe right. Switch slides with PgDn and PgUp.

Slides at https://horstmann.com/presentations/2024/smalljava

About the Speaker

.jpg

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

Why Small Java?

.jpg

Ad-hoc scripts
- Automation
- Exploration
Not Maven/Gradle
Why Java?
- Familiar
- Stable
- Portable
- Compile-time typed
- Vast ecosystem
Why not
- shell
- Python
- Scala

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 21
```
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 21 "$0" "$@" ; exit $?

~/bin/BackupFileFilter.java

Instance Main Methods and Implicit Classes

.jpg

JEP 477

Instance main method:

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

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

Implicit class: 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
Automatic import of println, print, readln (since Java 23)
Entire java.base module is imported
Saves a few lines, maybe gives a Pythonic vibe
~/bin/Audio.java and its shell predecessor ~/bin/audio

Helpful Language Features

.jpg

Records are your friend
Python programs often use ad-hoc lists, dicts for “data carrier” objects
In Java, cost of giving a name is very low:
```
record Brick(Point p, Point q)
```
Free toString, equals, hashCode

Natural point for adding related methods:

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

Don't fear static imports:

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

out.println(sqrt(PI));

enum
var, diamond
Text blocks (to keep data with the code)
Tip: Prefer lists over arrays to avoid painful refactoring
Unhelpful: Modules 🤣

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
Streams: Nice when used with restraint
Processes: fine
HTTP client/server: ok
XML: serviceable
Missing in action:
- JSON
- CLI arg parsing
Missing in action: Adding Maven libraries
I sometimes use single-file libraries: Essential JSON, JArgs
~/books/cji4/katacoda/MakeLab.java and Json.java

Checked Exceptions

.jpg

Checked exceptions can be heavyweight in simple scripts
Often ok to terminate script with stack trace
Just add throws Exception to each method that throws a checked exception
Including main
Wouldn't it be nice if all methods of implicit classes did that?

Still painful in lambda expressions:

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

Ugh, need

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

“Sneaky throw” uses hole in Java type system:
```
paths.stream().map(sneaky(Files::readString))
```
E.g. https://github.com/ciechanowiec/sneakyfun/

File Organization

.png

Don't use a barebones text editor
You want code completion, instant error display
Middle-weight code editor with LSP: VS Code, Emacs, vim
- Open VS Code
- Visit ~/bin
- Open Audio.java
Work well without src/main/java project hierarchy
You can coax your heavy-weight IDE into simple file hierarchy
- Open IntelliJ
- Make a new project at ~/books/cji4/katacoda
- Menu → Project structure... → Modules
- Remove the “content root”
- Add parent as “content root”
- Mark as Sources
- Open MakeToc.java

Graal

.jpg

Graal (https://www.graalvm.org) compiles (slowly) to native image:
```
javac WinMove.java
native-image WinMove
./winmove
```

Native images start up faster:

$ time ./winmove move r
real 0m0.298s
$ time java WinMove move l
real 0m0.364s
$ time java WinMove.java move r
real 0m0.790s

Executables aren't small:

$ ls -lh winmove
-rwxrwxr-x 1 cay cay 15M Aug 29 21:12 winmove

JShell

.jpeg

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

Pattern attributePattern = Pattern.compile("^\t(?<name>[A-Z][^:]*): (?<value>.*)$");
var line = "\tActive Port: analog-input-mic";
attributePattern.matcher(line)

$3.matches()
$3.group("name")

A bit awkward with longer code
Some IDEs include JShell (poorly)
Could be used for scripting, but Oracle discourages it
Out of the box not easy to experiment with third party libraries
But check out this hack: https://advancedweb.hu/using-external-libraries-in-jshell/

jshell-resolve tech.tablesaw:tablesaw-core:0.43.1

import tech.tablesaw.api.*;
Table.read().url("https://raw.githubusercontent.com/gmsharpe/edumore/master/data/elections.csv")

JBang

.png

Shell scripts for Java ≥ 8

///usr/bin/env jbang "$0" "$@" ; exit $?

Killer feature: Maven dependency declarations as comments:
```
//DEPS org.eclipse.angus:jakarta.mail:2.0.3
```

Flags as comments:

//COMPILE_OPTIONS ...
//RUNTIME_OPTIONS ...

Export to JAR or fat JAR
```
jbang export fatjar mail/MailTest.java
```

Native image

sdk use java 21.0.2-graalce
jbang export native MakePassword.java

Templates
```
jbang init --template=cli Demo.java
```
Launch JShell with dependencies
```
jbang --interactive mail/MailTest.java
```

Launch an editor in a sandbox with symlinks

jbang edit -b --live --verbose --open=emacs Demo.java

Launch debugger on given port
```
jbang --debug=*:9999 Demo.java
```
And more: https://www.jbang.dev

Jupyter Notebooks

.webp

For interactive, explorative programming
Code cells, visual output of tables and graph, sliders, ...
Can run locally or share 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 21 --enable-preview").stdout)

Example: graph:

%maven org.knowm.xchart:xchart:3.5.2
import org.knowm.xchart.*;
double[] xData = new double[] { 0.0, 1.0, 2.0 };
double[] yData = new double[] { 2.0, 1.0, 0.0 };
XYChart chart = QuickChart.getChart("Sample Chart", "X", "Y", "y(x)", xData, yData);
BitmapEncoder.getBufferedImage(chart)

Local Jupyter
```
cd ~/presentation
jupyter notebook
```
Load chart.ipynb
Colab
Visit https://colab.research.google.com/github/jupyter-java/anywhere/blob/main/getting-started.ipynb
Runtime → Change runtime type → Runtime type dropdown

Experimental Notebooks

.jpg

Java Jupyter support is not on par with Python
Multiple incompatible Java “kernels”: IJava, JJava, Ganymede, Rapaio
Numpy equivalent? Maybe tablesaw?
Matplotlib equivalent? Maybe ChartFX???
Jupyter notebooks are not perfect
Poor code completion, error reporting
Out of order execution
Weird JSON code format, hard to diff
Experimental jnotebook renders JShell files to HTML
```
./jnotebook.jar server
```
Browse http://localhost:5002 Edit ~/presentation/notebooks/hello_world.jsh
JTaccuino is a JavaFX app with Jshell cells
```
cd ~/temp/jtaccuino
./gradlew run
```
Load ~/presentation/jtaccuino-demo.ipynb

Java in the Browser

.gif

Remember applets?
All browsers used to have a sandboxed Java runtime
The sandbox died when the security model proved insufficient
Now, all browsers can run WASM
WASM runtime not a great match for Java
- No GC (yet)
- No threads
But some projects try anyway
- TeaVM
- CheerPJ
Demo: https://reportmill.com/SnapCode/app/

The End

.jpeg

Java is surprisingly good in the small
Standard library: Batteries mostly included
Language: Recent features focus on this use case
Editor/IDE support: So much better than the alternatives without compile-time typing
Weak point: Third-party library integration
JBang to the rescue
Watch out for notebooks
Java may return to the browser
Questions?