tutego

Mit den Closures nach Gilad Bracha, Neal Gafter, James Gosling, Peter von der Ahé.

Innere Klassen, insbesondere anonyme innere Klassen, sind bisher die einzige Möglichkeit, um Programmteile an Methoden zu übergeben. Nehmen wir einen Timer als Beispiel. Dem eigentlichen Zeitgeber muss ein Stücken Code übergeben werden, sodass der Timer weiß, was er zu tun hat. Mit dem Zeitgeber, der Klasse Timer, und der abstrakten Basisklasse TimerTask zur Beschreibung der Aufgaben, ist schnell ein Beispiel programmiert, das wie eine Uhr in jeder Sekunde die Zeit auf dem Bildschirm ausgibt:

public class TimerExample
{
  public static void main( String[] args )
  {
    class MyTimer extends java.util.TimerTask {
      @Override public void run() {
        System.out.println( new java.util.Date() );
      }
    } 
 
    new java.util.Timer().scheduleAtFixedRate( new MyTimer(), 0, 1000 );
  }
}

Für die Beschreibung des Programmcodes ist extra eine eigene Klasse erforderlich. Über eine innere anonyme Klasse lässt sich der Programmcode jedoch noch etwas weiter verkürzen:

 public class TimerExample
{
  public static void main( String[] args )
  {
    new java.util.Timer().scheduleAtFixedRate( new java.util.TimerTask() {
      @Override public void run() {
        System.out.println( new java.util.Date() );
      }
    }, 0, 1000 );
  }
}

Deklaration eines Closures

Ein Closure repräsentiert einen Block Java-Code. Die allgemeine Schreibweise ist

{ formal parameters => statements expression }

Die Schreibweise definiert eine anonyme Funktion. Vergleichen wir einer bekannten Funktionsdeklaration

void out()
{
  System.out.printn("Hallo Welt");
}

mit der Deklaration eines Closures:

{ => System.out.printn("Hallo Welt"); }

Während normale Funktionen mit ihrem Namen aufgerufen werden, steht eine Closure für ein Objekt, welches eine invoke()-Methode anbietet.

public class Closures
{
  public static void main( String[] args )
  {
    { => System.out.println("Hallo Welt"); }.invoke();
  }
}

Aus der allgemeinen Schreibweise

{ formal parameters => statements expression }

lässt sich absehen, dass formale Parameter wie bei normalen Funktionsdeklarationen möglich sind. So lassen sich in den Closure-Block Daten einführen. Vergleichen wir wieder eine Funktions- mit einer Closure-Deklaration:

void quote( String s )
{
  System.out.println("'" + s + "'");
}

Der Closure mit Beispiel:

public class Closures
{
  public static void main( String[] args )
  {
    { String s => System.out.println("'" + s + "'"); }.invoke( "tutego" );
  }
}

Zwei Dinge fallen an dem Beispiel auf:
• Formale Parameter haben einen Typ (links vom Pfeil steht String s ).
• Die invoke()-Funktion nimmt immer so viele Argumente an, wie es formale Parameter in der Closure-Deklaration gibt.

Die Beispiele bisher zeigen Closures, die in ihrem Rumpf eine Anweisung tragen. Closures können aber auch Ausdrücke enthalten.

public class Closures
{
  public static void main( String[] args )
  {
    System.out.println( { int a, int b => (a + b) / 2 }.invoke( 10, 20) );  // 15
  }
}

Im Rumpf endet die Ausdruck nicht mit einem Semikolon, denn es wäre ja auch verboten,

System.out.println( (a + b) / 2; );

zu schreiben.

Ein auffälliger Unterschied zur Funktion ist die fehlende return-Anweisung. Closures selbst sind quasi an die Aufrufstelle eingesetzte Programmteile und ein return würde die Funktion verlassen!

Funktions-Typ

Closures, wie { int a, int b => (a + b) / 2 }, besitzen einen so genannten Funktions-Typ, der durch die Typen der Parameter und der Rückgabe bestimmt ist. Die allgemeine Notation ist

{ formal parameters => return type }

Gibt eine Funktion nicht zurück, so steht rechts vom Pfeil void. Für unsere drei bisherigen Closures sind die Typen:

{ => void }
{ String => void }
{ int, int => int }

Da in einer Funktionsdeklaration ohne Parameter ja auch kein void steht – void out(void) ist falsch – steht auch im ersten Fall links vom Pfeil nichts.
Mit diesem Funktions-Typ lassen sich die Closures ausgezeichnet referenzieren:

{ => void } printHelloWorld = { => System.out.println("Hallo Welt"); }; 
 
{ String => void } printQuoted = { String s => System.out.println("'" + s + "'"); };  
{ int, int => int } avg = { int a, int b => (a + b) / 2 };  
printHelloWorld.invoke();                     // Hallo Welt  
printQuoted.invoke( "tutego" );               // 'tutego'  
System.out.println( avg.invoke( 10, 20 ) );   // 15

Mit diesem Wissen lassen sich Funktionen schreiben, die ein Closure entgegennehmen. Eine Funktion repeat() soll dabei einen Programmcode so oft wie gewünscht aufrufen:

public class Repeater
{
  public static void repeat( int times, { => void } block )
  {
    for ( int i = 0; i < times; i++ )
      block.invoke();
  } 
 
  public static void main( String[] args )
  {
    repeat( 2, { => System.out.println("Hallo"); } );
  }
}

Das Hallo kommt also zweimal auf den Bildschirm.

In der Java-Bibliothek sind nicht alle Funktionen so parametrisiert, so dass Closures als Parameter erlaubt sind. Schreiben wir für den Timer eine eigene Methode scheduleAtFixedRate(), die einen Codeblock entgegennimmt und ausführt:

public class TimerExample
{
  public static void scheduleAtFixedRate( { => void } task, long delay, long period )
  {
    new java.util.Timer().scheduleAtFixedRate( new java.util.TimerTask() {
      @Override public void run() {
        task.invoke();
      }
    }, delay, period );
  }
  public static void main( String[] args )
  {
    scheduleAtFixedRate(
      { => System.out.println( new java.util.Date() ); }
      , 0, 1000 );
  }
}

Mit Closures sind auch Funktionszeiger leicht zu realisieren:

public class FunctionPointerWithClosures
{
  static void invoker( { => void } block )
  {
    block.invoke();
  } 
 
  public static void main( String[] args )
  {
    { => void } method1 = { => System.out.println("Hello www.tutego.com"); };
    { => void } method2 = { => System.out.println("Hallo www.tutego.com"); };  
    invoker( Math.random() > 0.5 ? method1 : method2 );
  }
}

Natürlich lassen sich jetzt die Methoden auch in eine Datenstruktur setzen:

Map<String, { => void }> methods = new HashMap<String, { => void }>();
methods.put( "German",  { => System.out.println("Hallo www.tutego.com"); } );
methods.put( "English", { => System.out.println("Hello www.tutego.com"); } ); 
 
methods.get( "German" ).invoke();  
for ( { => void } method : methods.values() )
  invoker( method );

In ein Feld können Closures nicht gesetzt werden! Der Grund liegt an der internen Generics-Umsetzung.

Nehmen wir an, wir wollen eine Funktion each() schreiben, die einen String mit einem gegebenen Delimiter zerlegt und dann eine Operation auf den einzelnen Token ausführt. Soll weiterhin die Operation einen String zurückgeben, so kann das in herkömmlichem Java etwa so implementiert werden:

class StringUtils
{
  public static interface StringInStringOutBlock
  {
    String execute( String in );
  } 
 
  public static String each( String source, String delimiter, StringInStringOutBlock block )
  {
    StringBuilder result = new StringBuilder();  
    for ( String token : source.split( delimiter ) )
      result.append( block.execute( token ) );  
    return result.toString();
  }
  public static void main( String[] args )
  {
    class QuoterBlock implements StringInStringOutBlock {
      @Override public String execute( String in ) {
        return "'" + in + "'";
      }
    }  
    String s = each( "Hallo Welt!", " ", new QuoterBlock() );
    System.out.println( s );
  }
}

Closures machen das viel kompakter:

class StringUtils
{
  public static String each( String source, String delimiter, { String => String } block )
  {
    StringBuilder result = new StringBuilder(); 
 
    for ( String token : source.split( delimiter ) )
      result.append( block.invoke( token ) );  
    return result.toString();
  }  
  public static void main( String[] args )
  {
    String s = each( "Hallo Welt!", " ", { String in => "'" + in + "'" } );
    System.out.println( s );
  }
}

Closure mit Variablenzugriff

Closures haben einige Eigenschaften, die innere anonyme Klassen so erst einmal nicht haben. Eine davon ist, dass ein Closure-Block auf auch nicht-finale Werte lesend und schreiben zugreifen kann.

int i = 0;
repeat( 3, { => System.out.println(i); } );   // 0 0 0 
 
@Shared int j = 0;
repeat( 3, { => System.out.println(j++); } ); // 0 1 2
System.out.println( j );                      // 3

Auffällig ist die Annotation @Shared. Annotiert sie nicht die Variablen, auf die der Closure schreibend zugreift, gibt es eine Compiler-Warnung (kein Fehler!): "warning: [shared] captured variable j not annotated @Shared".

Closure Conversion

Damit automatisch Java-Entwicklung ohne Anpassung der Bibliotheken von den Closures profitieren, haben die Sprachentwickler einen speziellen Mechanismus eingebaut: Ein Closure kann einem Interface mit einer Operation zugewiesen werden, wenn die Rückgabe- und Parametertypen übereinstimmen. Die Schnittstelle Runnable und ActionListener sind wie folgt deklariert:

public interface Runnable {
  void run();
}
public interface ActionListener extends EventListener {
    void actionPerformed(ActionEvent e);
}

Kompatible Closures sind:

Runnable run = { => System.out.println("Nebenläufig!"); };
ActionListener listener = { ActionEvent l => System.out.println("Gedrückt!"); };

Ohne Zuweisung an Variablen ist ein nebenläufiges Programm schnell gestartet und ein Ereignisbehandler ohne viel Programmcode an einer Schaltfläche festgemacht:

new Thread( { => System.out.println("Nebenläufig!"); } ).start();
JButton b = new JButton();
b.addActionListener( { ActionEvent l => System.out.println("Gedrückt!"); } );

Diese automatische Konvertierung ist wirklich sehr praktisch, denn viele wichtige Java-Schnittstellen schreiben nur eine Operation vor.

Nach einem Vormittag mit Java-Closures kann ich sagen, dass ich gut mit der Syntax leben kann. Ich mag's! Schauen wir mal, ob sich noch groß etwas ändert.

Labels: Insel, Java 7

Mit der Google Java API (http://code.google.com/apis/gdata/javadoc/) lässt sich leicht auf die Dokumente oder Kalender zurückgreifen. Ein erstes Beispiel für eine Liste der Google-Calender ist schnell formuliert:

import java.net.URL;
import com.google.gdata.client.calendar.CalendarService;
import com.google.gdata.client.docs.DocsService;
import com.google.gdata.data.calendar.CalendarEntry;
import com.google.gdata.data.calendar.CalendarFeed;
import com.google.gdata.data.docs.DocumentListEntry;
import com.google.gdata.data.docs.DocumentListFeed;

public class GoogleExample
{
  public static void main( String[] args ) throws Exception
  {
    String user = "user@gmail.com", pass = "pass";

    CalendarService calService = new CalendarService( "Mein Kalender" );
    calService.setUserCredentials( user, pass );

    CalendarFeed resultFeed = calService.getFeed(
                                new URL( "http://www.google.com/calendar/feeds/default/allcalendars/full" ),
                                CalendarFeed.class );

    for ( CalendarEntry entry : resultFeed.getEntries() )
      System.out.println( entry.getTitle().getPlainText() );

    DocsService service = new DocsService( "Meine Dokumente" );
    service.setUserCredentials( user, pass );

   DocumentListFeed feed = service.getFeed(
                              new URL( "http://docs.google.com/feeds/documents/private/full" ),
                              DocumentListFeed.class );

    for ( DocumentListEntry doc : feed.getEntries() )
      System.out.println( doc.getId() + "/" + doc.getTitle().getPlainText() );
  }
}

Die notwendigen Java-Archive nimmt man aus dem lib-Verzeichnis des Archivs http://gdata-java-client.googlecode.com/files/gdata.java-1.15.2.zip. Um auf die Dokumente zurückzugreifen (oder auch nur aufzulisten), ist mail.jar ebenfalls nötig.

Labels: Open Source

Applets in der Wiege von Java

Applets sind kleine Java-Programme, die in einem Web-Browser ablaufen. Sie gehören zu den Java-Programmen der ersten Stunde. Obwohl Applets Java an die Spitze der Programmiersprachen brachte, sind die heute nur noch selten zu sehen. Es gibt zwar Ausnahmen, wie den Routenplaner http://map24.de/, doch im Allgemeinen sind in öffentlichen Webseiten Applets weitestgehend verschwunden. Der Grund, warum Java-Applets weniger attraktiv für den Konsumenten sind liegt nicht daran, dass die Client-seitige Darstellung und Logik unwichtig geworden ist, doch vielmehr an ande-ren Gründen:

• Mit HTML, CSS sowie JavaScript lassen sich heutzutage viele Aufgaben lösen, die 1995 unlösbar waren. Dagegen wirken kompilierte Java-Programme wie Raketentechnik. Während bei Java-Applets erst eine JVM gestartet werden muss, was natürlich eine gewisse Zeit kostet, ist JavaSc-ript und HTML sofort bereit. Starke JavaScript-Bibliotheken ermöglichen tolle Effekte und schnelle Verarbeitung.
• Ist Java installiert, steht auf den Rechnern eine moderne und schnelle Java-Laufzeitumgebung für Applets über ein Brower-Plugin zur Verfügung. Möchte der Anwender Applets nutzen, aber kein JVM ist installiert, ist der Bezug langwierig und viele Megabyte Daten müssen vom Sun-Server geladen werden. Sun arbeitet aktuell an einem System, mit dem nur relevante Bibliotheken bezogen werden, doch die Umsetzung ist noch Zukunftsmusik. (Microsoft lieferte für Windows XP immerhin noch eine eigene JVM aus, obwohl sie auf dem Stand von Java 1.1 stehen bleib. Wegen immer wieder aufkehrenden Sicherheitsproblemen sollten Anwender die Microsofts Java VM jedoch deinstallieren. Microsoft liefert für Vista kein Java mit aus und empfiehlt daher, Suns JVM zu installieren. )
• Java ist als allgemeine Programmiersprache entworfen worden, aber nicht als einfache Programmiersprache für grafische Effekte. Hier liegt der Vorteil von Adobe Flash. Mit starken Tools kön-nen Designer großartige Oberflächen entwerfen und die Verbreitung des Flash-Players ist phäno-menal . Zudem erweitert Adobe die Multimedia-Techologie Flash, die Programmiersprache ActionScript sowie die Produktpalette zur Entwicklung kontinuierlich. Möglicherweise ändert sich dass, wenn Java Laufzeitumgebungen stark verbreitet sind und sich Suns neue Programmierspra-che JavaFX (http://java.sun.com/javafx/) verbreitet hat.

Hinweis   Wir wollen im Folgenden davon ausgehen, dass nicht die Java-Laufzeitumgebung 1.1 von Microsoft installiert ist, sondern ein vollwärtiges Java von Sun. Ist Suns Version von Java installiert, ersetzt es die JVM von Microsoft, und aktuelle Java-Programme lassen sich ausführen.

HTML Converter

Läuft der Browser auf ein <applet>-Tag, so startet er die Java Laufzeitumgebung, die das Java-Programm ausführt. Problematisch ist nur, wenn für den Browser kein Java (oder die falsche Version) installiert ist, und der Browser keine Idee hat, war er mit dem <applet>-Tag anfangen soll. Die Lö-sung ist, auf das <applet>-Tag zu verzichten, und eine Browser-spezifische Alternative zu verwen-den, um dem Benutzer zur Installation einer richten JVM zu verhelfen. Der HTML-Code dafür ist recht kryptisch, sodass Sun ein Tool vorsieht, welches das <applet>-Tag ersetzt. Das Hilfsprogramm heißt HTML Converter und befindet sich im bin-Verzeichnis vom JDK. Nach dem Start öffnet sich eine grafische Oberfläche, mit der die HTML-Datei oder ein Ordner mit Applet-referenzierenden HTML-Dateien angegeben wird.
<neupic: htmlconverter.png, „Der HTML Converter“>
Aus dem bedächtigen

<html><body>
<applet code="HelloWorldApplet.class" width="200" height="100"></applet>
</body></html>

erzeugt der Generator anschließend (wenn die Schablonendatei „Erweitert“ angegeben ist):

<html><body>
<!--"CONVERTED_APPLET"-->
<!-- HTML CONVERTER -->
<script language="JavaScript" type="text/javascript"><!--
    var _info = navigator.userAgent;
    var _ns = false;
    var _ns6 = false;
    var _ie = (_info.indexOf("MSIE") > 0 && _info.indexOf("Win") > 0 && _info.indexOf("Windows 3.1") < 0);
//--></script>
    <comment>
        <script language="JavaScript" type="text/javascript"><!--
        var _ns = (navigator.appName.indexOf("Netscape") >= 0 && ((_info.indexOf("Win") > 0 && _info.indexOf("Win16") < 0 && java.lang.System.getProperty("os.version").indexOf("3.5") < 0) || (_info.indexOf("Sun") > 0) || (_info.indexOf("Linux") > 0) || (_info.indexOf("AIX") > 0) || (_info.indexOf("OS/2") > 0) || (_info.indexOf("IRIX") > 0)));
        var _ns6 = ((_ns == true) && (_info.indexOf("Mozilla/5") >= 0));
//--></script>
    </comment>

<script language="JavaScript" type="text/javascript"><!--
    if (_ie == true) document.writeln('<object classid="clsid:8AD9C840-044E-11D1-B3E9-00805F499D93" WIDTH = "200" HEIGHT = "100"  codebase="http://java.sun.com/update/1.6.0/jinstall-6u30-windows-i586.cab#Version=6,0,0,5"><noembed><xmp>');
    else if (_ns == true && _ns6 == false) document.writeln('<embed ' +
        'type="application/x-java-applet;version=1.6" \
            CODE = "HelloWorldApplet.class" \
            WIDTH = "200" \
            HEIGHT = "100" ' +
        'scriptable=false ' +
        'pluginspage="http://java.sun.com/products/plugin/index.html#download"><noembed><xmp>');
//--></script>
<applet  CODE = "HelloWorldApplet.class" WIDTH = "200" HEIGHT = "100"></xmp>
    <PARAM NAME = CODE VALUE = "HelloWorldApplet.class" >
    <param name="type" value="application/x-java-applet;version=1.6">
    <param name="scriptable" value="false">

</applet>
</noembed>
</embed>
</object>

<!--
<APPLET CODE = "HelloWorldApplet.class" WIDTH = "200" HEIGHT = "100">

</APPLET>
-->
<!--"END_CONVERTED_APPLET"-->

</body></html>

Labels: Insel

Die Informationen von Mikroformaten lassen sich mit JAXB relativ leicht in XML konvertieren:

import java.util.*;
import javax.xml.bind.*;
import javax.xml.bind.annotation.*;

public class MicroformatViaJaxb
{
  public static void main( String[] args ) throws JAXBException
  {
    Microformat mf = new Microformat();
    mf.elements.add( new Element( "name", "Christian Ullenboom" ) );
    mf.elements.add( new Element( "address", "tutego Allee" ) );
    mf.elements.add( new Element( "phone", "2873568956928" ) );

    JAXBContext context = JAXBContext.newInstance( Microformat.class );
    Marshaller m = context.createMarshaller();
    m.setProperty( Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE );
    m.marshal( mf, System.out );
  }
}
@XmlRootElement( name = "div" )
class Microformat
{
  @XmlAttribute( name = "class" )
  public String key = "person";
  @XmlElement( name = "span" )
  public List<Element> elements = new ArrayList<Element>();
}
class Element
{
  @XmlAttribute( name = "class" )
  public String key;
  @XmlValue
  public String value;
  public Element() { }
  public Element( String key, String value )
  {
    this.key = key;
    this.value = value;
  }
}

XML HK2 WSIT ESB JMS SSO SAO JSR JAX-RS JCP DOJO AJAX WSDP jBMP RIFE RAILS MC4J CAPS SAML WS-* WSRP SAW JXTA HTTP URL IIOP ORB JMX TCP/IP WSDL MEX XWSS MTOM XSD SMTP WSA SOAP JBI JCA CMT LDAP BMT CMPI VJM CDDL GPL BSD API JAX-B StAX JSP JSTL EJB JPA TCK JDBC JDK JRE JAXP XOP REST POJO SQL GUI URI XMLDSig JAAS GSSAPI META-INF NIO ACL JNL CORBA CDC CLDC MIDP ACID SSL DRDA UML SAX DOM XOM XML-RPC MVC XSLT DAO SVG COM FTP PDF JNA ANTLR SLF4J

Alles klar?

Die PDFs sind zwar schon länger online, aber für Interessierte noch der Link: http://de.sun.com/sunnews/events/2007/20071203/agenda_frankfurt.jsp#agenda-2:

Sun Microsystems Country Manager Introduction:Donatus Schmid, Marketing Director Germany
Download PDF

Demo. Showcase: Tomorrow's Technologies in action Today
Sang Shin, Simon Ritter, Sridhar Reddy, Carol McDonald, Philip Torchinsky, Joey Shen, Inyoung Cho
Sun Spot

Java EE, GlassFish and their Future
Daniel Adelhardt
Download PDF

Java SE 6 Top 10 Features, Java SE 7 and OpenJDK
Inyoung Cho
Download PDF

What Makes Solaris Interesting?
Frank Curran
Download PDF

Oracle Sponsor Session: Discover Oracle
Wolfgang Ehrenthaler
Download PDF

Easy Deployment: Leaner and Meaner Runtime
Simon Ritter
Download PDF

New Security Features in Solaris and OpenSolaris
Scott Rotondo
Download PDF

Sun Keynote – James Gosling
Download PDF

Java DB: The Multi-tier Database
Dag H. Wanvik
Download PDF

A Rich Application Platform: JavaFX
Sridhar Reddy
Download PDF

Building High Performance Applications on Multicore Systems Using Sun Studio Compilers and Tools
Vijay Tatkar
Download PDF

Solaris Virtualization for Systems Administrators
Philip Torchinsky
Download PDF

Rapid Development with Ruby, JRuby and Rails
Joey Shen
Download PDF

Real-time Java
Simon Ritter
Download PDF

Performance Tuning With Sun Studio Analyzer, Race Detection Tools, Dtrace (D-Light)
Boris Ivanovsky
Download PDF

Efficient System Administration Using Sun's System Management Technologies
Juergen Fleischer
Download PDF

Developing Applications Using Spring and JPA
Eberhard Wolff
Download PDF

Effective Concurrency for the Java Platform
Sang Shin
Download PDF

Let SMF Deal With That
Detlef Drewanz
Download PDF

Java Persistence API: Further Simplifying Persistence
Simon Ritter
Download PDF

Isolating Performance Bottlenecks and Memory Leaks
Jaroslav Bachorik
Download PDF

Enterprise Database Inside: The PostgreSQL In Your Solaris
Paul van den Bogaard
Download PDF

Sun Community Keynote: Developing in a Polyglot World by Craig McClanahan
Download PDF

Ajax and Web 2.0 Related Frameworks and Toolkits
Carol McDonald
Download PDF

Programming for Cool Devices using the Open Source Java ME PhoneME Stack
Terrence Barr
Download PDF

ZFS - Using Its Full Potential
Uli Graef
Download PDF

Building Rich Web Applications using jMaki
Joey Shen
Download PDF

More Concurrency: The Ten Unofficial Laws
Heinz Kabutz and Kirk Pepperdine
Download PDF

NFS and pNFS: High Performance Shared Data Stores for HPC Applications
Guenter Herbert
Download PDF

AMS GmbH Sponsor Session: jBEAM - A Framework for Desktop and Web Based Analysis and Reporting Systems
Dr. Bernhard Sünder
Download PDF

OpenSolaris Testing
Joaquim Rosell &
Sean McGrath
Download PDF

AMD Sponsor Session: Optimizing for Quad-core Solaris Systems based on AMD platforms
Raj Kharran
Download PDF

Metro and REST: Everyday Web Services
Harold Carr and Carol McDonald
Download PDF

Web Services Security, OpenSSO and Access Management for SOA
Abdi Mohammadi
Download PDF

Intel Technical Session: What are we doing to optimize Solaris on Intel Architecture?
Download PDF

Java ME GUI Makeover with Ajax Mashup
Terrence Barr
Download PDF

Performance Tuning Applications: GC Friendly Java Programming
Simon Ritter
Download PDF

How to Develop Solaris Parallel Applications
Leonid Lenyashin
Download PDF

DTrace Web 2.0 Applications, JavaScript, PHP, Java and the SAMP Stack
Peter Karlsson and Philip Torchinsky
Download PDF

SOA Using OpenESB, BPEL and NetBeans
Armin Wallrab
Download PDF

Get Your Parallel Applications Onto The Grid With Sun Grid Engine
Guenter Herbert
Download PDF