Ist Java das neue Cobol? Die Flut neuer JVM-Sprachen hält dem eindrücklich die Leistungsfähigkeit und Modernität der Plattform entgegen. Insbesondere für den industriellen Einsatz gibt es neue Kandidaten, die wir genauer betrachten wollen. Dabei lernen wir viele Innovationen und Features rund um eine robustere und effizientere Entwicklung kennen. Code-Beispiele und Hintergrundinformationen über Tooling und Projekt helfen bei der kritischen Betrachtung. Ein abschließendes Fazit über ihre Potentiale gibt Orientierung im Dschungel der Neuerungen.
Extended Abstract:
Ein bisschen in die Jahre gekommen ist es ja schon: Java! Vereinzelt eilt ihm schon gar der verbrämende Ruf des "neuen Cobols" voraus. Dabei ist die zugrunde liegende JVM Plattform moderner und hochleistungsfähiger als je zuvor. Sowohl Android als auch die schiere Flut neu aus der Taufe gehobenen JVM Sprachen belegen die beeindruckende Solidität ihres Fundaments.
Zu den frühen, eher Scripting-orientierten Sprachentwürfen sind inzwischen einige statisch-typisierte Dialekte dazu gestoßen, die echtes Potential haben auch für Unternehmensanwendungen als ernste Alternativen zu Java aufzusteigen.
So z.B. Kotlin, welches explizit für den industriellen Einsatz bei 100% Java-Interoperabilität entworfen wurde. Oder das unbekanntere Fantom, das mit JavaScript/.NET-Crosscompiling, semi-statisch-/dynamischer Typisierung und innovativen Multithreading-Unterstützung selbst dem JVM-Urgestein Scala einiges entgegenzusetzen hat.
Wir werfen einen Blick auf diese verschiedenen Sprachen. Dabei betrachten wir insbesondere aus der Perspektive des industrienahen Java-Entwicklers ihre spannenden Kern-Features. Einzelne Code-Fragmente und Gegenüberstellungen sowie Hintergründe und Details zu ihrer Tooling- und Projekt-Landschaft sollen helfen, hier frühe Orientierung im Dschungel der spannenden Neuerungen zu erlangen.
12. Warum neue JVM Sprachen?
12 | Next Generation JVM Languages
13. Von Lambdas und „1. Klasse“-Rechnen
13 | Next Generation JVM Languages
14. Imperativ vs. Funktional: Beispiel #1 Quicksort
public void quicksort(int array[]) {
quicksort(array, 0, array.length - 1);
}
public void quicksort(int array[], int start, int end){
int i = start;
int k = end;
if (end - start >= 1) {
int pivot = array[start];
while (k > i) {
while (array[i] <= pivot && i <= end && k > i) i++;
while (array[k] > pivot && k >= start && k >= i) k--;
if (k > i) swap(array, i, k);
}
swap(array, start, k);
quicksort(array, start, k - 1);
quicksort(array, k + 1, end);
} else {
return;
}
}
public void swap(int array[], int index1, int index2) {
int temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
}
14 | Next Generation JVM Languages
15. Imperativ vs. Funktional: Beispiel #1 Quicksort
public void quicksort(int array[]) {
quicksort(array, 0, array.length - 1);
}
public void quicksort(int array[], int start, int end){
int i = start;
int k = end;
if (end - start >= 1) {
int pivot = array[start];
while (k > i) {
while (array[i] <= pivot && i <= end && k > i) i++;
while (array[k] > pivot && k >= start && k >= i) k--;
if (k > i) swap(array, i, k);
}
swap(array, start, k);
quicksort(array, start, k - 1);
quicksort(array, k + 1, end);
} else {
return;
}
}
public void swap(int array[], int index1, int index2) {
int temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
}
15 | Next Generation JVM Languages
16. Imperativ vs. Funktional: Beispiel #2
int sum = 0;
for (int i = 0; i < 150; i++)
{
if (i % 5 != 0)
sum += i;
}
int sum = Enumerable.Range(0, 150).Where(i => i % 5 != 0).Sum();
f1(
16 | Next Generation JVM Languages
f2(
f3(
f4())))
17. Objektorientierte vs. Funktionale Programmierung
FP
Sammlung von Funktionen
Zustandlos & Unveränderlich
Rekursiv
Auswertung: Lazy
17 | Next Generation JVM Languages
OOP
Sammlung von Objekten
Zustandsbehaftet
Iterativ
Imperativer Ablauf
18. Warum neue JVM Sprachen?
18 | Next Generation JVM Languages
19. Dynamic Typing
Parsen und
Auflisten der Daten
19 | Next Generation JVM Languages
Practically Groovy: Building, parsing, and slurping XML
http://www.ibm.com/developerworks/java/library/j-pg05199/
20. Dynamic Typing
import
import
import
import
org.xml.sax.SAXException;
org.w3c.dom.*;
javax.xml.parsers.*;
java.io.IOException;
public class ParseXml {
public static void main(String[] args) {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
try {
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse("src/languages.xml");
//print the "type" attribute
Element langs = doc.getDocumentElement();
System.out.println("type = " + langs.getAttribute("type"));
//print the "language" elements
NodeList list = langs.getElementsByTagName("language");
for(int i = 0 ; i < list.getLength();i++) {
Element language = (Element) list.item(i);
System.out.println(language.getTextContent());
}
}catch(ParserConfigurationException pce) {
pce.printStackTrace();
}catch(SAXException se) {
se.printStackTrace();
}catch(IOException ioe) {
ioe.printStackTrace();
}
}
}
20 | Next Generation JVM Languages
Parsen und
Auflisten der
Daten
Practically Groovy: Building, parsing, and slurping XML
http://www.ibm.com/developerworks/java/library/j-pg05199/
21. Dynamic Typing
def langs = new XmlParser().parse("languages.xml")
println "type = ${langs.attribute("type")}"
langs.language.each{
println it.text()
}
Parsen und
Auflisten der
Daten
21 | Next Generation JVM Languages
Practically Groovy: Building, parsing, and slurping XML
http://www.ibm.com/developerworks/java/library/j-pg05199/
22. Warum neue JVM Sprachen?
22 | Next Generation JVM Languages
23. Schlankere Syntax : Listen befüllen
List<String> languages = new LinkedList<String>();
languages.add("Java");
languages.add("Ruby");
languages.add("Python");
languages.add("Perl");
stuff = []
stuff << "Java", "Ruby", "Python"
23 | Next Generation JVM Languages
Practically Groovy: Building, parsing, and slurping XML
http://www.ibm.com/developerworks/java/library/j-pg05199/
24. Schlankere Syntax : Getter/Setter
Class Circle
private Coordinate center, float radius;
public void setCenter(Coordinate center){
this.center = center;
}
public Coordinate getCenter(){
return center;
}
public void setRadius(float radius){
this.radius = radius;
}
public Coordinate getRadius(){
return radius;
}
}
class Circle
attr_accessor :center, :radius
end
24 | Next Generation JVM Languages
Practically Groovy: Building, parsing, and slurping XML
http://www.ibm.com/developerworks/java/library/j-pg05199/
25. Warum neue JVM Sprachen?
25 | Next Generation JVM Languages
26. Warum neue JVM Sprachen?
26 | Next Generation JVM Languages
40. Warum neue JVM Sprachen?
40 | Next Generation JVM Languages
41. Dynamic & Weak Typing
l
“A programming language is said to be dynamically typed when the majority
of its type checking is performed at run-time as opposed to at compile-time.
In dynamic typing values have types, but variables do not […]”
https://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing
l
[…] strong typing when it specifies one or more restrictions on how operations
involving values of different data types can be intermixed.
Weak typing means that a language implicitly converts (or casts) types when used.
https://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing
41 | Next Generation JVM Languages
42. Warum neue JVM Sprachen?
42 | Next Generation JVM Languages
44. Auszug neuer JVM Sprachen
Inzwischen über 50-250 verschiedene Sprachen auf der JVM…
44 | Next Generation JVM Languages
45. Anforderungen für den Industriellen Einsatz
–
–
–
–
45 | Next Generation JVM Languages
46. Sprachen im industriellen Einsatz
[...] programming by larger groups of people or by smaller groups over
longer time periods [...] result in large, and hence complicated, programs
[...] place emphasis on partitioning work into modules with preciselyspecified interactions.
http://en.wikipedia.org/wiki/Programming_in_the_large_and_programming_in_the_small
–
–
46 | Next Generation JVM Languages
57. Scala - Implicit Conversion
object A {
implicit def aToB(a: A) : B = {
new B()
}
}
57 | Next Generation JVM Languages
object MainClass {
def main(args: Array[String]) {
val b : B = new A()
}
}
75. Ceylon im Portrait
„Ceylon’s goal is to design the language that Java would have been
if its designers had been able to predict the future.”
–
–
–
–
–
75 | Next Generation JVM Languages
76. Ceylon: Code Example
doc "A component"
shared abstract class Component() {
OpenList<Callable<Void,Event>> observers =
OpenList<Callable<Void,Event>>();
shared void addObserver(void observe(Event event)) {
observers.append(observe);
}
shared void fire(Event event) {
for (void observe(Event event) in observers) {
observe(event);
}
}
}
76 | Next Generation JVM Languages
77. …bisschen Spannendes hat Ceylon aber schon…
l
l
l
77 | Next Generation JVM Languages
http://www.sxc.hu/photo/732192
82. 82 | Next Generation JVM Languages
http://www.sxc.hu/photo/1339625
83. Kotlin im Portrait
“General-purpose language intended for industrial use”
Kotlin = Java++ bzw. Scala--
l
–
–
–
–
–
83 | Next Generation JVM Languages
84. Kotlin Motivation & Hintergrund
“Although we’ve developed support for several JVM-targeted programming languages,
we are still writing all of our IntelliJ-based IDEs almost entirely in Java.
We want to become more productive by switching to a more expressive language.”
l
–
–
–
–
84 | Next Generation JVM Languages
87. Kotlin Sprach-Features
l
l
interface Collection<E> ... {
void addAll(Collection<? extends E> items);
}
abstract class Source<out T> {
fun nextT() : T
}
fun fill(dest : Array<in String>, value : String) {
// ...
}
87 | Next Generation JVM Languages