Programming Tools: Java Scripting Languages

What's new with Jython and a look at the latest Java scripting language, Groovy.
Closures and Anonymous Classes

Groovy's documentation provides an example that illustrates the benefits of using closures in place of anonymous classes. Using an anonymous class, we can write:

Button b = new Button ("Push Me");
  b.onClick (new Action() {
    public void execute (Object target)

Using a closure, this becomes:

Button b = new Button ("Push Me");
  b.onClick { buttonClicked() }

Another nice feature of Groovy is its "each" operator, which is used to iterate over a collection:

SomeCollection stuff = new SomeCollection();
  stuff.each() someClosure

// for example:

def myList = [1,2,4,5,6]
myList.each { println it }  // where 'it' is current collection item

// outputs:


Groovy also has built-in structured "builders" for languages such as XML, HTML and more. Again, a simple example illustrates how natural it is to build structured text:

xml = new groovy.xml.MarkupBuilder()
def myList = ['acct1':['id':123111, 'type':'savings', 'balance':1234.56],
              'acct2':['id':221212, 'type':'checking', 'balance':2010.02]]
doc = xml.accounts() {
  for (entry in myList)
    acct(id:entry.key) {
      for (thing in entry.value)
        item(name:thing.key, type=thing.value)

This small code fragment outputs:

  <acct id='acct2'>
    <item name='type'>checking</item>
    <item name='id'>221212</item>
    <item name='balance'>2010.02</item>
  <acct id='acct1'>
    <item name='type'>savings</item>
    <item name='id'>123111</item>
    <item name='balance'>1234.56</item>

Contrasting Jython and Groovy


In the following example, the use of variable c is caught at compile time in a statically defined language. Only when a is greater than b is the use of the undefined variable, c, detected in an interpreted language.

a = 1
b = 2
if a > b:
  print c
print a,b

Another major difference between a compiled language and an interpreted one is when things are bound to their references. In Groovy, the following code prints "Bound to local variable":

def varA = "Bound to global variable"
def closure = { varA }
public class C {
  def varA = "Bound to local variable"
  def closure = { varA }  // bound to local varA at definition time
  public def f = closure  // f bound to local closure
def c = new C();          // create instance of C using new
println c.f()             // invoke f in C

in Jython, the equivalent-looking code prints "Bound to global variable":

varA = "Bound to global variable"
closure = lambda: varA
class C:
  varA = "Bound to local variable"
  closure = lambda self: varA
  f = closure
c = C()
print c.f()

For those wanting more flexibility, the Jython/Python bindings are handier. For those wanting more stability, the Groovy implementation may be more desirable.


Currying function arguments is another difference. Groovy has a special "curry" mechanism to bind arguments to a function. In the following example, "foo bar" is printed:

def c = { arg1, arg2-> println "${arg1} ${arg2}" }
def d = c.curry("foo")

Jython inherits Python's natural ability to curry arguments using a number of techniques. One is:

def c(arg1, arg2): print arg1,arg2
def d(arg2): c("foo",arg2)


Jython has been around a long time and is based on a mature language, Python. However, its development has stalled in recent years. Groovy is a relatively new language and thus still is developing. For example, its error diagnostics leave a lot to be desired. Also, at the moment, Groovy's following is much smaller than Jython's or Python's. However, both languages are picking up development activity, so you have a chance to influence both languages if you want to become involved.



Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

a sign of dynamic typing is

Anonymous's picture

a sign of dynamic typing is the following (groovy code):

def foo(String s) {"String"}
def foo(Object o) {"Object"}

def obj = "obj"
assert foo(obj) == "String"

Object obj2 = "obj"
assert foo(obj2) == "String"

both, obj and obj2 have the static type java.lang.Object when viewed from Java, but for the function call the type String is used, as this is the runtime/dynamic type. So Groovy does have dynamic typing.

A compile step is not a sign of the typing mechanism.

What about BeanShell?

Paulo Marquez's picture

Sometimes I wonder whether I am the only person in the world who uses BeanShell, It's a java interpreter written in java and uses java syntax (have I written "java" too many times? ;) .)

I think there are two nice advantages when using BeanShell:
1) The programmer does not have to learn new syntax.
2) If desired, a more script-like syntax can be used.

Also BeanShell scripts can have acess to every object within the host application, can acess all of the available java classes and runs at the VM speed (it just means I like it a lot :) .)

I am not trying to make a case for BeanShell, I'm just curious to know why BeanShell has not gotten more coverage in "Java Scripting Languages" articles and learn more about the comparative advantages of using a diferent approach to java scripting.


Brandon Keepers's picture

By the way, JavaScript has nothing to do with the Java language, so it is not considered here.

Historically, this statement is correct, but that is about to change. Mazilla has a javascript implementation in Java called Rhino that is slated to be included in the next major release of the JVM. And we had just convinced everyone that Java and JavaScript are not the same....


Dennis Decker Jensen's picture

Nice Article! I couldn't help but think about NetRexx which is Rexx built for a JVM. Rexx is an old classic scripting language from mainframes, OS/2, Amiga, Unix (sic!). It would be nice to also hear about Rexx's uses in this context, i.e. JVM scripting languages!


Good article. About your ver

Anonymous's picture

Good article. About your very last sentence, if someone wants to actually influence development and design decisions, go with groovy. Jython isn't going to be influenced by anyone, because it is meant to be an exact clone of CPython, nothing more, nothing less (same way with IronPython for .NET).

For those comfortable with statically typed languages, scala ( and nice ( have some really fascinating features.

Good article; a few typos

Anonymous's picture

I enjoyed the article. I had heard of Groovy, but not seen any examples. While the examples shown here are small, they do at least provide a little bit of flavor as to what the language is like.

There are some typos, however. In the section on Closures, there is obviously some markup intermixed in the first code example. Then in the immediately following paragraph, the word "each" should have double quotes around it, but only the first one is there.

Geek Guide
The DevOps Toolbox

Tools and Technologies for Scale and Reliability
by Linux Journal Editor Bill Childers

Get your free copy today

Sponsored by IBM

Upcoming Webinar
8 Signs You're Beyond Cron

Scheduling Crontabs With an Enterprise Scheduler
11am CDT, April 29th
Moderated by Linux Journal Contributor Mike Diehl

Sign up now

Sponsored by Skybot