Jeff Brown – SpringSource

Polyglot?

• "many languages"
• writing software in multiple languages
• some people would say if you do any web development, you're doing polyglot
  • javascript, css, html, java, etc.
• in the context of this talk, we'll be talking about implementing the actual business logic with multiple languages

Languages on the JVM

• 200+ languages available on the JVM
• many of these aren't exactly practical, but many are
• at least 10-12 programming languages available on the JVM that could be used for serious development
• big players are java, groovy, clojure, scala, jruby, jython
• which of these is the best? no answer of course
  • personal preference, best tool for the job, etc.
• many of these languages solve specific problems really well
• all these languages are turing complete, so anything you can do in one you can do in another
• but depending on the problem you're trying to solve, you may find one language or another is ideally suited to the task at hand
• reached a point with CPU development where the speed of light is a factor in terms of increasing the speed
  • can't really make processors any faster with the current method of developing processors
  • instead of making faster processors, we're using more processors and multiple cores
• concurrency is becoming more and more important
• OO languages don't lend themselves to managing concurrency very well
  • allocate objects on the heap, objects in a shared mutable state
  • best we can do in OO languages is use locks so multiple threads can't access things at the same time
  • problem with locking is it's opt-in
• functional languages make the concurrency problem almost disappear
  • no such thing as destructive assignment in a pure functional language
  • clojure and scala *do* allow destructive assignment
  • but in clojure, for example, you have to do this in a transaction
    • get a snapshot of the heap, and nothing can change on the heap while you're making changes
• because of the advantages in terms of concurrency, it will be more common to use polyglot programming moving forward
  • e.g. write much of the application in groovy, but build parts of the application using a functional language
• ultimately all this will run on the jvm, but we can take advantage of the best things each language has to offer
• pretty different from the past–would have been rather unusual to write a C++ program that had other languages mixed in

Grails?

• full stack MVC platform for the JVM
  • build system down to ORM, etc.
• leverages proven staples
  • spring, hibernate, groovy, quartz, java, sitemesh
• extensible plugin system
  • e.g. can pull out hibernate and use a different persistence mechanism, or can write your own plugins
• since grails is built on the jvm you can take advantage of any language that will run on the jvm

Demo

• showing how to write a grails app that uses a groovy controller, but a "math helper" class can be written in groovy, or java, or clojure
• as long as there's a bean in the spring context, regardless of language, it can be injected into grails controllers
• the grails controller doesn't care what language the classes it uses are written in

Clojure

• core grails doesn't have clojure support, but there's a clojure plugin
• plugin creates an src/clj file for clojure source
• code in the grails controller doesn't have to change to take advantage of the math helper written in the different languages


(ns grails)
(defn addNumbers [x y]
  (+ x y ))


Using the Clojure Plugin

• call via clj.mathHelper.addNumbers(x, y)
• clj is the same as calling getClj()
• the cloure plugin adds the getCjl method to all of the grails classes
  • classes*.metaClass*."getClj" = { return proxy } — this is done in the withDynamicProperties method in the plugin config
  • the proxy is an instance of the clojure proxy class (grails.clojure.ClojureProxy)
• no addNumbers method in the proxy class — uses methodMissing
• plugin looks for clojure methods in the grails namespace by default
  • if you need another namespace, clj['mynamespace'].methodName() will handle this
• clojure plugin declares that it wants to watch all the files in src/clj
  • gets notified when files change and compiles the files if they change
• if your plugin is adding things to the metaclasses on application startup, then you need to make sure your plugin also modifies controllers, services, etc. as they're changed while the application is running
• can also observe only specific plugins for changes, e.g. only notify me when something involved with hibernate changes
• can swap out other view technologies in grails
• for taglibs, they have to be written in groovy, but inside the taglib you could be making calls to code in other languages

Who gets the credit?

• grails? groovy? clojure? java? the jvm?
• really it's the combination of all of them
• don't have to walk away from grails to take advantage of any of the languages that run on the jvm