Polyglot JVM
Upcoming SlideShare
Loading in...5
×
 

Polyglot JVM

on

  • 9,967 views

My talk about Polyglot JVM.

My talk about Polyglot JVM.
A Quick Tour of Java Virtual Machine Languages: Java, Groovy, Scala, Clojure.

Codemotion
http://codemotion.es/
24.03.2012

Statistics

Views

Total Views
9,967
Views on SlideShare
3,091
Embed Views
6,876

Actions

Likes
2
Downloads
64
Comments
0

256 Embeds 6,876

http://arturoherrero.com 4818
http://mindfood.osoco.es 1262
http://localhost 155
http://bbvabetatesters.com 67
http://lanyrd.com 47
http://beta-testing 38
http://mindfood.tumblr.com 36
http://jira.rumbo.com 20
http://www.bbvabetatesters.com 20
http://abtasty.com 16
http://anfix 12
http://www.tumblr.com 10
http://colorbox 10
http://rebe 9
https://twimg0-a.akamaihd.net 7
http://magicev 7
http://gmail 6
http://translate.googleusercontent.com 6
http://svn.carmen.ccn-cert-cni.es 6
https://si0.twimg.com 5
http://pccomponentes 5
http://catalogo-ceapat.org 4
http://www.bbbvabetatesters.com 4
http://elpa 4
http://bbvabetatesters.es 4
http://gestordevacaciones.rumbo.com 4
http://gctest.bkool.com 4
http://hootsuite.com 3
http://r-y-r.es 3
http://gmailc.om 3
http://rae 3
http://cc 3
http://atm 3
http://gcdr.coderetreat.org 3
http://new.spam.dnsbl.sorbs.net 3
http://analytics 3
http://lureka 3
http://adwords 3
http://apple 3
http://f 3
http://g 3
http://wordreference 3
http://54.247.161.23 3
http://www.google.es 2
http://crazz 2
http://mail.google.com 2
http://mail.gmail.com 2
http://magicma 2
http://mtgme 2
http://asdfasdf 2
More...

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Polyglot JVM Polyglot JVM Presentation Transcript

    • Polyglot JVMA Quick Tour of JVM Languages
    • @ArturoHerrerohttp://arturoherrero.com
    • Working at OSOCOSmall but outstanding software development shop Groovy and Grails hackers on EC2 cloud nine TDD mantra singers Quality preachers
    • Java Platform _____________________________________ / /||------------------------------------| || Java Programming Language | ||------------------------------------| || Libraries & APIS | ||------------------------------------| || Java Virtual Machine | ||------------------------------------|/
    • > 200 languages on JVMJavaFX Ceylon Gosu Groovy ClojureRhino Java Mirah Scala JRubyXtend JPython Fantom Oxygene Kotlin
    • The Da Vinci Machine ProjectWe are extending the JVM with first-classarchitectural support for languages other thanJava, especially dynamic languages. This projectwill prototype a number of extensions to the JVM, sothat it can run non-Java languages efficiently, with aperformance level comparable to that of Java itself.
    • The Da Vinci Machine ProjectJSR 223: Scripting for the Java PlatformJSR 292: Supporting Dynamically Typed Languages on the Java PlatformNew JDK 7 instruction: invokedynamic
    • Polyglot Programming
    • Ola Bini Programming Pyramid / / / DSL /------ / Dynamic / /------------ / Stable / /------------------
    • Ola Bini Programming PyramidDomain-Specific (DSL, web templating) Specific part of the applicationDynamic (Groovy, Clojure) Rapid, productive, flexible development or funcionalityStable (Java, Scala) Core funcionality, stable, well-tested, performance
    • Civilization advances by extending thenumber of important operations which wecan perform without thinking about them. Alfred North Whitehead
    • New languagesNew ways to think about problems
    • Language Clasification functional | | | | -----------------+-----------------static | dynamic | | | not functional
    • StackOverflow Questions| 8,268| __| | || | | 3,847| | | __ 2,762| | | | | __| | | | | | || | | | | | ||------+--+------+--+------+--+------
    • | | | |StackOverflow Questions | | | | 222,722 | || 8,268 | || __ | || | | | || | | 3,847 | || | | __ 2,762 | || | | | | __ | || | | | | | | | || | | | | | | | ||------+--+------+--+------+--+------+--+-
    • Indeed Job Trends| 0,06| __| | || | | 0,03| | | __| | | | | 0,01| | | | | __| | | | | | ||------+--+------+--+------+--+------
    • | | | |Indeed Job Trends | | | | 3,40 | || 0,06 | || __ | || | | | || | | 0,03 | || | | __ | || | | | | 0,01 | || | | | | __ | || | | | | | | | ||------+--+------+--+------+--+------+--+-
    • All of them● Everything is an object● Operator overloading● Native syntax for collection classes● Regular expressions as first class citizens● Closures● Facilities to build DSLs
    • Groovy● Dynamic Language● Object-Oriented● Designed for the JVM● Inspired by Python, Ruby and Smalltalk● Good integration with Java● 2003
    • Hello Groovy println Hello World
    • ScriptingTypically dynamic languages No need to define variable before you use them. Many type conversionMost scripting languages are interpreted Perform the script compilation and execution within the same processFast results for small jobs Write application faster Execute commands repeatedly
    • Groovy Beansclass Person { String name Integer age}def person = new Person(name: John, age: 30)def name = person.nameperson.age = 35
    • Static vs. DynamicStatic typing A programming language is said to use static typing when type checking is performed during compile time as opposed to runtimeDynamic typing A programming language is said to be dynamically typed when the majority of its type checking is performed at runtime as opposed to at compile time
    • Optional Typing Integer object object = 4 object = noun ERROR org.codehaus.groovy.runtime. typehandling.GroovyCastException
    • Optional Typing def object object = 4 object = noun object = true object = [1, noun, true] object = [1: noun]
    • Java → Groovyimport java.util.List;import java.util.ArrayList;public class Filter { public static void main(String[] args) { List names = new ArrayList(); names.add("Ted"); names.add("Fred"); names.add("Jed"); names.add("Ned"); System.out.println(names); Filter filter = new Filter(); List shortNames = filter.filterLongerThan(names, 3); System.out.println(shortNames.size()); for (String item : shortNames) { System.out.println(item); } }...
    • Java → Groovy... private List filterLongerThan(List strings, int length) { List result = new ArrayList(); for (String item : strings) { if (item.length() <= length) { result.add(item); } } return result; }}
    • Java → Groovydef names = ["Ted", "Fred"] << "Jed" << "Ned"println namesdef shortNames = names.findAll { it.size() <= 3 }println shortNames.size()shortNames.each { name -> println name }
    • Static language interface Animal { def quack() } class Duck implements Animal { def quack() { println "I am a Duck" } } class Frog implements Animal { def quack() { println "I am a Frog" } }
    • Polymorphism Animal animal animal = new Duck() animal.quack() ===> I am a Duck animal = new Frog() animal.quack() ===> I am a Frog
    • Dynamic language class Duck { def quack() { println "I am a Duck" } } class Frog { def quack() { println "I am a Frog" } }
    • Duck typing def animal animal = new Duck() animal.quack() ===> I am a Duck animal = new Frog() animal.quack() ===> I am a Frog
    • Dynamic Method Call class Dog { def bark() { println "woof!" } def jump() { println "boing!" } } def doAction(animal, action) { animal."$action"() }
    • Dynamic Method Call someObject."$methodName"() def rex = new Dog() doAction(rex, "bark") ===> woof! doAction(rex, "jump") ===> boing!
    • MetaprogrammingPrograms that write or manipulateother programsCompile time ● Groovy ASTRuntime ● Hook into method dispaching ● Dynamically create methods/properties ● Dynamic execution of expressions
    • AST Transformations @Singleton class Singleton {} @EqualsAndHashCode class Person { String name, lastName } @Immutable class Coordinates { Double latitude, longitude }
    • Method Missing class Dog { def bark() { println "woof!" } def jump() { println "boing!" } } def rex = new Dog() rex.sit() ERROR groovy.lang.MissingMethodException
    • Method Missing class Dog { def bark() { println "woof!" } def jump() { println "boing!" } def methodMissing(String name, args) { println "sit!" } } rex.sit() ===> sit!
    • Adding methods to aclass at runtime 4.toRoman() ERROR groovy.lang.MissingMethodException
    • Adding methods to aclass at runtime SomeObject.metaClass.newMethod = { -> // do something } Integer.metaClass.toRoman = { -> println IV } 4.toRoman() ===> IV
    • Scala● Object-Oriented and Functional Language● Stronger type system● Designed for the JVM● Concurrency: Actors● Many advanced language features● As fast as Java● 2003
    • Hello Scala object HelloWorld { def main(args: Array[String]) { println("Hello World") } }
    • Scala Types scala> 1 + 1 res1: Int = 2 scala> (1).+(1) res2: Int = 2 scala> "a" + "b" res3: java.lang.String = ab scala> "abc".size res4: Int = 3
    • Classes class Person(name: String, age: Int) val person = new Person("John", 30)
    • Objects object Singleton { def start = println("Start") } scala> Singleton.start Start
    • Anatomy of a Function def max (x: Int, y: Int): Int = { if (x > y) x else y }
    • Type Inference // Java Map<String, List<Integer>> map = new HashMap<String, List<Integer>>() // Java 7 Map<String, List<Integer>> map = new HashMap<>() // Scala val map = new HashMap[String, List[Int]]
    • Variable Declaration var mutable = "I am mutable" mutable = "Touch me, change me..." val immutable = "I am not mutable" immutable = "Cant touch this" error: reassignment to val
    • ImmutabilitySimple Immutable objects can only be in exactly one state, the state in which it was createdAlways consistent Less prone to errors and more secureImmutable objects can be shared freely Freedom to cacheInherently thread-safe
    • Imperative vs. DeclarativeImperative: how to achieve our goal Take the next customer from a list. If the customer lives in Spain, show their details. If there are more customers in the list, go to the beginningDeclarative: what we want to achieve Show customer details of every customer living in Spain
    • Mutability val listOneToTen: List[Int] = { var list: List[Int] = List() var i: Int = 1 while (i <= 10) { list :+= i i += 1 } list }
    • Immutability def listToTen(i: Int): List[Int] = { if (i <= 10) i :: listToTen(i + 1) else Nil } val listOneToTen = listToTen(1)
    • Range scala> println(listOneToTen) List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) (1 to 10) toList
    • Mixin Traits class Person(val name: String) trait Power { def fly() = println("Fly") } class SuperHero(override val name:String) extends Person(name) with Power val superMan = new SuperHero("SuperMan") scala> superMan.fly Fly
    • Pattern Matchingdef determineType(x:Any) = x match { case s: String => println("String") case l: List[_] => println("List") case l: Map[_,_] => println("Map") case _ => println("Unhandled type!")}def factorial(n: Int): Int = n match { case 0 => 1 case x if x > 0 => factorial(n - 1) * n}
    • Clojure● Clojure is LISP● Dynamic language● Designed for the JVM● Code is data● Powerful macros● Good interoperability with Java● Clojure is fast● Concurrency. Shared Transactional Memory● 2007
    • Why Functional Programming? Referential transparencyλ Unit testingλ Debbugingλ Parallelizationλ Modularity and compositionλ Increases the quality of codeλ Abstractionsλ
    • Hello Clojure (println "Hello World")
    • Prefix notation (+ 1 2) => 3 (+ 1 2 3 4 5) => 15 (< 1 2 3 4 5) => true
    • Anatomy of a Function(defn biggest "Find the maximum of two numbers" [x y] (if (> x y) x y))
    • Anatomy of a Function(def biggest "Find the maximum of two numbers" (fn [x y] (if (> x y) x y)))
    • Function Composition (defn square [x] (* x x)) (square 21) => 441 (square (+ 2 5)) => 49
    • Function Composition (defn sum-of-squares [x y] (+ (square x) (square y))) (sum-of-squares 3 4) => 25
    • Immutability (def my-list (1 2 3)) +---+ +---+ +---+ | 1 | ---> | 2 | ---> | 3 | +---+ +---+ +---+ (def new-list (conj my-list 0)) +-----------------------------+ +---+ | +---+ +---+ +---+ | | 0 | --->| | 1 | ---> | 2 | ---> | 3 | | +---+ | +---+ +---+ +---+ | +-----------------------------+
    • Lazy EvaluationOnly does as much work as necessary Delays the evaluation of the expression until its neededCPU efficient The value is not calculated or assigned until the value is requestedManage potentially infinite data structures Only a manageable subset of the data will actually be used
    • Infinite Sequences (take 3 (repeat "Hello")) => ("Hello" "Hello" "Hello") (take 5 (cycle [1 2 3])) => (1 2 3 1 2) (take 5 (drop 2 (cycle [1 2 3]))) (->> [1 2 3] (cycle) (drop 2) (take 5)) (1 2 3 1 2 3 1 2 3 … => (3 1 2 3 1)
    • Clojure STM (def my-account (ref 1000.)) (def other-account (ref 5000.)) (defn transfer [from to amount] (dosync (alter from - amount) (alter to + amount))) (transfer other-account my-account 1000.)
    • Thank you!@ArturoHerrero