Lessons learned: Use of Modern JVM Languages besides Java - JavaOne 2012

Lessons Learned:
Use of Modern JVM Languages Besides Java

Kai Wähner (MaibornWolff et al GmbH)

Main Tasks
Evaluation of Technologies and Products
Requirements Engineering
Enterprise Architecture Management
Business Process Management
Architecture and Development of Applications
Planning and Introduction of SOA
Integration of Legacy Applications
Cloud Computing
Big Data

Consulting Contact
Developing Email: kontakt@kai-waehner.de
Speaking Blog: www.kai-waehner.de/blog
Coaching Twitter: @KaiWaehner
Social Networks: Xing, LinkedIn
Writing

www.mwea.de Lessones learned: Use of modern JVM Languages besides Java - Kai Wähner

Java platform

www.mwea.de Lessones learned: Use of modern JVM Languages besides Java - Kai Wähner 01.10.2012

Variety of languages on the .NET platform

C C++

C# F#
.NET
Silverlight Scala


Variety of languages on the Java platform

Java Java

Java Java
Java
Java


Characteristics of the Java language

„It’s not all
rainbows and unicorns
in the land of Java“

http://batsov.com/Java/Groovy/2011/05/06/jvm-langs-groovy.html


Java Virtual Machine (JVM)

Java Runtime Environment (JVM + Java Standard Libraries)
=> JVM Bytecode -> VM-specific internal representation -> Native machine code



Ahead-of-time compiled
Java Bytecode (.class)




Ahead-of-time compiled Ahead-of-time compiled
Java Bytecode (.class) Scala Bytecode (.class)






Ahead-of-time compiled
Groovy Bytecode (.class)





Interpreted or Just-in-time
compiled Groovy Bytecode
Ahead-of-time compiled (In-memory)
Groovy Bytecode (.class)

Groovy Script Code


Languages for the Java platform

240+ further languages:
http://tinyurl.com/3ql5m98


"Escape from the Java language prison"


What is the key message?


Key message

Java is still the most important programming platform


Key message

Java is not the new Cobol


Key message

Java is not the new Cobol
Modern JVM languages besides Java create added value


Agenda

1.  Reduced Efforts
2.  Increased Flexibility
3.  Reduced Complexity
4.  Reduced Heterogeneity
5.  Innovation
6.  Language Selection
7.  Problems
8.  Getting Started

Agenda

Business
Value
5.  Innovation
7.  Problems

Agenda

5.  Innovation
7.  Problems
Lessons
learned

Lines of code (Java)

employees.sort (
new Comparator{
public int compare(Object emp1, Object emp2){
int emp1Age = ( (Employee) emp1).getAge();
if( emp1Age > emp2Age )
return 1;
else if( emp1Age < emp2Age )
return -1;
else
return 0;
}

Java


Lines of code (Scala)

employees.sort (
employees.sort (_.age > _.age)
new Comparator{
public int compare(Object emp1, Object emp2){
if( emp1Age > emp2Age )
return 1;
else if( emp1Age < emp2Age )
return -1;
else
return 0;
}

Java Scala


Lines of code (Scala)

employees.sort (_.age > _.age)

Scala API:

Scala


Lines of code

<books>
<book isbn="…">
<title>Groovy in Action</title>
<author>Dierk Koenig</author>
<author>Paul King</author>
…
</book>
<book isbn="…">
<title>Grails in Action</title>
<author>Glen Smith</author>
<author>Peter Ledbrook</author>
</book>
...
</books>

(Making Java Groovy, Kenneth A. Kousen)


Lines of code

<books>
<book isbn="…">
…
</book>
<book isbn="…">
</book>
...
</books>


Task: Get the title of the second book!


Lines of code (Java)

<books> DocumentBuilderFactory factory =
<book isbn="…"> DocumentBuilderFactory.newInstance();
<title>Groovy in Action</title> Document doc = null;
<author>Paul King</author> try {DocumentBuilder b = factory.newDocumentBuilder();
… doc = b.parse("src/jag/xml/books.xml");
</book> } catch (Exception e) { // Parser, SAX, IO
<book isbn="…">
<title>Grails in Action</title> e.printStackTrace();}
<author>Glen Smith</author> if (doc == null) return;
NodeList titles = doc.getElementsByTagName("title");
</book>
... Element titleNode = (Element) titles.item(1);
</books> String title = titleNode.getFirstChild().getNodeValue();
System.out.println("The second title is " + title);



Lines of code (Groovy)

<books>
<book isbn="…">
… root = new XmlSlurper().parse('books.xml')
</book> println root.book[1].title
<book isbn="…">
</book>
...
</books>




Increased flexibility

Modularisation


Modularisation

http://www.artima.com/scalazine/articles/package_objects.html



Scripting


Scripting

Change behaviour of an application
dynamically at runtime

Direct execution
vs.

JSR 233 Scripting for the Java Platform



Meta programming


Meta programming (Runtime)

// Java Code
public class ABC() {

public static ABC factory() {
return new ABC();
}

public static void main(String[] args) {
ABC abc = ABC.factory());
}
}



// A little bit of (Groovy-) Magic:
Class.metaClass.factory = { Object[] args ->
delegate.metaClass.invokeConstructor(*args)
}



// A little bit of (Groovy-) Magic:
Class.metaClass.factory = { Object[] args ->
delegate.metaClass.invokeConstructor(*args)
}

// Now, all Java classes have a „factory()“ method:
HashMap hashmap = HashMap. factory ()
Integer integer = Integer. factory (42)
Dimension dimension = Dimension. factory (2, 3)



In Practice: „Finder“ in Grails


Meta programming replacement in Scala:
Implicit Conversions


Meta programming replacement in Scala:
Implicit Conversions

Attention: Use it wisely!


Build management


Build tools

Ant
vs.

Maven

Build tools

Ant
Gradle vs.

Maven

Build tools

Further advantages
(e.g. Scripting)
Ant
Gradle vs.

Maven

Reduced complexity


Reduced complexity

Concurrency


Concurrency

Current situation?


Current situation

„The
Gigahertz
Race
is over!“


The industry has an answer

Multicore
CPUs


Concurrency

The problem?


The problem

Process
A

Shared
State
Process
B


The problem

Thread-API
  Deadlocks
  Race Conditions
  Exceptions


Reduced complexity

Solution?


Attempted rescue


Good books! However, the Thread API is still complex ...


Reduced complexity

Better solution?


Alternatives* for dealing with state (instead of Thread API)

Shared Mutability => Software Transactional Memory (STM)

versus

Isolated Mutability => Actors

* Purely Immutability => Tough to realize


Shared Mutability: Software Transactional Memory (STM)

„Clojure does not replace the Java thread system,
rather it works with it. [But there are] no locks! “

=> An alternative to lock-based synchronization!

http://www.heise.de/developer/artikel/Benefits-1030160.html


Isolated Mutability: Actors

„Communicate by passing immutable Messages“

http://www.infoq.com/presentations/Actor-based-Programming (Jamie Ridgway)


Actors in Scala

val chatRoom = actor {
while (true) {
receive {
case Subscribe(user) => // do something
case Unsubscribe(user) => // do something
case UserPost(user, post) => // do something
}}}

// send a asynchronous message to the Actor:
chatRoom ! Subscribe(User("Bob"))

No Thread API, Locks, Synchronisation
(and therefore lower threat to deadlocks or race conditions)


Actors in Groovy with GPars (Groovy Parallel Systems)

„Give Actors an OO facade“
@ActiveObject
class Decryptor {

@ActiveMethod // asynchronous => return a Future object
def decrypt(String encryptedText) {
return encryptedText.reverse() }

@ActiveMethod
def decrypt(Integer encryptedNumber) {
return -1*encryptedNumber + 142 } }

final Decryptor decryptor = new Decryptor()

def part1 = decryptor.decrypt(' noitcA ni yvoorG')
def part2 = decryptor.decrypt(140)

print part1.get() // == Groovy in Action
print part2.get() // == 2


Reduced complexity

Domain
Specific
Languages
(DSL)


Domain Specific Languages (DSL)

A [internal] DSL is a programming language that mimics the terms,
idioms, and expressions used among experts in the targeted domain.
Code written in a DSL reads like structured prose for the domain.

Ideally, a domain expert with little experience in programming can
read, understand, and validate this code. Sometimes, a domain
expert might be able to write DSL code, even if he isn’t a professional
programmer.
http://ofps.oreilly.com/titles/9780596155957/DomainSpecificLanguages.html


Internal DSL in test frameworks


ScalaTest (Scala)

Which code is easier to understand?


ScalaTest (Scala)


Java: assertTrue(map.containsKey(‘a’));


ScalaTest (Scala)


Java: assertTrue(map.containsKey(‘a’));

Scala: map should contain key ‘a’


Example for an internal Scala DSL

Baysick DSL
(simulates BASIC)
http://blog.fogus.me/2009/03/26/
baysick-a-scala-dsl-implementing-basic/


Reduced heterogeneity

Install
Source code script
(Java) (Shell)

Dynamic
database script
Build
(JRuby)
(XML)


Reduced heterogeneity

Source code

Dynamic database script

Install script

Build

(Groovy)


Innovation


Innovation

New
Technologies
Concepts
Solutions


Innovation

New
Technologies
Concepts
Solutions

Marketing
Article, blogs, conference sessions


Innovation

New
Technologies
Concepts
Solutions

New Projects Marketing
Consulting, Coaching, Development Article, blogs, conference sessions


Marketing

„War for Talents“


Marketing

„War for Talents“

„Follow the Leader“


Conclusion "business value"

Reduced efforts
Reduced
complexity

Increased
flexibility

Reduced
Innovation Heterogeneity


Language selection

<Excursus>


Excursus: Typing

Dynamically
typed
Complexity

languague

Statically
typed
language

Power

Excursus: Programming concepts

Scala in Depth, Joshua D. Suereth


Language selection

</Excursus>



Which language(s)
shall we use?


Conclusion „language selection"

The language has to be
„Java Friendly“ and „Feature Rich“



Maturity?


Maturity




Prevalence?



Platform integration?


Syntax alignment

import java.util.*; // Java
Date today = new Date(); // Java


Syntax alignment


today = new Date() // Groovy


Syntax alignment



import java.util._ // Scala
var today = new Date // Scala


Syntax alignment




java_import ‘java.util.Date' # JRuby
today = Date.new # JRuby


Syntax alignment




java_import ‘java.util.Date' # JRuby
today = Date.new # JRuby

(import '(java.util Date)) ; Clojure (def today (new Date)) ;
Clojure (def today (Date.)) ; Clojure alternative


Good IDE-support: The Paranthesis Generator?

(import '(java.util Date)) ; Clojure (def today (new Date)) ;
Clojure (def today (Date.)) ; Clojure alternative


Plattform integration? => No syntax alignment!

JRuby
Feature Rich

Clojure
Jython

JavaScript

Java Friendly

Seamless integration?

Java

Groovy? „Other“


Seamless Integration? (Groovy)

public class Article {
    private String name;
    private String price;
    public Article(String name, String price) {
        this.name = name;
        this.price = price;
    } class Article {

    public String getName() {    String name
        return name;    String price
    }
}
    public void setName(String name) {
        this.name = name;
    }
    public String getPrice() {
        return price;
    }
    public void setPrice(String price) {
        this.price = price;
    }
}

Java Groovy

Seamless Integration? (Groovy)

public class Article { public class Article {
    private String name;     private String name;
    private String price;     private String price;
    public Article(String name, String price) {     public Article(String name, String price) {
        this.name = name;         this.name = name;
        this.price = price;         this.price = price;
    }     }
    public String getName() {     public String getName() {
        return name;         return name;
    }     }
    public void setName(String name) {     public void setName(String name) {
        this.name = name;         this.name = name;
    }     }
    public String getPrice() {     public String getPrice() {
        return price;         return price;
    }     }
    public void setPrice(String price) {     public void setPrice(String price) {
        this.price = price;         this.price = price;
    }     }
} }

Java Groovy


Java

Groovy „Other“


Plattform integration?

JRuby
Groovy
Feature Rich

Clojure
Jython

JavaScript

Java Friendly


Java

„Other“ Scala?


Seamless integration? (Scala) => Bytecode != Bytecode

Implicit Conversions Inexpressible
vs. Language
Object Identity / Equality Features

Objects
vs.
Primitives
Uniform
Access
Principle
Java Bytecode Analysis


Seamless integration? (Scala) => Bytecode != Bytecode

„Usually, it just works ...

... if not, define a Java Interface.“



Java

„Other“ „Scala“


Plattform integration?

JRuby Scala
Groovy
Feature Rich

Clojure
Jython

JavaScript

Java Friendly


240+ Weitere:



„The dynamic One“ „The functional One“

The language has to be
„Java Friendly“ and „Feature Rich“

(Other JVM languages only if „forced“)


Why use new languages? Java does the job, right?

IT
vs.

Politics


Cloud Computing will be requested by the customer...




NoSQL will be required for big data and high scalability...




NoSQL will be required for big data and high scalability...

... but modern JVM languages will probably never be demanded 


Problems with modern JVM Languages

‚Real life‘ problems



-  New Concepts for Java / OO Developers
-  Powerful vs. Ease of Use
-  Confusion due to Meta Programming
-  Bytecode != Bytecode
-  Trouble with Debugging
-  Total Cost of Ownership (Skills, Training, Refactoring, Maintenance)



-  New Concepts for Java / OO Developers
-  Powerful vs. Ease of Use
-  Confusion due to Meta Programming
-  Bytecode != Bytecode
-  Trouble with Debugging
-  Total Cost of Ownership (Skills, Training, Refactoring, Maintenance)

BUT:
„Don't let yourself be fooled!“
(you also use a JAXB compiler, a GWT compiler, a WSDL compiler, etc., right?)


Bytecode != Bytecode

Java + Groovy = Good

Java + Scala = Ok

Non-Java + Non-Java = ???


Bytecode != Bytecode

Ruby

Scala
JRuby + Scala: www.codecommit.com/blog/ruby/integrating-scala-into-jruby


IDEs do not have AS-GOOD maturity as Java (yet?)


Getting started...

You can't make something out of nothing.


Getting started...

Use new languages!
Marketing
Looking back at Channels
finished projects

Think about it BEFORE
starting new projects
Internal
Projects
Testing


Conclusion „lessons learned“


Did the key message arrive?


Thank you for your attention... Questions?

Contact
Kai Wähner MaibornWolff et al GmbH Mobile +49 151 544 277 88
IT Consultant Theresienhöhe 13 Email kontakt@kai-waehner.de
D-80339 München Twitter @KaiWaehner


Lessons learned: Use of Modern JVM Languages besides Java - JavaOne 2012

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (9)

Similar to Lessons learned: Use of Modern JVM Languages besides Java - JavaOne 2012

Similar to Lessons learned: Use of Modern JVM Languages besides Java - JavaOne 2012 (20)

More from Kai Wähner

More from Kai Wähner (20)

Recently uploaded

Recently uploaded (20)

Lessons learned: Use of Modern JVM Languages besides Java - JavaOne 2012