JFokus 2018 - Framtiden för Java ser ljus ut

26 February 2018 // Johan Kindgren

Årets JFokus har gått av stapeln och denna gång hade (av naturliga skäl) stor fokus på Java 9 och de förbättringar som kom med den nya versionen. Förutom nyheter om Java fastnade jag för föreläsningarna om Kotlin och dess olika användningsområden.

Kotlin

Kotlin har de senaste åren fått mer och mer uppmärksamhet, där Google har valt det som språk för utveckling av appar för Android, Spring Framework har lagt till stöd för det och Gradle jobbar på att byta ut Groovy mot Kotlin. Språket har sin grund i att vara pragmatiskt och skulle man göra en jämförelse med t ex Scala, som är mer akademiskt/matematiskt, känns Kotlin lättare att ta till sig. Jag har själv använt Kotlin tillsammans med Spring Boot och även om det inte skiljer jättemycket i språket så känns det lättare och snabbare att utveckla med Kotlin. Jag kan rekommendera att gå igenom deras tutorial på https://try.kotlinlang.org/ för att få en inblick i hur det ser ut!

Java 9, 10, 11…

Fram till nu har det som bekant gått långsamt att införa nya funktioner i både språket och plattformen. Som Java-utvecklare har man med avund betraktat utvecklingen av andra språk som Scala (och även Kotlin) där man kan släppa nya versioner i egen takt utan större beroende till version av Java. Med Java’s nya strategi att skapa nya versioner var sjätte månad, finns det dock hopp om att snabba på utvecklingen! Planen är att kunna införa nya funktioner i varje release, men var tredje år kommer det att skapas en LTS-version (Long Term Support) där det finns support fram till nästa LTS-version.

Fram till nu har man i stort sett endast infört nya funktioner i plattformen, men med den nya strategin ska det även underlätta att städa undan detaljer som av någon anledning bör förändras. I samband med Java 9 har man infört två nya fält i @Deprecated-annoteringen: forRemoval() och since(). Fältet since() ska ange i vilken version av Java som den aktuella klassen/metoden blev Deprecated och fältet forRemoval() sätts till true om nästa release faktiskt kommer att ta bort koden. Det här ger en möjlighet till förbättrade varningar från kompilatorn, beroende på vilken version av Java man använder. Se gärna mer på http://openjdk.java.net/jeps/277

Mark Reinhold (Chief Architect, Java Platform Group) höll en föreläsning om vad som kommer att utvecklas framöver och det fanns en hel del intressanta projekt som är “på gång”.

Local variable type inference

Typ-inferens av lokala variabler är en av de få syntax-mässiga ändringar som kommer med Java10. Man kan tänka att det inte skulle ge någon större inverkan på språket, men det är ett bra exempel på nyheter som förenklar språket. Läsbarheten ökar betydligt när man jämför följande exempel:

URL url = new URL("http://www.callistaenterprise.se");
URLConnection conn = url.openConnection();
Scanner scanner = new Scanner(conn.getInputStream(), "UTF-8");

var url = new URL("http://www.callistaenterprise.se");
var conn = url.openConnection();
var scanner = new Scanner(conn.getInputStream(), "UTF-8");

Records

I alla applikationer finns det klasser som endast används för att bära information och det innefattar ganska ofta en hel del “boilerplate”-kod. Scala har “case class”, Kotlin “data class” och med Lombok kan man annotera en klass med @Data för att åstadkomma något liknande i Java. Ett av förslagen är att lägga till en ny typ av klasser som skulle kallas “record”, som skulle generera en icke-muterbar klass med hashcode-, equals- och toString-metoder för samtliga fält.

record Point(double x, double y);

Switch expression

Nästa förslag på temat innebär att switch-statement skulle göras om så att det blir ett expression, vilket innebär att man kan tilldela variabler direkt från switch-satsen. Detta i kombination med Pattern Matching skulle ge ganska stora förändringar på hur koden kan se ut. Ett exempel kan ge en fingervisning av vad man kan vänta sig inom några år:

Nuvarande

String formatted = "unknown";
if (obj instanceof Integer) {
    int i = (Integer) obj;
    formatted = String.format("int %d", i);
}
else if (obj instanceof Byte) {
    byte b = (Byte) obj;
    formatted = String.format("byte %d", b);
}
else if (obj instanceof Long) {
    long l = (Long) obj;
    formatted = String.format("long %d", l);
}
else if (obj instanceof Double) {
    double d = (Double) obj;
    formatted = String.format(“double %f", d);
}
else if (obj instanceof String) {
    String s = (String) obj;
    formatted = String.format("String %s", s);
}

Switch expression

String formatted = switch (obj) {
    case Integer i -> String.format("int %d", i);
    case Byte b    -> String.format("byte %d", b);
    case Long l    -> String.format("long %d", l);
    case Double d  -> String.format(“double %f", d);
    case String s  -> String.format("String %s", s);
    default:       -> obj.toString();
}

Observera att syntax inte är fastslagen, så det kan komma att ändras.

Se mer på http://openjdk.java.net/projects/amber/

Mark Reinhold nämnde även Project Valhalla som innebär en förbättrad hantering av data, så att man kan optimera minneshantering i hårdvara. Troligtvis skulle detta göra att man kan utnyttja processorns cache på ett mer effektivt sätt, med bättre prestanda. Se mer på http://openjdk.java.net/projects/valhalla/ och http://openjdk.java.net/jeps/169

Den fortsatta utveckling innebär både att skriva om kompilatorn och hela JDK’n i Java. Han nämnde att dagens JIT-kompilator består av en stor mängd C-kod, som är över tio år gammal, och när Switch expression och Project Valhalla har implementerats skulle man kunna göra en hel del förenklingar i både kompilator och JDK. Det här verkar dock vara ett antal år fram innan det kommer upp i prioriteringen som det ser ut just nu. Jag kan rekommendera att ta en titt på Marks föredrag från JFokus Moving Java forward faster.

Även om Java nu kommer att släppa nya versioner oftare så finns det ingen garanti för när utvecklingen är klar, men det känns som att det finns många bra funktioner som vi hoppas blir tillgängliga framöver. Framtiden för Java ser ljus ut!