import java.util.List;
public class Prog {
public static void main(String[] args) {
System.out.println(List.of("Hello", "World!"));
}
}Advanced "Java 101"
Java in Education
Who learned Java in
school, university, etc.?
🖐🏾
Java in Education
Java became a cornerstone in CS education because:
the runtime simplified coding (e.g. GC)
explicit types and concepts
well-suited for OOP
widely used
Java as a Hobby
Kids/students/grown-ups learn Java for their hobbies:
home automation
static website generation
game modding
Java as a Second Language
Developers move from other languages to Java:
frontend developers
ML/AI developers
developers from other ecosystems
Java for Beginners
All these learners benefit from:
a simple, straightforward language
a smooth standard library
a powerful runtime
a well-trodden path
Java in Business
Java is successful in business, science, etc. because:
multi-paradigm language
refined programming model
comprehensive standard library
powerful runtime
backwards-compatible evolution
detailed, varied tools
strong, diverse ecosystem
Tension
There’s a tension here:
education benefits from a simple, straightforward Java
professional use benefits from a detailed, diverse Java
To stay relevant in education, Java must have an on-ramp.
On-Ramp
An on-ramp to Java:
small starting set of language constructs,
APIs, and toolsfeatures that allow quick achievements
gradual expansion to the full set
Today
teaching the language
teaching the tools
teaching the concepts
teaching Java
Notes
I’m no teacher/professor
this is inspiration, not instruction
slides at slides.nipafx.dev/teaching-java
(hit "?" to get navigation help)ask questions at any time
Teaching the Language
| Teaching the Language |
| Teaching the Tools |
| Teaching the Concepts |
| Teaching Java |
Language Constructs
Minimal Java code:
imports & visibility
classes & methods
static vs instance
returns & parameters
statements & arguments
Simplification
Beginners should be able to:
start with a minimal set of language constructs
achieve first results quickly
learn as they go without "delearning"
Simplification
Remove requirement of:
String[] argsparametermainbeing staticmainbeing publicthe class itself
System.out(useIOinstead)imports for java.base
Simpler Code
Previews in Java 23 (JEP 477):
// all the code in Prog.java
void main() {
println(List.of("Hello", "World!"));
}imports & visibilityclasses &methodsstatic vs instancereturns & parametersstatements & arguments
Progression
Natural progression:
start with
main()add
String[] argsfor argumentsadd methods to organize code
add fields to share state
explore JDK APIs for more functionality
Ramp up to full language.
Teaching the Tools
| Teaching the Language |
| Teaching the Tools |
| Teaching the Concepts |
| Teaching Java |
Starting (with) Java
To write and run a simple Java program, you need:
a JDK
an editor (IDE?)
javac(build tool? IDE?)java(IDE?)
Simplification
Beginners should be able to run
simple Java programs with
no/fewer/simpler tools!
The Java Playground
Oracle’s Java Platform Group developed the Java Playground:
all you need:
tools: browser
concepts: statements & arguments
but:
limited capabilities
(e.g. no file I/O or network)no persistence
jshell
Java 9 added jshell:
all you need:
tools: JDK,
jshellconcepts: statements & arguments
but:
no syntax highlighting
no (smooth) persistence
no progression
IDE vs Editor
An IDE:
makes a few things easier
is itself a complex tool
is almost certainly unknown to beginners
Maybe not the best tool to introduce early.
IDE vs Editor
VS Code:
is better known
has decent Java capabilities
Single-file Execution
Java 11 added single-file execution (JEP 330):
java Prog.javatools: JDK,
javabut: no progression
Much better for beginners, but just a section of an on-ramp.
Running Multiple Files
If you have a folder:
MyFirstJava
├─ Prog.java
├─ Helper.java
└─ Lib
└─ library.jarRun with:
java -cp 'Lib/*' Prog.javaAdded in Java 22 (JEP 458).
Dependencies
But where do you get dependencies from?
This is an open problem.
Progression
Natural progression:
start experiments in playground
to persist work:
download JDK
move to text editor
start with single source file
split into multiple files when code becomes larger
use visibility & packages to add structure
Ramp up until delivery of artifacts is needed.
Teaching the Concepts
| Teaching the Language |
| Teaching the Tools |
| Teaching the Concepts |
| Teaching Java |
Programming Concepts
Java is a great OOP language.
OOP is a great paradigm for large systems.
But is OOP the best paradigm to learn first?
Object-Oriented Programming
OOP hinges on:
abstraction of the domain through classes
combination of state and behavior
encapsulation and visibility
inheritance (at least of types)
Neither easy nor necessary for simple programs.
Simple Programs
Programming can be immediately useful:
automation
data analysis
visualization
interactive media
Let learners write simple, useful programs!
⇝ Such programs rarely need OOP.
Terminal Interaction
Simple programs usually interact via terminal.
Use IO instead of System.{in|out}:
void print(Object)&void println(Object)to writeString readln(String)to read input
(Auto-imported in a simple source file.)
Focusing on Data
Simple programs often focus on data:
reading data from disk or remote
parsing various data formats
representation of data as types
mass-processing data
visualizing data
writing data to disk or a remote
Reading Local Data
NIO.2 makes reading text files straightforward:
var transactions = Path.of("transactions.csv");
for (var line : Files.readAllLines(transactions)) {
// ...
}Reading Remote Data
HTTP/2 client makes reading remote data
(relatively) straightforward:
var client = HttpClient.newHttpClient();
var request = HttpRequest
.newBuilder(URI.create("http://example.org/"))
.build();
var body = client
.send(request, BodyHandlers.ofString())
.body();Parsing Data
Java has out-of-the-box support for:
XML
😬
Clearly room for improvement!
Representing Data
Records make simple types simple:
record Transaction(
LocalDate date, long cents,
TransactionType type) { }
enum TransactionType { PRIVATE, BUSINESS }Processing Data
for-loops, if statements, etc. are simplest.
But once functions are introduced, streams become available.
Visualizing Data
JavaFX is powerful but not simple to get started with.
Java lacks beginner-level visualization tools.
Writing Data
NIO.2 makes writing data very simple:
var analysis = "...";
var file = Path.of("analysis.txt");
Files.writeString(file, analysis);Progression
Natural progression:
start with simple terminal interaction
use NIO.2 to read and write local data
use HTTP/2 client to access remote data
use records to model data
use common statements to analyze data
potentially upgrade to streams
Go into more OOP as problems get more complex.
Teaching Java
| Teaching the Language |
| Teaching the Tools |
| Teaching the Concepts |
| Teaching Java |
Starting Point
Take first steps in the playground.
To get started "for real":
tools: JDK, text editor
code: simple
mainandIOexecution with
java Prog.java
Progression
need arguments? ⇝ add
String[] argsneed to organize code? ⇝ add methods
need more functionality? ⇝ explore JDK APIs:
e.g. NIO.2 or HTTP/2 clientneed to capture data? ⇝ define records
need shared state? ⇝ add fields
need even more functionality? ⇝ explore simple libraries:
e.g. JavaFX for visualizationneed more structure? ⇝ split into multiple files
even more ⇝ use visibility & packages
Progression
Java can do better is some areas:
managing dependencies without build tool
steering away from outdated APIs
support more data formats out of the box
simplify (data) visualization
Progression
At some point:
a more powerful editor would be helpful ⇝ IDE
testing or delivering becomes necessary ⇝ build tool
Welcome to full Java!
So long…
More
Slides at slides.nipafx.dev⇜ Get my book!
Follow Nicolai
nipafx.dev/nipafx
Follow Java
inside.java // dev.java/java // /openjdk
Image Credits
Advanced "Java 101"
Nicolai Parlog
nipafx.dev
/ @nipafx
betterCode()
#betterCode
Developer Advocate
Java Team at Oracle
Nicolai Parlog
/ nipafx.dev
/ @nipafx
betterCode()
/ #betterCode