$30 off During Our Annual Pro Sale. View Details »

Comparing JVM languages

Comparing JVM languages

Comparing JVM languages
Java 8,Scala,Groovy,Clojure,Kotlin,Ceylon

jmortegac

June 28, 2015
Tweet

More Decks by jmortegac

Other Decks in Programming

Transcript

  1. Comparing JVM languages José Manuel Ortega Candel | @jmortegac 26-27

    June 2015
  2. INDEX Functional programming and closures 2 Language classification 1 Java

    8 new features 3 Scala, Groovy, Kotlin, Clojure and Ceylon 4 Advantages and drawbacks 5 Comparing features 6
  3. Language classification FUNCTIONAL NOT FUNCTIONAL STATIC DYNAMIC

  4. Functional programming •Data structure persistent and immutable •Closures •Higher order

    functions •Pass functions to functions as parameter •Create functions within functions •Return functions from other functions •Functions as first class values
  5. Closures •Reduce amount of “boiler plate” code •Eliminate the boilerplate

    code of anonymous inner classes •Allow the use of idiomatic functional programming code •Allow the creation of custom control structures •In Java 8 closures are just syntactic sugar for defining anonymous inner classes
  6. Java 8 new features  Lambda expressions  Closures 

    Streams  Enhaced collections  Processing data in parallel  Pattern Filter-Map-Reduce  Annotations types  Methods References (String s)-> System.out.println(s) System.out::println
  7. Streams

  8. Filter-Map-Reduce Book book=new Book(123455,"Beginning Java 8"); Book book1=new Book(3232332,"Java 8

    Advanced"); Book book2=new Book(43434343,"Groovy Advanced"); List<Book> books=Arrays.asList(book,book1,book2); Predicate<Book> condition=(it) -> it.getTitle().contains("Java"); String jsonFormat=books .stream() .filter(condition) .map(Book::toJSON) .collect(Collectors.joining(", ")); [{isbn:123455,title:'Beginning Java 8'}, {isbn:3232332,title:'Java 8 Advanced'}]
  9. Parallel Streams List myList = .. Stream stream = myList.stream();

    Stream parallelStream = myList.parallelStream(); Stream parallel = stream.parallel(); •Streams are sequential by default •With Parallel you can optimize number of threads •More efficient with bigger collections
  10. Sequential vs Parallel books.parallelStream().filter((it) -> it.getTitle().contains("Java")). forEach((it)->System.out.println(it+" "+Thread.currentThread())); Book{isbn=3232332, title='Java

    8 Advanced'} Thread[main,5,main] Book{isbn=123455, title='Beginning Java 8'} Thread[main,5,main] books.stream().filter((it) -> it.getTitle().contains("Java")). forEach((it)->System.out.println(it+" "+Thread.currentThread())); Book{isbn=3232332, title='Java 8 Advanced'} Thread[main,5,main] Book{isbn=123455, title='Beginning Java 8'} Thread[ForkJoinPool.commonPool- worker-2,5,main]
  11. Scala Combines the paradigms of functional programming and object-oriented Statically

    typed No types primitives like Java Everything is an Object, including functions Performance equivalent to Java
  12. Scala features Pattern matching Closures,lambdas,anonymous functions Traits and mixins for

    multiple inheritance Operator overloading Support Data Paralell like Java 8 Concurrency models(Akka,actors) Inmutable and mutable data structures
  13. Scala examples def factorial(n : Int): Int = n match{

    case 0 => 1 case x if x >0 => factorial(n-1) *n } val languages = List("Scala", "Groovy", "Clojure", "Kotlin") val headList = languages.head // Scala val tailList = languages.tail; //List( "Groovy", "Clojure", "Kotlin") val empty = languages.isEmpty //false def orderList(xs: List[String]): List[String] = if (xs.isEmpty) Nil else insert(xs.head, isort(xs.tail) @BeanProperty Annotation which is read by the Scala compiler to generate getter and setter class Bean { @scala.reflect.BeanProperty var name: String } val someNumbers = List(-11, -10, -5, 0, 5, 10) someNumbers.filter((x) => x > 0) someNumbers.filter(_ > 0) List[Int] = List(5, 10) scala.collection.immutable
  14. Inmutability in Scala scala> var languages = Set("Scala", "Kotlin") languages

    : scala.collection.immutable.Set[java.lang.String] = Set(Scala, Kotlin) scala> languages += "Clojure" scala> languages res: scala.collection.immutable.Set[java.lang.String] = Set(Scala, Kotlin, Clojure) scala> languages -= " Kotlin " scala> languages res: scala.collection.immutable.Set[java.lang.String] = Set(Scala, Clojure) • You can add elements in a inmutable collection
  15. Java 8 vs Scala

  16. Java 8 vs Scala streams bookList.parallelStream().filter(b -> b.title.equals(”Clojure”)) .collect(Collectors.toList()) bookList.par.filter(_.title

    == “Clojure”) bookList.par.filter( b =>b.title == “Clojure”) val bookFilter = bookList.par.filter(_.title.contains("Groovy")) .foreach{i=> println(Thread.currentThread) } Thread[ForkJoinPool-1-worker-3,5,main] Thread[ForkJoinPool-1-worker-5,5,main]
  17. Kotlin Object-oriented with functional elements Developed by JetBrains Statically typed

    like Scala Smarts casts Elvis operator(?) for checking null like Groovy Type inference 100 % interoperability with Java
  18. Kotlin syntax & rules Inmutable/Mutable variables No new keyword for

    create objects No primitive types No static members Primary constructors No fields, just properties By default, all classes are final
  19. Kotlin Smart casts Maps val languages = mapOf("Java" to "Gosling",

    "Scala" to "Odersky","Groovy" to "Strachan") for((language,author) in languages){ println("$author made $language") } fun eval(e: Expr): Double = when (e) { is Num-> e.value.toDouble() is Sum -> eval(e.left) + eval(e.right) else -> throw IllegalArgumentException("Unknown expression") } val mapLanguages = hashMapOf<String, String>() mapLanguages.put("Java", "Gosling") mapLanguages.put("Scala", "Odersky") for ((key, value) in mapLanguages) { println("key = $key, value = $value") } fun patternMatching(x:Any) { when (x) { is Int -> print(x) is List<*> ->{print(x.count())} is String -> print(x.length()) !is Number -> print("Not even a number") else -> print("can't do anything") } }
  20. Kotlin Operator overloading Default & name arguments println(product(2)) println(product(2,3)) println(format(text="kotlin"))

    println(format(text="kotlin", upperCase= true)) 2 6 kotlin KOTLIN fun product(a:Int,b:Int=1):Int{ return a.times(b); } fun format(text:String,upperCase:Boolean= false):String { return if (upperCase) text.toUpperCase() else text }
  21. Kotlin Iterators fun iterateOverCollection(collection: Collection<Int>) { for (element in collection)

    {} } fun iterateOverString() { for (c in "abcd") {} "abcd".iterator() } fun iteratingOverMap(map: Map<Int, String>) { for ((key, value) in map) {} }
  22. Kotlin Data classes  Data annotation changes behavior of hashCode,

    equals, toString functions public class Book (var isbn:Int, var title:String) fun main(args: Array<String>) { //Books val book = Book(123456, "Beginning Kotlin") val book2 = Book(123456, "Beginning Kotlin") println(book); println(book.hashCode()); println(book2.hashCode()); println(book.equals(book2)); if (book == book2) println("Same Book"); if (book != book2) println("Diferent Book"); } books.Book@2a84aee7 713338599 168423058 false Diferent Book data public class Book (var isbn:Int, var title:String) fun main(args: Array<String>) { //Books val book = Book(123456, "Beginning Kotlin") val book2 = Book(123456, "Beginning Kotlin") println(book); println(book.hashCode()); println(book2.hashCode()); println(book.equals(book2)); if (book == book2) println("Same Book"); if (book != book2) println("Diferent Book"); Book(isbn=123456, title=Beginning Kotlin) 1848623012 1848623012 true Same Book
  23. Kotlin Classes constructor • It is not necessary define a

    constructor like in Java • You can use the class definition to pass the properties and default values data public class Book (var isbn:Int, var title:String="My Default Book") fun main(args: Array<String>) { val book = Book(123456) println(book.title); }
  24. Kotlin Higher order functions • Lambda expressions • it implicit

    parameter val filter = books filter({ b: Book -> b.title.contains(“Kotlin") }) val book = Book(123455, "Beginning Java 8") val book1 = Book(3232332, "Java 8 Advanced") val book2 = Book(43434343, “Kotlin Advanced") val books = Arrays.asList(book, book1,book2) Filter[Book(isbn=43434343, title=Kotlin Advanced)] val filter = books filter({ it.contains(“Kotlin") })
  25. Kotlin collections val listInmutable =listOf("Java","Kotlin","Groovy","Scala") val listMutable=ArrayList<String>() listMutable.add("Java") listMutable.add("Kotlin")

  26. Kotlin vs Java list iterate for ((index,element) in list.withIndex()) {

    println(“$index$element”); } int index=0 for (String element:list) { System.out.println(index+””+element); index++ }
  27. Kotlin smart cast vs Java if (expr is Number) {

    println(expr.getValue()); //expr is automatically cast to Number } if (expr instanceof Number) { System.out.println((Number)expr).getValue()); }
  28. Kotlin vs Java types inference val longJavaClassName = LongJavaClassName() LongJavaClassName

    longJavaClassName =new LongJavaClassName()
  29. Groovy  Java supercharged(syntactic sugar)  Object oriented and dynamic

    language  Optional typing like Scala and Kotlin  All type checking is at run time  It reduces Java boilerplate code including no semi colons, no getters/setters, type inference, null safety, elvis operators
  30. Groovy  Closures with lambda or it implicit parameter def

    upper = { s-> s.toUpperCase()} def upper = {it.toUpperCase()}  Collections def languages = ["Java":”James Gosling”, "Scala":”Martin Odersky”, "Clojure":”Rich Hickey”, "Ceylon":”Gavin King”, "Groovy":”James Strachan”] languages.each { entry -> println} languages.each { k,v -> println}  Methods as closures with .& operator def object object = 2 object = true object = [1,2,3]  Optional typing
  31. Groovy  @Memoized annotation  @Inmutable annotation @Memoized def BigInteger

    fibRecursiveMemoized(n) { if (n<2) return 1 else return fibRecursiveMemoized(n-1) + fibRecursiveMemoized(n-2) } TimeIt.code{println(fibonnaci.fibRecursive(40))} TimeIt.code{println(fibonnaci.fibRecursiveMemoized(40))} 165580141 Time taken 42.083165464 seconds 165580141 Time taken 0.061408655 seconds //with memoize import groovy.transform.Immutable @Immutable class Language { String title; Long isbn; } def l1 = new Language (title:'Beginning Groovy',isbn:100) def l2 = new Language (title:'Groovy advanced',isbn:200) l1.title = 'Groovy for dummies' // Should fail with groovy.lang.ReadOnlyPropertyException
  32. Groovy  Time execution class TimeIt { def static code(codeBlock){

    def start = System.nanoTime() try{ codeBlock() }finally{ def end = System.nanoTime() println "Time taken ${(end-start)/1e9} seconds" } } }
  33. Groovy  Parsing and creating XML

  34. Groovy Advantages Disadvantages Java Collections Non-lazy evaluation Closures (like Lambda

    expressions in Java 8) It's performance isn't great (but it's improving) Filter – Map – Reduce in streams Easy interoperability with Java Static and dynamic typing @TypeChecked @CompileStatic Metaprogramming
  35. Java Groovy def languages = ["Java", "Scala", "Clojure", "Kotlin", "Ceylon","Groovy"]

    def filter = languages.stream() .findAll { it.size()>5 } .collect { it.toUpperCase()} .first() List<String> languages = Arrays.asList("Java", "Scala", "Clojure", "Kotlin","Ceylon","Groovy"); Optional<String> bookFiltered = languages.stream() .filter(s -> s.length()>5 ) .map(s -> s.toUpperCase()) .findFirst();
  36. Clojure Pure functional language JVM language based in Lisp Not

    Object Oriented Dynamically typed All data structure including list ,vectors, maps, sequences, collections, are inmutable and fully persistent The main data structure is the list The key is the use of High Order Functions
  37. Clojure Alternate implementations in functions (defn square-or-multiply "squares a single

    argument, multiplies two arguments" ([] 0) # without arguments ([x] (* x x)) # one argument ([x y] (* x y))) # two arguments List operations (first '(:scala :groovy :clojure))return scala (rest '(:scala :groovy :clojure))return all elements excepts the first (cons :kotlin '(:scala :groovy :clojure))add kotlin to head in the list
  38. Clojure Sequences (defn count-down [n] (if (<= n 0) '(0)

    (cons n (lazy-seq (count-down (dec n)))))) Filter – Map - Reduce (filter integer? [1 2.71 3.14 5 42]) => (1 5 42) (map (fn [n] (* n n)) [1 2 3 4 5]) => (1 4 9 16 25) (reduce + [1 2 3 4]) => 10 user=> (count-down 8) (8 7 6 5 4 3 2 1 0)
  39. Clojure Records (defrecord Book [isbn title]) (def bookList [(Book. 432423

    "Clojure")(Book. 534243 "Kotlin") (Book. 432424 "Groovy")]) (println "count bookList "(count bookList)) (dorun (for [item bookList] (println (:title item)(:isbn item)))) (println (filter #(= "Clojure" (get % :title)) bookList)) count bookList 3 Clojure 432423 Kotlin 534243 Groovy 432424 (#user.Book{:isbn 432423, :title Clojure}) (defrecord Object [prop1 propn])
  40. Clojure Recursive functions with trampoline and memoize (defn factorial ([x]

    (trampoline (factorial (dec x) x))) ([x a] (if (<= x 1) a #(factorial (dec x) (*' x a))))) (def fibonaci (memoize (fn [n] (if (< n 2) n (+ (fibonaci (dec n)) (fibonaci (dec (dec n)))))))) (time(println (factorial 20))) (time(println (fibonaci 30))) "Elapsed time: 0.692549 msecs" 832040 "Elapsed time: 1.263175 msecs" "Elapsed time: 24.574218 msecs" 832040 "Elapsed time: 118.678434 msecs" 2432902008176640000
  41. Clojure Advantages Disadvantages Very simple Not Object oriented The language

    has little elements compared with other languages Difficult to decipher stacktraces and errors Excellent concurrency support Requires a new way to solve problems Easy interoperability with java There are no variables Powerful language features (macros,protocols) Thre is no inheritance concept Clojure programs run very quickly No mecanism for avoid NullPointerException JVM is highly optimized
  42. Clojure vs Java Code reducing (defn blank [str] (every#? (Character/isWhitespace

    %) str)) public class StringUtils { public static boolean isBlank(String str) { int strLen; if (str == null || (strLen = str.length()) == 0) { return true; } for (int i = 0; i < strLen; i++) { if ((Character.isWhitespace(str.charAt(i)))) { return true; }} return false; }}
  43. Ceylon Is very similar to Java, reducing verbosity Object oriented

    with functional features Strong static typing with type inference Explicit module system  Comparing with Java  Eliminates static, public, protected, private  Add new modifiers like variable, shared, local  Shared is used for make visibility outside in other modules(like public in Java)  Arrays are replaced by sequences
  44. Ceylon Sequence languages = Sequence("Java", "Groovy","Clojure","Kotlin"); //Check if the sequence

    is empty if(nonempty languages){ String? firstElementValue = languages.value(1); String? firstElement = languages.first; } Sequence more = join(languages,Sequence("Ceylon","Scala")); Sequences Generics & Union types Iterable<String|Boolean> list = {“string”,true,false} ArrayList<Integer|Float> list = ArrayList<Integer|Float> (1, 2, 1.0, 2.0)
  45. Comparing featues •Reducing verbosity •Variables definition •Null-safety •Optional types •Lambdas

    •Pattern matching •Traits •Java interoperability
  46. Reducing Java verbosity Reducing Boilerplate Code class MyClass{ private int

    index; private String name; public MyClass(int index, String name){ this.index = index; this.name = name; } } case class MyClass(index: Int, name: String) public class MyClass(var index:Integer,var name:String){ } class MyClass { int index String name } class MyClass(index,name) { shared Integer index; shared String name; } (defstruct MyClass :index :name)
  47. Variables definition • In Kotlin and Scala you can define

    2 types • var myMutableVariable • val myInmutableVariable • In Ceylon we have variable modifier for mutable variable Integer count=0; count++; //OK Integer count=0; count++;//ERROR val name: Type = initializer // final “variable” var name: Type = initializer // mutable variable
  48. Null-safety •Operator ? used in Kotlin,Groovy,Ceylon •Avoid NullPointerException var b

    : String? = "b" b = null // valid null assignment val l = b?.length() Elvis Operator(?:) and Safe navigation (?.) def displayName = user.name ? user.name : "Anonymous“ def streetName = user?.address?.street String? argument = process.arguments.first; if (exists argument) { //checking null values }
  49. Optional Types Optional<Object> optional = findObject(id); //check if Optional object

    has value if (optional.isPresent()) { System.out.println(optional.get()); } Type safe Option[T] in Scala New class java.util.Optional
  50. Optional Type in Scala private val languages = Map(1 ->

    Language(1, "Java", Some("Gosling")), 2 -> Language(2, "Scala", Some("Odersky"))) def findById(id: Int): Option[Language] = languages.get(id) def findAll = languages.values def main(args: Array[String]) { val language = Optional.findById(1) if (language.isDefined) { println(language.get.name) } } val language = Optional.findById(3) None
  51. Optional Type in Scala val languages =Map("Java"->"Gosling","Scala"->"Odersky") languages:scala.collection.immutale.Map[java.lang.String,java.lang.String] languages get

    "Scala" Option[java.lang.String] = Some(Odersky) languages get "Groovy" Option[java.lang.String] = None
  52. Lambdas in streams List<Book> books=Arrays.asList(book,book1,book2); Optional<String> bookFiltered = books.stream() .filter(b

    -> b.getTitle().contains("Groovy")) .map(b -> b.getTitle().toUpperCase()) .findFirst(); val books = Arrays.asList(book,book1,book2) val bookFiltered : String? = books.sequence() .filter { b->b.title.contains("Groovy")} .map { b->b.title.toUpperCase() } .firstOrNull() def bookfilter= books. findAll { b->b.title.contains(" Groovy ") } .sort { b->b.isbn } .collect { b->b.title.toUpperCase() } .find() val bookList = List(book1,book2,book3); val bookFilter = bookList .filter(b=>b.title.contains("Groovy")) .map(book => book.title)
  53. Pattern matching • Is a generalization of Java switch/case def

    generalSize(x: Any) = x match { case s: String => s.length case m: Map[_, _] => m.size case _ => -1 } scala> generalSize("abc") res: Int = 3 scala> generalSize(Map(1 -> 'a', 2 -> 'b')) res: Int = 2 fun fib(n: Int): Int { return when (n) { 1, 2 -> 1 else -> fib(n - 1) + fib(n - 2) } } fun patternMatching(x:Any) { when (x) { is Int -> print(x) is List<*> ->{print(x.size())} is String -> print("String") !is Number -> print("Not even a number") else -> print("can't do anything") } }
  54. Traits vs Java interfaces Traits allow declare method definitions A

    trait is an interface with an implementation(behavior and/or state) Traits support “multiple inheritance” One class can inherit from many traits
  55. Traits.Code in interfaces trait Publication { int number def getNumberPublication(){

    return (number) } } trait Location { String description def getInfoPublication(){ return (description) } } class MyBook implements Publication,Location{ Integer isbn String title def getInfoBook(){ return (isbn+ " "+title) } } trait Publication { def description() = println(“Description”) } class Book(var isbn:Int,var title:String) extends Publication{ def getInfoBook(){ return (isbn+ " "+title) } } trait Publication{ var number:String fun getNumberPublication(){ println(number) } } class Book:Publication { }
  56. Java interoperability object list extends App { import java.util.ArrayList var

    list : ArrayList[String] = new ArrayList[String]() list.add("hello") list.add("world") println(list) } import collection.JavaConversions._ java.util.Arrays.asList(1,2,3). foreach(i =>println(i)) java.util.Arrays.asList(1,2,3). filter(_ % 2 ==0) fun list(source: List<Int>):ArrayList<Int> { val list = ArrayList<Int>() for (item in source) list.add(item) for (i in 0..source.size() - 1) list[i] = source[i] return list } (ns clojure-http-server.core (:require [clojure.string]) (:import (java.net ServerSocket SocketException) (java.util Date) (java.io PrintWriter BufferedReader InputStreamReader BufferedOutputStream)))
  57. Java interoperability import scala.beans.BeanProperty class Language( @BeanProperty var name: String,

    @BeanProperty var author: String) { } public static void main(String[] args) { Language l1 = new Language(“Java",”Gosling”); Language l2 = new Language(“Scala",”Odersky”); ArrayList<Language> list = new ArrayList<>(); list.add(l1); list.add(l2); }
  58. List Partitions • We can use partition over a list

    for obtain 2 lists scala> List(1, 2, 3, 4, 5) partition (_ % 2 == 0) res: (List[Int], List[Int]) = (List(2, 4),List(1, 3, 5)) // partition the values 1 to 10 into a pair of lists of even and odd numbers assertEquals(Pair(listOf(2, 4, 6, 8, 10), listOf(1, 3, 5, 7, 9)), (1..10) .partition{ it % 2 == 0 })
  59. Read file and print lines import scala.io.Source for (line <-

    Source.fromFile(“file.txt”).getLines()) println(line.length +" "+ line) import java.nio.file.*; import java.util.stream.Stream; Path dict = Paths.get(“file.txt”); Stream<String> linesStream = Files.lines(dict); linesStream.forEach(System.out::println); val dict = Paths.get(“file.txt") val linesStream = Files.lines(dict) val lines = linesStream.forEach{println(it)};
  60. Read file and print lines (defn read-file [file] (with-open [rdr

    (clojure.java.io/reader file)] (doseq [line (line-seq rdr)] (println line)))) (read-file (file “file.txt")) Files.lines(Paths.get(“file.txt")).forEach{println it};
  61. Performance in recursion (defn factorial ([x] (trampoline (factorial (dec x)

    x))) ([x a] (if (<= x 1) a #(factorial (dec x) (*' x a))))) @TailRecursive def fact(BigInteger n,acumulator = 1G) { if (n <2){ acumulator }else{ fact(n-1,n*acumulator) } } @scala.annotation.tailrec def factorialrec(fact:BigInt,number:BigInt=1):BigInt = { if (fact<2) return number else factorialrec(fact-1,fact*number) }
  62. Comparing features Higher Order Functions Mixin/traits Pattern matching Implicit casts

    Nullables / Optionals Modules Promote inmutability Lambdas
  63. Palindrome (use 'clojure.java.io) (defn palindrome? [s] (let [sl (.toLowerCase s)]

    (= sl (apply str (reverse sl))))) (defn find-palindromes[s] (filter palindrome? (clojure.string/split s #" "))) fun isPalindrome(s : String) : Boolean { return s== s.reverse() } fun findPalindrome(s:List<String>): List<String>{ return s.filter {isPalindrome(it)}.map {it} } def isPalindrome(x:String) = x==x.reverse def findPalindrome(s:Seq[String]) = s find isPalindrome def isPalindrome(s) { def s1 = s.toLowerCase() s1 == s1.reverse() } def findAllPalindrome(list) { list.findAll{isPalindrome(it)} }
  64. Conclusions Full interoperability with Java Reducing Java verbosity These languages

    allow developer be more productive comparing with java Pragmatic Programmer advice: When you learn a new language, you learn a new way to think.
  65. Resources SCALA • http://www.scala-lang.org • http://www.scalakoans.org • http://scala-ide.org • https://www.coursera.org/course/progfun

    KOTLIN • http://kotlinlang.org • http://kotlin.jetbrains.org • http://kotlin-demo.jetbrains.com • http://github.com/Jetbrains/kotlin
  66. Resources CLOJURE • http://www.tryclj.com • http://clojuredocs.org • http://www.clojure-toolbox.com • http://www.clojureatlas.com

    CEYLON • https://modules.ceylon-lang.org
  67. Resources • http://vschart.com/compare/kotlin/vs/clojure/vs/scala

  68. Book • Seven Languages in Seven Weeks • A Pragmatic

    Guide to Learning Programming Languages • https://pragprog.com/book/btlang/seven-languages-in-seven-weeks • Ruby • Io • Prolog • Scala • Erlang • Clojure • Haskell
  69. Thank you! José Manuel Ortega Candel | @jmortegac