address - Java Forum Stuttgart

Transcription

Das nächste große Ding
Programmiersprachen für die JVM
MATHEMA Software GmbH
Henkestraße 91
91052 Erlangen
[email protected]
www.mathema.de
Das nächste große (Java-)Ding
Copyright © 2011, MATHEMA Software GmbH
Folie 1 von 42
Was Sie erwartet
●
Was ist eine große Programmiersprache
●
Was Java richtig macht
●
Was Java nicht richtig gemacht hat
●
Was Java besser machen müsste
●
Was die nächste große Sprache richtig machen muss
Folie 2 von 42
Was Sie nicht erwartet
●
●
Ein Vergleich von Java mit anderen Programmiersprachen
Ein Überblick über die coolen Features der anderen Sprachen,
die Java leider nicht hat
●
Ein Vorschlag für eine neue Sprache
●
Bilder
Folie 3 von 42
Was ist eine große Programmiersprache?
Folie 4 von 42
Beispiele für große Programmiersprachen
●
C
●
Pascal?
●
C++
●
Modula?
●
Java
●
Visual Basic
●
C#
●
Scala?
●
Fortran?
●
Perl
●
Cobol
●
Ruby
●
PL/I
●
Python
●
Algol?
Folie 5 von 42
Eigenschaften einer großen Sprache
●
Eine große Sprache ist …
●
und hat ein Ökosystem mit …
●
wichtig
●
Werkzeugen
●
weit verbreitet
●
Bibliotheken
●
berufsentscheidend
●
Büchern
●
etabliert
●
Schulungen
●
Konferenzen
●
Web-Seiten
●
…
Folie 6 von 42
Das nächste große Ding
●
●
●
Läuft auf der JVM …
… und vielleicht noch auf anderen VMs
Konkurriert mit Java …
… und vielleicht noch mit C#
Ersetzt Java …
… und macht noch andere überflüssig
Folie 7 von 42
Was Java richtig gemacht hat
Folie 8 von 42
Motivation für Java
●
robust
●
sicher
●
architekturneutral
●
portierbar
●
interpretierbar
●
nebenläufig
●
dynamisch
Folie 9 von 42
Zeitgeist (vor fünfzehn Jahren)
●
Virtuelle Maschine
●
Objektorientierung
●
Packages
●
Threads
●
Garbage Collection
●
Sandbox
●
Protection Domains
Folie 10 von 42
Fliegender Start
C++, aber …
●
ohne Redundanz
●
ohne Komplexität
●
ohne (Speicher-)Fehler
●
vertraute Syntax
●
einfach erlernbar
Folie 11 von 42
Typische Java-Entscheidungen …
●
Wohldefinierte Basistypen (insbesondere boolean und String)
●
Sichere Arrays
●
Keine vorzeichenlose Zahlen
●
Kein typedef
●
Keine Strukturen, Unions, Enums und Funktionspointer
●
Kein Präprozessor (und Header-Dateien)
●
Keine Mehrfachvererbung
●
Kein Überladen von Operatoren
●
Kein goto
●
Keinen direkten Zugriff auf Speicher
Folie 12 von 42
●
Statische Typisierung
●
Interfaces
●
Packages
●
Checked Exceptions
●
Unicode
●
Reflection
●
Multi-Threading
Folie 13 von 42
●
Byte-Code-Verifier
●
Strong Typing
●
Sichere Arrays
●
Garbage Collection
●
Memory Model
… mit Konsequenzen
●
Technologie-Sprung
●
Performanz-Steigerung
●
Dynamische Flexibilität
Folie 14 von 42
Kontrovers: Checked Exceptions
try {
write(buffer, offset, length);
} catch (IOException e) {
// ignore
}
Stephen Colebourne:
●
Theoretisch eine gute Idee
●
Praktisch unbrauchbar
●
●
Code kann nicht wissen, ob der Aufrufer die Ausnahme behandeln
kann
Misslungenes Experiment
Folie 15 von 42
Mangelnde Uniformität
public void doItWith(boolean b) { … }
public void doItWith(byte b) { … }
public void doItWith(short s) { … }
public void doItWith(int i) { … }
public void doItWith(long l) { … }
public void doItWith(float f) { … }
public void doItWith(double d) { … }
public void doItWith(char c) { … }
public void doItWith(Object o) { … }
Folie 16 von 42
Bedenklicher Variantenreichtum
int n = array.length;
Integer[] integers = new Integer[…];
Number[] numbers = integers;
numbers[i] = Double.valueOf(0.3);
Folie 17 von 42
Unnütze Objekteigenschaft
private static final Object LOCK = new Object();
public void doIt() {
synchronized (LOCK) {
…
}
}
Folie 18 von 42
Versteckte Schwächen
public class Base {
public static void doIt(String s) { … }
}
public class Derived extends Base {
public static void doIt(String s) { … }
}
Folie 19 von 42
Entscheidungsprobleme
class Num {
public double add(Integer i, double d) { … }
public double add(int i, Double d) { … }
}
Num num = new Num();
Short s = 6;
Double d = 1.2;
num.add(s, d);
Folie 20 von 42
Evolution
●
Primäre Weisung
●
●
Rückwärtskompatibilität
Sekundäre Weisung
●
Das „Java-Feeling“ sichern
●
Die „konzeptionelle Integrität“ sichern
Folie 21 von 42
Problembeispiele
●
●
Probleme mit Generics
●
Primitive Datentypen
●
Arrays
●
Variable Argumentenliste
●
Methodenauflösung
Probleme mit Closures
●
Primitive Datentypen
●
Arrays
●
Checked Exceptions
●
Methodenauflösung
Folie 22 von 42
Kleine Änderungen
●
„foreach“ auch für Maps
●
Elvis-Operator
●
switch-break-Fix
●
Abfangen von „unmöglichen“ Checked Exceptions
Folie 23 von 42
Größere Änderungen
●
Properties
●
Steuerungsstrukturen
●
Bessere Generics
●
Traits
●
Continuations
●
Design by Contract
●
Nullable Types
●
Immutability
●
Values
Folie 24 von 42
Wunschliste …
●
Properties (Beans)
●
Immutability
●
Factory/Dependency Injection
●
Aspects
●
Logging
●
Reflection
●
Looping
●
Multi-Threading
●
Managed Resources
●
Module
Folie 25 von 42
Wunschliste
●
Performanz
●
„Beliebige“ Literale
●
Standard Scoping (public, protected, private et al.)
●
Operator Overloading
●
Build
●
Test
●
…
Folie 26 von 42
Entrauschung
public class Person {
private String surname;
private String forename;
private List<Address> addresses = new ArrayList<Address>();
public String getSurname() { ... }
public void setSurname(String surname) { ... }
public String getForename() { ... }
public void setForename(String forename) { ... }
public List<Address> getAddresses() { ... }
}
public List<Address> getAddresses(String type) {
List<Address> filtered = new ArrayList<Address>();
for (Address address : addresses) {
if (address.getType().equals(type)) {
filtered.add(address);
}
}
return filtered;
}
Folie 27 von 42
Entrauschung (ohne Satzzeichen)
private String surname
private String forename
private List<Address> addresses = new ArrayList<Address>()
}
List<Address> filtered = new ArrayList<Address>()
filtered.add(address)
}
}
return filtered
}
Folie 28 von 42
Entrauschung (ohne Getter/Setter)
public String surname
public String forename
public List<Address> addresses = new ArrayList<Address>()
if (address.type.equals(type)) {
}
}
return filtered
}
}
Folie 29 von 42
Entrauschung (public als default)
class Person {
String surname
String forename
List<Address> addresses = new ArrayList<Address>()
List<Address> getAddresses(String type) {
}
}
return filtered
}
}
Folie 30 von 42
Entrauschung (List-Typ, Typ-Inferenz)
class Person {
String surname
String forename
Address[] addresses = []
Address[] getAddresses(String type) {
var filtered = Address[]
}
}
return filtered
}
}
Folie 31 von 42
Entrauschung (vernünftige Operatoren)
class Person {
String surname
String forename
var filtered = Address[]
if (address.type == type) {
}
}
return filtered
}
}
Folie 32 von 42
Entrauschung (Schleife …)
class Person {
String surname
String forename
var List<Address> filtered = Address[]
if (address.type == type) {
}
}
return filtered
}
}
Folie 33 von 42
Entrauschung (… durch Filter ersetzen)
class Person {
String surname
String forename
return addresses.filtered(#(address) {address.type == type})
}
}
Folie 34 von 42
Entrauschung (Satzzeichen)
class Person {
String surname
String forename
return addresses.filtered #(address) {address.type == type}
}
}
Folie 35 von 42
Entrauschung (nur zur Erinnerung)
private String surname;
private String forename;
private List<Address> addresses = new ArrayList<Address>();
}
List<Address> filtered = new ArrayList<Address>();
filtered.add(address);
}
}
return filtered;
}
Folie 36 von 42
Der abschließende Blick in die Glaskugel
Folie 37 von 42
Zeitgeist (heute)
●
●
Sprachorientierte Programmierung
(Language Oriented Programming)
Unveränderlichkeit
(Immutability)
●
Funktionale Programmierung
●
Nebenläufigkeit und Parallelität
●
Auf jeden Fall so eine Art Paradigmenwechsel
Folie 38 von 42
Aber …
Das am besten geeignete Mittel
ist meist
das am besten geeignete Mittel
Folie 39 von 42
Meine ganz persönliche Prognose
●
Keine Limitierung durch den Zeichensatz
●
Einheitliche, nachladbare Syntax
●
Beliebige, nachladbare Paradigmen
●
Repository
Folie 40 von 42
Vielen Dank!
Folie 41 von 42
Refernzen
Diese „Liebeserklärung“ an Java wurde von dem Vortrag „The Next Big JVM
Language“, den Stephen Colebourne im September 2010 auf der JavaOne
gehalten hat, inspiriert.
Ein diesbezüglicher Blog-Eintrag von Stephen Colebourne findet sich unter
http://www.jroller.com/scolebourne/entry/the_next_big_jvm_language1
oder im KaffeeKlatsch:
Stephen Colebourne
Die nächste große JVM-Sprache
Ideen und Gedanken eines Java-Entwicklers
KaffeeKlatsch 02/2011, Bookware, Erlangen, Februar 2011
http://www.bookware.de/kaffeeklatsch/archiv/KaffeeKlatsch-2011-02.pdf
Das Beispiel für die Entrauschung stammt aus obigem Vortrag von Stephen
Colebourne, das sich an der von ihm befürworteten Sprache Fantom
http://fantom.org
orientiert.
Folie 42 von 42

address - Java Forum Stuttgart

Transcription

Documents pareils

Anmeldeformular Allgemein

Senior Support Engineer

Antrag auf Rückerstattung der Quellensteuer auf

KURZANLEITUNG IP Motorzoom Boxkamera SNC-3322

Anmeldung Comic-Sondereditionen

ue07_120_saetze_unre..

Sardinien - Die schönsten Motorradtouren Buch

Arab Republic of Egypt