RoboVM erreicht Version 1.0

RoboVM erlaubt es, Java-Anwendungen für iOS und auch Android zu compilieren.

Ankündigung unter http://robovm.com/robovm-1-0-released-commercial-licenses-a-look-under-the-hood/.

Gegenüber der alten Version:

  • The debugger has received another round of updates. All JDWP functionality is now implemented.
  • Support for RAM disk caches. This can help speed up the compilation and linking process on slow HDDs.
  • Support for HFS+ file compression. All files put into the cache are now compressed, further speeding up the compilation process and reducing the amount of space used for the RoboVM cache.
  • Initial project template and Maven archetype support.
  • A new Eclipse project wizard, using the templates project
  • Support for invoking tools via robovm.xml. We currently support the TextureAtlas tool, with more to come.
  • Cleanup and simplification of Objective-C bindings, see the binding status page

Neu ist eine kommerzielle Lizenz:

Our commercial license scale with the size of your business, covering solo developers, startups, SMEs and big enterprises. Depending on your plan, you’ll get access to the following features and services:

  • JDWP compliant debugger for both simulator and on-device debugging
  • Improved crash reporting
  • Private e-mail support, with and without SLA
  • JavaFX support
  • Hotfix support
  • Alpha channel access to new commercial features

Offtopic: Praktikumsstellen verfügbar

Die Digitale Erlebnis-Center GmbH beschäftigt sich seit April 2011 intensiv mit dem Aufbau eines PC-/und Spiel-Konsolen-Museums.

Aufgaben

- Gestaltung und Entwurf interaktiver Oberflächen unter Berücksichtigung existierender Frameworks
- Auswahl und Integration von Emulatoren für Computer und Spiel-Konsolen in der musealen Gestaltung
- Recherchetätigkeiten und Erstellung von Texten über Hardware und Software

Qualifikation

- Kreativität und eine hohe Internetaffinität, praktische Erfahrung in HTML, CSS3, JavaScript. Java ist von Vorteil
- Praktische Erfahrung in Linux, Windows und grundlegender Systemkonfiguration
- Systematische, strukturierte und selbstständige Arbeitsweise mit hohem Qualitätsbewusstsein
- Team- und Kommunikationsfähigkeit, gut und sicher im Ausdruck
- Hintergrundwissen über Computer der 1980er Jahre und der Computerspielszene sind von Vorteil

Wir bieten

- Freundliche Arbeitsatmosphäre und Unterstützung bei beruflicher und persönlicher Weiterentwicklung
- Eigenverantwortliche Gestaltung des Aufgabenbereichs unter Einbringung eigener Präferenzen
- Freie Arbeitszeitgestaltung durch Heimarbeit
- Das Praktikum wird gering vergütet

http://www.meinpraktikum.de/praktikum/digitales-erlebnis-center-gmbh/jobs/praktikum-im-computer-konsolen-museum

Heute feiern wir …

… den Pi-Day (https://de.wikipedia.org/wiki/Pi-Tag).

Er findet jedes Jahr am 14. März statt und geht zurück auf die US-amerikanische Datumsschreibweise 3/14 oder die ISO-Schreibweise -3-14, denn der numerische Wert von π auf zwei Dezimalen gerundet ist 3,14. Besonders genaue Anhänger dieses Tages feiern um 1 Uhr 59 und 26 Sekunden und erreichen die Kreiszahl damit bis zur siebten Nachkommastelle, 3,1415926. Im Jahr 2015 wird Pi um 9 Uhr 26 und 53 Sekunden sogar das erste mal, durch die Passende 15 der Jahreszeit bis zur neunten Nachkommastelle erreicht.

JDK 8u40 freigegeben

http://www.oracle.com/technetwork/java/javase/8u40-relnotes-2389089.html.

Und es sind interessante Neuerungen dabei.

The endorsed-standards override mechanism and the extension mechanism are deprecated and may be removed in a future release. There are no runtime changes. Existing applications using the ‘endorsed-standards override’ or ‘extension’ mechanisms are recommended to migrate away from using these mechanisms. To help identify any existing uses of these mechanisms, the -XX:+CheckEndorsedAndExtDirs command-line option is available.

Grund dafür ist das neue Modulsystem,was in Java 9 kommt.

Und:

Starting with JDK 8u40 release, JavaFX controls are enhanced to support assistive technologies, meaning that JavaFX controls are now accessible. In addition, a public API is provided to allow developers to write their own accessible controls.

JDK 8u40 release includes new JavaFX UI controls; a spinner control, formatted-text support, and a standard set of alert dialogs.

Viele Bugs wurden gefixt: http://www.oracle.com/technetwork/java/javase/2col/8u40-bugfixes-2423829.html

Average number of lines per method in the JDK

The JDK itself can help us to count the lines of code, we just need to parse the source and get the method bodies in a String representation–then we can count the lines. A quick statistic from the new Java 8 Stream API will give us the numbers.

Code first:

import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.*;
import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import com.sun.source.tree.CompilationUnitTree;
import com.sun.source.tree.MethodTree;
import com.sun.source.util.JavacTask;
import com.sun.source.util.TreeScanner;

public class AverageNumberOfLinesInJDKFinder {
  public static void main( String[] args ) throws IOException {

    String[] files = findAllJavaSourceFiles( "C:/Program Files/Java/jdk1.8.0/src/" );
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

    try ( StandardJavaFileManager fileManager = compiler.getStandardFileManager( null, null, null ) ) {
      CompilationTask task = compiler.getTask( null, fileManager, null, null, null,
                                               fileManager.getJavaFileObjects( files ) );

      JavacTask javacTask = (JavacTask) task;
      Iterable<? extends CompilationUnitTree> trees = javacTask.parse();

      LineCountingVisitor lineCountingVisitor = new LineCountingVisitor();
      for ( CompilationUnitTree compilationUnitTree : trees )
        compilationUnitTree.accept( lineCountingVisitor, null );

      DoubleSummaryStatistics stats = lineCountingVisitor.numberOfLines.stream().mapToDouble( d -> d ).summaryStatistics();
      System.out.println( stats );
    }
  }

  static String[] findAllJavaSourceFiles( String base ) throws IOException {
    final List<String> result = new ArrayList<String>();

    Files.walkFileTree( Paths.get( base ), new SimpleFileVisitor<Path>() {
      @Override
      public FileVisitResult visitFile( Path path, BasicFileAttributes attribs ) {
        if ( path.toString().endsWith( ".java" ) )
          result.add( path.toString() );
        return FileVisitResult.CONTINUE;
      }
    } );
    return result.toArray( new String[result.size()] );
  }
}

class LineCountingVisitor extends TreeScanner<Void, Void> {
  final List<Integer> numberOfLines = new ArrayList<Integer>( 2048 );

  @Override
  public Void visitMethod( MethodTree node, Void p ) {
    if ( node.getBody() != null ) {
      int lines = new StringTokenizer( node.getBody().toString(), "\n" ).countTokens() - 1 /* { */ - 1 /* } */;
      if ( lines != 0 ) // ignore empty bodies
        numberOfLines.add( lines );
    }
    return super.visitMethod( node, p );
  }
}

Result:

DoubleSummaryStatistics{count=84695, sum=576427,000000, min=1,000000, average=6,805915, max=1716,000000}

Exercise for the readers:

  • Analyse different open source products and post the results here.
  • Generate a SVG with the lines of code.
  • Change the calculation so we not only get the arithmetic mean but also the geometric and harmonic mean.
  • Sort the result by package, are there differences?
  • Recognize the @since Javadoc tag and try to find out if the number of lines change over time.
  • How about the line size?

number-of-lines-jdk

Avatar verabschiedet sich

Mal wieder geht ein Java-Oracle-Projekt den Bach runter, dieses mal Avatar/Avatar.js (Quelle https://blogs.oracle.com/theaquarium/entry/project_avatar_update).

https://avatar-js.java.net/, https://avatar.java.net/

Avatar ist/war eine Art Node.js Implementierung in JavaScript auf der JVM.

http://nodyn.io/ ist eine spannende Altarnative, läuft aber auf einer eigenen JavaScript-Umgebung namens DynJS, nicht auf Nashorn.

Java Interfaces mit main-Methode

Statische Schnittstellenmethoden erlauben eine neue Möglichkeit zur Deklaration der main(…)-Methode:

interface HelloWorldInInterfaces {

  static void main( String[] args ) {

    System.out.println( “Hallo Welt einmal anders!” );

}

}

Das Schlüsselwort interface ist vier Zeichen länger als class, doch mit der Einsparung von public und einem Trenner ergibt sich eine Kürzung von drei Zeichen – wieder eine neue Möglichkeit zum Längefeilschen.

Java Open Source Libs Januar

Mustache (Apache). Sehr performantes Mustache-Templating-System für Java, benötigt Java 8.

Capsule (EPL). “Dead-Simple Packaging and Deployment for JVM Apps”. Im Kern ein Fat-Jar-Builder. Ermöglicht auch ausführbare WARs und Capsules können in Docker-Images konvertier werden. Alaternativ: One-JAR.

Pegdown Doclet (GPL 3). Markdown in Javadoc-Kommentaren statt HTML nutzen, inklusive PlantUML und Syntax Highlighting mit highlight.js.

The Checker Framework (GLP 2/MIT). Hängt sich in den Java-Compiler und führt zusätzliche Typ-Prüfungen (Null-Pointer, SQL-Injections, …) durch. Funktioniert toll mit Java 8, da nun an jeder Deklaration eine Annotation erlaubt ist.

Gradle (Apache). Gradle ist Ant in Groovy :)

Offtopic: .NET/C# nun auch Open-Source

Vor einiger Zeit hat MS begonnen die Quellen ihrer Laufzeitumgebung, Bibliotheken und Compiler auf ein Git-Repository (sync mit NET Framework TFS Server innerhalb von Microsoft) zu setzen – ein großartiger Zug! Alles steht unter der MIT-Lizenz.

Zum Einlesen:

Ich freue mich auf die spannenden Entwicklungen aus dem CLR-Lager. Hätte MS diesen Zug schon 10 Jahre früher gemacht, könnte ich gar nicht ausmalen, wie es mit der Verbreitung von Java heute aussehen würde.

UML-Werkzeuge für die Java-Entwicklung

Hier eine Auswahl von Produkten:

§ Enterprise Architect (http://www.sparxsystems.de/) ist ein Produkt von Sparx Systems; es unterstützt UML 2.5 und bietet umfangreiche Modellierungsmöglichkeiten. Für die Business & Software Engineering Edition Standard License sind 599 USD fällig. Eine 30-tägige Testversion ist frei. Das Tool ist an sich eine eigenständige Software, die Integration in Eclipse (und MS Visual Studio) ist möglich.

§ MyEclipse (https://www.genuitec.com/products/myeclipse/) von Genuitec besteht aus seiner großen Sammlung von Eclipse-Plugins, unter anderem auch mit einem UML-Werkzeug. Einblick in das kommerzielle Werkzeug gibt https://www.genuitec.com/products/myeclipse/learning-center/uml/myeclipse-uml2-development-overview/.

§ ObjectAid UML Explorer for Eclipse (http://www.objectaid.com/) ist ein kleines und kompaktes Werkzeug, das Klassen aus Eclipse einfach visualisiert. Es entwickelt sich langsam zu einem größeren kommerziellen Produkt.

§ TOPCASED/PolarSys (http://www.topcased.org/) ist ein umfangreicher UML-Editor für Eclipse.

§ Together (http://www.borland.com/products/together/) ist ein alter Hase unter den UML-Tools – mittlerweile ist der Hersteller Borland bei Micro Focus gelandet. Es gibt eine 30-tägige Demoversion. Die Version 12.7 basiert auf Eclipse 4.4, ist also hinreichend aktuell.

§ Rational Rose (http://www-01.ibm.com/software/de/rational/design.html) ist das professionelle UML-Werkzeug von IBM. Es zeichnet sich durch seinen Preis aus, aber auch durch die Integration einer ganzen Reihe weiterer Werkzeuge, etwa für Anforderungsdokumente, Tests usw.

§ UMLet (http://www.umlet.com/) ist ein UML-Zeichenwerkzeug und geht auf ein Projekt der Vienna University of Technology zurück. Es kann alleinstehende eingesetzt oder in Eclipse eingebettet werden. Auf Google Code liegt der offene Quellcode: https://code.google.com/p/umlet/.

§ Der quelloffene UML Designer (https://obeonetwork.github.io/UML-Designer/) greift auf viele Eclipse-Projekte zurück.

§ UML Lab von yatta (http://www.uml-lab.com/de/uml-lab/).

Viele Werkzeuge kamen und gingen, unter ihnen:

§ eUML2 (http://www.soyatec.com/euml2/) und EclipseUML von Omondo (http://www.omondo.com/) sind Eclipse-basierte UML-Tools. Es gibt ältere freie, eingeschränkte Varianten. eUML2 basiert auf Eclipse 4.3, die letzte Version ist von Dezember 2013. Bei EclipseUML hält das Unternehmen sogar an Eclipse 3.7 fest, und schreibt „Omondo will not anymore deliver builds for Eclipse 4 because it was a technological failure.“

§ ArgoUML (http://argouml.tigris.org/) ist ein freies UML-Werkzeug mit UML 1.4-Notation auf der Basis von NetBeans. Es ist eigenständig und nicht in Eclipse integriertEnde 2011 stoppte die Entwicklung, die letzte Version ist 0.34.

§ NetBeans hatte lange Zeit ein schönes UML-Werkzeug, das jedoch nicht auf die neuen Versionen portiert wurde.

Fehlt was?

null coalescing operator in Java nachbilden

Da null viel zu oft vorkommt, null-Referenzierungen aber vermieden werden müssen, gibt es viel Code der Art: o != null ? o : non_null_o.

Diverse Programmiersprachen bieten für dieses Konstrukt eine Abkürzung über den sogenannten null coalescing operator (Coalescing, zu Deutsch verschmelzend), der geschrieben wird mal als ?? oder als ?:, für unser Beispiel: o ?? non_null_o. Besonders hübsch ist dass bei sequenziellen Tests der Art o ?? p ?? q ?? r, wo es dann sinngemäß lautete: Liefere die erste Referenz ungleich null.

Java-Programmierer kommen nicht zu diesem Glück, können aber tricksen (http://stackoverflow.com/a/28306286/388317):

If there are only two references to test and you are using Java 8, you could use

Object o = null;
Object p = "p";
Object r = Optional.ofNullable( o ).orElse( p );
System.out.println( r );   // p

If you import static Optional the expression is not too bad.

Unfortunately your case with “several variables” is not possible with an Optional-method. Instead you could use:

Object o = null; Object p = null; Object q = "p"; Optional<Object> r = Stream.of( o, p, q ).filter( Objects::nonNull ).findFirst(); System.out.println( r.get() ); // p

Lokale Klassen und effektiv finale Variablen

Im folgenden Beispiel deklariert die main(…)-Methode eine innere Klasse Snowden mit einem Konstruktor, der auf die finale Variable PRISM zugreift:

public class NSA {

public static void main( String[] args ) {

final int PRISM = 1;

int tempora = 2;

tempora++; // (*)

class Snowden {

Snowden() {

System.out.println( PRISM );

// System.out.println( tempora ); // Auskommentiert ein Compilerfehler

}

}

new Snowden();

}

}

Die Deklaration der inneren Klasse Snowden wird hier wie eine Anweisung eingesetzt. Ein Sichtbarkeitsmodifizierer ist bei inneren lokalen Klassen ungültig, und die Klasse darf keine Klassenmethoden und allgemeinen statischen Variablen deklarieren (finale Konstanten schon).

Jede lokale Klasse kann auf Methoden der äußeren Klasse zugreifen und zusätzlich auf die lokalen Variablen und Parameter, die final sind. Das ist die Variable PRISM auf jeden Fall, tempora ist nicht final (tempora++ ist ein Schreibzugriff), und daher führt eine Konsolenausgabe mit println(tempora) auch zu einem Compilerfehler – Eclipse meldet: „Local variable tempora defined in an enclosing scope must be final or effectively final”. Der letzte Teil der Fehlermeldung gibt einen Hinweis auf eine kleine Änderung seit Java 8, dass Variablen nicht zwingend mit dem Modifizierer final ausgezeichnet werden müssen, um final zu sein. Gibt es keinen Schreibzugriff auf Variablen, sind sie effektiv final. Im Beispiel kann das einfach getestet werden: Wird die Zeile (*) mit tempora++; auskommentiert, so ist tempora effektiv final und Snowden kann auf tempora zugreifen.

Liegt die innere Klasse in einer statischen Methode, kann sie keine Objektmethoden der äußeren Klasse aufrufen.

Wichtiges Sicherheitsupdate für Java 7 und 8

Es ist angeraten die Updates zu installieren:

Oracle stuft die Fehler als kritisch ein.

http://www.oracle.com/technetwork/topics/security/cpujan2015-1972971.html