Polyglot Programming in the JVM - Øredev
1 like974 views
This document discusses polyglot programming on the Java Virtual Machine (JVM). It begins by introducing the speaker and their experience with Java and JVM languages like Groovy, Scala, and Clojure. It then discusses how while Java is powerful, it can be verbose and lack modern features. Other JVM languages reduce verbosity, support closures and enhanced switch statements, and have a richer type system. These languages also have full interoperability with Java. The document provides examples of polyglot programming in areas like web apps, databases, and build systems. It concludes by encouraging experimenting with JVM languages and provides additional resources.
![CLOSURES (OR FUNCTIONS)
(defn adder [a b] (+ a b))](https://image.slidesharecdn.com/oredevpolyglotprogrammingv2-1-121108104129-phpapp02/85/Polyglot-Programming-in-the-JVM-Oredev-22-320.jpg)
![ENHANCED SWITCH
def letterGrade(grade) {
switch(grade) {
case 90..100: return ‘A‘
case 80..<90: return ‘B‘
case 70..<80: return ‘C‘
case 60..<70: return ‘D‘
case 0..<60: return ‘F‘
case ~"[ABCDFabcdf]":
return grade.toUpperCase()
}
throw new IllegalArgumentException(‘invalid
grade ‘+grade)
}](https://image.slidesharecdn.com/oredevpolyglotprogrammingv2-1-121108104129-phpapp02/85/Polyglot-Programming-in-the-JVM-Oredev-24-320.jpg)
![ENHANCED SWITCH
(defn letter-grade [grade]
(cond
(in grade 90 100) "A"
(in grade 80 90) "B"
(in grade 70 80) "C"
(in grade 60 70) "D"
(in grade 0 60) "F"
(re-find #"[ABCDFabcdf]" grade) (.toUpperCase
grade)))](https://image.slidesharecdn.com/oredevpolyglotprogrammingv2-1-121108104129-phpapp02/85/Polyglot-Programming-in-the-JVM-Oredev-26-320.jpg)
Polyglot Programming in the JVM - Øredev
- 1. POLYGLOT PROGRAMMING IN THE JVM Or how I Learned to Stop Worrying and Love the JVM Andres Almiray | Canoo Engineering AG @aalmiray
- 2. ABOUT THE SPEAKER Java developer since the beginning True believer in open source Groovy committer since 2007 Project lead of the Griffon framework Currently working for
- 3. SOME FACTS ABOUT JAVA Previous name was Oak. Bonus points for knowing its real name before that Made its public appearance in 1995 C/C++ were king at the time Networking, multithreading were baked right into the language Developers came for the applets and stayed for the components (JEE and all that jazz)
- 4. HOWEVER... It‘s already in its teens It has not seen a groundbreaking feature upgrade since JDK5 was released back in 2004 -> generics (and we do know how that turned out to be, don’t we?) JDK7 was delayed again (late 2010, actual 2011). Some features did not make the cut (lambdas) JDK8, late 2013?
- 5. MORE SO... It is rather verbose when compared to how other languages do the same task Its threading features are no longer enough. Concurrent programs desperately cry for immutability these days
- 6. TRUTH OR MYTH? Is Java oftenly referred as overengineered? Can you build a Java based web application (for arguments sake a basic Twitter clone) in less than a day‘s work WITHOUT an IDE? Did James Gosling ever say he was threatened with bodily harm should operator overloading find its way into Java?
- 7. The JVM is a great place to work however Java makes it painful sometimes...
- 8. What can we do about it?!
- 11. DISCLAIMER (THIS IS NOT A BASH-THE-OTHER- LANGUAGES TALK)
- 13. STANDARD BEANS public class Bean { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } }
- 14. STANDARD BEANS public class Bean { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } }
- 15. STANDARD BEANS class Bean { String name }
- 16. STANDARD BEANS class Bean(var name:String) class Bean { @scala.reflect.BeanProperty var name: String }
- 17. STANDARD BEANS (defstruct Bean :name)
- 18. CLOSURES (OR FUNCTIONS) public interfaceAdder { int add(int a, int b); } public class MyAdder implements Adder { public int add(int a, int b) { return a + b; } }
- 19. CLOSURES (OR FUNCTIONS) // JDK7^H8 Closures proposal (int a, int b)(a + b) #(int a, int b) { return a + b; } (int a, int b) -> a + b
- 20. CLOSURES (OR FUNCTIONS) def adder = { a , b -> a + b }
- 21. CLOSURES (OR FUNCTIONS) val adder = (a:Int, b:Int) => a + b
- 22. CLOSURES (OR FUNCTIONS) (defn adder [a b] (+ a b))
- 23. ENHANCED SWITCH char letterGrade(int grade) { if(grade >= 0 && grade <= 60) return ‘F‘; if(grade > 60 && grade <= 70) return ‘D‘; if(grade > 70 && grade <= 80) return ‘C‘; if(grade > 80 && grade <= 90) return ‘B‘; if(grade > 90 && grade <= 100) return ‘A‘; throw new IllegalArgumentException(“invalid grade “+grade); }
- 24. ENHANCED SWITCH def letterGrade(grade) { switch(grade) { case 90..100: return ‘A‘ case 80..<90: return ‘B‘ case 70..<80: return ‘C‘ case 60..<70: return ‘D‘ case 0..<60: return ‘F‘ case ~"[ABCDFabcdf]": return grade.toUpperCase() } throw new IllegalArgumentException(‘invalid grade ‘+grade) }
- 25. ENHANCED SWITCH val VALID_GRADES = Set("A", "B", "C", "D", "F") def letterGrade(value: Any):String = value match { case x:Int if (90 to 100).contains(x) => "A" case x:Int if (80 to 90).contains(x) => "B" case x:Int if (70 to 80).contains(x) => "C" case x:Int if (60 to 70).contains(x) => "D" case x:Int if (0 to 60).contains(x) => "F" case x:String if VALID_GRADES(x.toUpperCase) => x.toUpperCase() }
- 26. ENHANCED SWITCH (defn letter-grade [grade] (cond (in grade 90 100) "A" (in grade 80 90) "B" (in grade 70 80) "C" (in grade 60 70) "D" (in grade 0 60) "F" (re-find #"[ABCDFabcdf]" grade) (.toUpperCase grade)))
- 28. ALL OF THESE ARE TRUE Java can call Groovy, Scala and Clojure classes as if they were Java classes Groovy, Scala and Clojure can call Java code without breaking a sweat In other words, interoperability with Java is a given. No need for complicated bridges between languages (i.e. JSR 223)
- 29. OK, SO... WHAT ELSE CAN THESE LANGUAGES DO?
- 30. ALL OF THEM Native syntax for collection classes Everything is an object Closures! Regular expressions as first class citizen
- 31. GROOVY Metaprogramming (HOT!) both at buildtime and runtime Builders Operator overloading Healthy ecosystem: Grails, Griffon, Gant, Gradle, Spock, Gaelyk, Gpars, CodeNarc, etc... Not an exhaustive list of features!
- 32. SCALA Richer type system Functional meets Object Oriented Type inference Pattern matching (+ case classes) Actor model Create your own operator Traits Not an exhaustive list of features!
- 33. CLOJURE Data as code and viceversa Immutable structures STM Not an exhaustive list of features!
- 34. DEMO
- 37. OTHER PLACES WHERE YOU‘LL FIND POLYGLOT PROGRAMMING
- 39. NEXT-GEN DATASTORES (NOSQL) FleetDB -> Clojure FlockDB -> Scala CouchDB, Riak -> Erlang By the way, watch out for Polyglot Persistence ;-)
- 40. BUILD SYSTEMS Gradle, Gant -> Groovy Rake -> Ruby/JRuby Maven3 -> XML, Groovy, Ruby SBT -> Scala Leiningen -> Clojure
- 41. PARTING THOUGHTS Java (the language) may have reached its maturity feature wise Other JVM languages have evolved faster Polyglot Programming is not a new concept Download and play with each of the demoed languages, maybe one of them strikes your fancy
- 42. RESOURCES
- 43. RESOURCES
- 44. RESOURCES
- 45. Q&A
- 46. THANK YOU!