for f in d[2] if f.endswith(".java")]

<p>This chapter looks at the value of crossing language boundaries. It is often

advantageous to solve a problem using more than one programming language, rather

than being arbitrarily stuck using a single language. As you’ll see in this

chapter, a problem that is very difficult or tedious to solve in one language

can often be solved quickly and easily in another. If you can combine the use of

languages, you can create your product much more quickly and cheaply.</p>

<p>The most straightforward use of this idea is the <em>Interpreter</em> design

pattern, which adds an interpreted language to your program to allow

the end user to easily customize a solution. If the application user

needs greater run time flexibility, for example to create scripts

describing the desired behavior of the system, you can use

<em>Interpreter</em> by creating and embedding a language interpreter into

your program.</p>

<p><em>Interpreter</em> solves a particular problem – that of creating a

scripting language for the user. But sometimes it’s just easier and

faster to temporarily step into another language to solve a particular

aspect of your problem. You’re not creating an interpreter, you’re

just writing some code in another language.</p>

<div class="section" id="interpreter-motivation">

<h2>Interpreter Motivation<a class="headerlink" href="#interpreter-motivation" title="Permalink to this headline">¶</a></h2>

<p>Remember that each design pattern allows one or more factors to change, so it’s

important to first be aware of which factor is changing. Sometimes the end users

of your application (rather than the programmers of that application) need

complete flexibility in the way that they configure some aspect of the program.

That is, they need to do some kind of simple programming. The interpreter

pattern provides this flexibility by adding a language interpreter.</p>

<p>The problem is that developing your own language and building an interpreter is

a time-consuming distraction from the process of developing your application.

You must ask whether you want to finish writing your application or create a new

language.  The best solution is to reuse code: embed an interpreter that’s

already been built and debugged for you. The Python language can be freely

embedded into your for-profit application without signing any license agreement,

paying royalties, or dealing with strings of any kind. There are basically no

restrictions at all when you’re using Python.</p>

<p>For solving Java problems, we will look at a special version of Python called

Jython. This is generated entirely in Java byte codes, so incorporating it into

your application is quite simple,  and it’s as portable as Java is. It has an

extremely clean interface with Java: Java can call Python classes, and Python

can call Java classes.</p>

<p>Python is designed with classes from the ground up and is a truly pure object

oriented language (both C++ and Java violate purity in various ways). Python

scales up so that you can create very big programs without losing control of the

code. Java projects have been quickly created using Jython, then later optimized by

rewriting sections of the Jython code that have profiled as bottlenecks into Java.</p>

</div>

<p>One very compelling benefit of using a dynamic language on the JVM is

<p>Note that things that require much more code (and often research) in

Java are very quick to write in Jython. Here’s an example that uses

a Python <em>list comprehension</em> with the <strong>os.walk()</strong> function to visit

all the directories in a directory tree, and find all the files with names

that end in <strong>.java</strong> (of course you can easily do more sophisticated things

like opening the file and looking for information within it):</p>

             <span class="k">for</span> <span class="n">f</span> <span class="ow">in</span> <span class="n">d</span><span class="p">[</span><span class="mf">2</span><span class="p">]</span> <span class="k">if</span> <span class="n">f</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="s">".java"</span><span class="p">)]</span>

<h2>Creating a Language<a class="headerlink" href="#creating-a-language" title="Permalink to this headline">¶</a></h2>

language is the ideal solution.  This is often called a

<em>domain-specific language</em> (DSL) because it solves a particular

domain problem.</p>

<p>The constructor of each derived class calls the base-class constructor, which

adds the new object to the list. The <strong>run()</strong> function sorts the list, which

automatically uses the <strong>__cmp__()</strong> method defined in <strong>Event</strong> to

base comparisons on time only. In this example, it only prints out the list, but

in the real system it would wait for the time of each event to come up and then

run the event.</p>

module that can be included in another Python program.

But instead of using it in an ordinary Python program,

let’s use Jython, inside of Java. This turns out to be remarkably

simple: you import some Jython classes, create a <strong>PythonInterpreter</strong>

object, and cause the Python files to be loaded:</p>

<p>The <strong>PythonInterpreter</strong> object is a complete Python interpreter that accepts

commands from the Java program. One of these commands is <strong>execfile()</strong>, which

tells it to execute all the statements it finds in a particular file. By

executing <strong>GreenHouseLanguage.py</strong>, all the classes from that file are loaded

into our <strong>PythonInterpreter</strong> object, and so it now “holds” the greenhouse

controller language. The <strong>Schedule.ghs</strong> file is the one created by the end

user to control the greenhouse. Here’s an example:</p>

<p>This is the goal of the interpreter design pattern: to make the configuration of

your program as simple as possible for the end user. With Jython you can achieve

this with almost no effort at all.</p>

<p>Jython wraps the Java libraries so that any of them can be used directly or via

inheritance. In addition, Python shorthand simplifies coding.</p>

<p>As an example, consider the <strong>HTMLButton.java</strong> example from

<em>Thinking in Java</em>. Here is its conversion to Jython:</p>

implementation, you’ll see that Jython is shorter and generally easier to

understand. For example, to set up the frame in the Java version you had to make

several calls: the constructor for <strong>JFrame()</strong>, the <strong>setVisible()</strong> method

and the <strong>setDefaultCloseOperation()</strong> method, whereas in the above code all

three of these operations are performed with a single constructor call.</p>

<p>Also notice that the <strong>JButton</strong> is configured with an <strong>actionListener()</strong>

method inside the constructor, with the assignment to <strong>kapow</strong>. In addition,

Jython’s JavaBean awareness means that a call to any method with a name that

begins with “<strong>set</strong>” can be replaced with an assignment, as you see above.</p>

<p>The only method that did not come over from Java is the <strong>pack()</strong> method,

which seems to be essential in order to force the layout to happen properly.

It’s also important that the call to <strong>pack()</strong> appear <em>before</em> the <strong>size</strong>

setting.</p>

<p><strong>MyDialog</strong> is inherited from <strong>JDialog</strong>, and you can see named arguments

being used in the call to the base-class constructor.</p>

<p>In the creation of the “OK” <strong>JButton</strong>, note that the <strong>actionPerformed</strong>

method is set right inside the constructor, and that the function is created

using the Python <strong>lambda</strong> keyword. This creates a nameless function with the

arguments appearing before the colon and the expression that generates the

returned value after the colon. As you should know, the Java prototype for the

<strong>actionPerformed()</strong> method only contains a single argument, but the lambda

expression indicates two. However, the second argument is provided with a

default value, so the function <em>can</em> be called with only one argument. The

reason for the second argument is seen in the default value, because this is a

way to pass <strong>self</strong> into the lambda expression, so that it can be used to

dispose of the dialog.</p>

<p>Compare this code with the version that’s published in <em>Thinking in Java</em>.

You’ll find that Python language features allow a much more succinct and direct

implementation.</p>

<div class="admonition-todo admonition " id="todo-20">

<p>Note that the <strong>import</strong> statements map to the Java package structure exactly as

you would expect. In the first example, a <strong>Date()</strong> object is created as if it

were a native Python class, and printing this object just calls <strong>toString()</strong>.</p>

<p><strong>ValGen</strong> implements the concept of a “generator” which is used a great deal in

the C++ STL (<em>Standard Template Library</em>, part of the Standard C++ Library). A

generator is an object that produces a new object every time its “generation

method” is called, and it is quite convenient for filling containers. Here, I

wanted to use it in a <strong>for</strong> iteration, and so I needed the generation method

to be the one that is called by the iteration process. This is a special method

called <strong>__getitem__()</strong>, which is actually the overloaded operator for

indexing, ‘<strong>[ ]</strong>‘. A <strong>for</strong> loop calls this method every time it wants to

move the iteration forward, and when the elements run out, <strong>__getitem__()</strong>

throws an out-of-bounds exception and that signals the end of the <strong>for</strong> loop

(in other languages, you would never use an exception for ordinary control flow,

but in Python it seems to work quite well). This exception happens automatically

when <strong>self.val[i]</strong> runs out of elements, so the <strong>__getitem__()</strong> code turns

out to be simple. The only complexity is that <strong>__getitem__()</strong> appears to

return <em>two</em> objects instead of just one. What Python does is automatically

package multiple return values into a tuple, so you still only end up returning

a single object (in C++ or Java you would have to create your own data structure

to accomplish this). In addition, in the <strong>for</strong> loop where <strong>ValGen</strong> is used,

Python automatically “unpacks” the tuple so that you can have multiple iterators

in the <strong>for</strong>. These are the kinds of syntax simplifications that make Python

so endearing.</p>

<p>The <strong>jmap</strong> and <strong>jset</strong> objects are instances of Java’s <strong>HashMap</strong> and

<strong>HashSet</strong>, again created as if those classes were just native Python

components. In the <strong>for</strong> loop, the <strong>put()</strong> and <strong>add()</strong> methods work just

like they do in Java. Also, indexing into a Java <strong>Map</strong> uses the same notation

as for dictionaries, but note that to iterate through the keys in a <strong>Map</strong> you

must use the <strong>Map</strong> method <strong>keySet()</strong> rather than the Python dictionary

method <strong>keys()</strong>.</p>

<p>The final part of the example shows the use of a Java class that I created from

scratch, to demonstrate how trivial it is. Notice also that Jython intuitively

understands JavaBeans properties, since you can either use the <strong>getVal()</strong> and

<strong>setVal()</strong> methods, or assign to and read from the equivalent <strong>val</strong>

property. Also, <strong>getChars()</strong> returns a <strong>Character[]</strong> in Java, and this

automatically becomes an array in Python.</p>

<p>The easiest way to use Java classes that you create for use inside a Python

program is to put them inside a package. Although Jython can also import

unpackaged java classes (<strong>import JavaClass</strong>), all such unpackaged java classes

will be treated as if they were defined in different packages so they can only

see each other’s public methods.</p>

<p>Java packages translate into Jython modules, and Jython must import a module in

order to be able to use the Java class. Here is the Java code for <strong>JavaClass</strong>:</p>

<p>You can see that this is just an ordinary Java class, without any awareness that

it will be used in a Jython program. For this reason, one of the important uses

of Jython is in testing Java code <a class="footnote-reference" href="#id4" id="id2">[2]</a>. Because Python is such a powerful,

flexible, dynamic language it is an ideal tool for automated test frameworks,

without making any changes to the Java code that’s being tested.</p>

<p>Inner classes becomes attributes on the class object. Instances of <strong>static</strong>

inner classes can be created with the usual call:</p>

<p>Non-<strong>static</strong> inner classes must have an outer class instance supplied

explicitly as the first argument:</p>

<p>In the rest of this chapter, we shall look at more sophisticated ways to

interact with Jython. The simplest way to exercise more control over the

<strong>PythonInterpreter</strong> object from within Java is to send data to the

interpreter, and pull data back out.</p>

<p>To inject data into your Python program, the <strong>PythonInterpreter</strong> class has a

deceptively simple method: <strong>set()</strong>. However, <strong>set()</strong> takes many different

data types and performs conversions upon them.  The following example is a

reasonably thorough exercise of the various <strong>set()</strong> possibilities, along with

comments that should give a fairly complete explanation:</p>

<p>As usual with Java, the distinction between real objects and primitive types

causes trouble. In general, if you pass a regular object to <strong>set()</strong>, it knows

what to do with it, but if you want to pass in a primitive you must perform a

conversion. One way to do this is to create a “Py” type, such as <strong>PyInteger</strong>

or <strong>PyFloat</strong>. but it turns out you can also use Java’s own object wrappers

like <strong>Integer</strong> and <strong>Float</strong>, which is probably going to be a lot easier to

remember.</p>

<p>Early in the program you’ll see an <strong>exec()</strong> containing the Python statement:</p>

<p>The colon inside the indexing statement indicates a Python <em>slice</em>, which

produces a range of elements from the original array. In this case, it produces

an array containing the elements from number 5 until the end of the array. You

could also say ‘<strong>a[3:5]</strong>‘ to produce elements 3 through 5, or ‘<strong>a[:5]</strong>‘ to

produce the elements zero through 5. The reason a slice is used in this

statement is to make sure that the Java <strong>String</strong> has really been converted to

a Python string, which can also be treated as an array of characters.</p>

<p>You can see that it’s possible, using <strong>exec()</strong>, to create a Python function

(although it’s a bit awkward). The <strong>prt()</strong> function prints the whole array,

and then (to make sure it’s a real Python array), iterates through each element

of the array and prints it. Finally, it prints the class of the array, so we can

see what conversion has taken place (Python not only has run-time type

information, it also has the equivalent of Java reflection). The <strong>prt()</strong>

function is used to print arrays that come from each of the Java primitive

types.</p>

<p>Although a Java <strong>ArrayList</strong> does pass into the interpreter using <strong>set()</strong>,

and you can index into it as if it were an array, trying to create a slice

fails. To completely convert it into an array, one approach is to simply extract

a Java array using <strong>toArray()</strong>, and pass that in. The <strong>set()</strong> method

converts it to a <strong>PyArray</strong> – one of the classes provided with Jython – which

can be treated as a Python array (you can also explicitly create a <strong>PyArray</strong>,

but this seems unnecessary).</p>

<p>Finally, a <strong>Map</strong> is created and passed directly into the interpreter. While it

is possible to do simple things like index into the resulting object, it’s not a

real Python dictionary so you can’t (for example) call the <strong>keys()</strong> method.

There is no straightforward way to convert a Java <strong>Map</strong> into a Python

dictionary, and so I wrote a utility called <strong>toPyDictionary()</strong> and made it a

<strong>static</strong> method of <strong>net.mindview.python.PyUtil</strong>. This also includes

utilities to extract a Python array into a Java <strong>List</strong>, and a Python

dictionary into a Java <strong>Map</strong>:</p>

<strong>PythonInterpreter</strong>. If you simply call the <strong>get()</strong> method, passing it the

object identifier as a string, it returns a <strong>PyObject</strong> (part of the

<strong>org.python.core</strong> support classes). It’s possible to “cast” it using the

<strong>__tojava__()</strong> method, but there are better alternatives:</p>

<li>The convenience methods in the <strong>Py</strong> class, such as <strong>py2int()</strong>, take a

<strong>PyObject</strong> and convert it to a number of different types.</li>

<li>An overloaded version of <strong>get()</strong> takes the desired Java <strong>Class</strong> object

as a second argument, and produces an object that has that run-time type (so you

still need to perform a cast on the result in your Java code).</li>

<p>Using the second approach, getting an array from the <strong>PythonInterpreter</strong> is

quite easy. This is especially useful because Python is exceptionally good at

manipulating strings and files, and so you will commonly want to extract the

results as an array of strings. For example, you can do a wildcard expansion of

file names using Python’s <strong>glob()</strong>, as shown further down in the following

<p>The last two examples show the extraction of Python tuples and lists into Java

<strong>List</strong>s, and Python dictionaries into Java <strong>Map</strong>s. Both of these cases

require more processing than is provided in the standard Jython library, so I

have again created utilities in <strong>net.mindview.pyton.PyUtil</strong>: <strong>toList()</strong> to

produce a <strong>List</strong> from a Python sequence, and <strong>toMap()</strong> to produce a <strong>Map</strong>

from a Python dictionary. The <strong>PyUtil</strong> methods make it easier to take

important data structures back and forth between Java and Python.</p>

<p>It’s also worth noting that you can have multiple <strong>PythonInterpreter</strong> objects

in a program, and each one has its own name space:</p>

<p>When you run the program you’ll see that the value of <strong>a</strong> is distinct within

each <strong>PythonInterpreter</strong>.</p>

<p>To produce Java classes from Python code, Jython comes with a compiler called

<strong>jythonc</strong>.</p>

<p>The Python definition doesn’t specify any return type, but the @sig string gives

the full type information about what is being passed and returned. The

<strong>jythonc</strong> compiler uses this information to generate the correct Java code.</p>

<p>There’s one other set of rules you must follow in order to get a successful

compilation: you must inherit from a Java class or interface in your Python

class (you do not need to specify the <strong>@sig</strong> signature for methods defined in

the superclass/interface). If you do not do this, you won’t get your desired

methods – unfortunately, <strong>jythonc</strong> gives you no warnings or errors in this

case, but you won’t get what you want. If you don’t see what’s missing, it can

be very frustrating.</p>

<p>In addition, you must import the appropriate java class and give the correct

package specification.  In the example below, <strong>java</strong> is imported so you must

inherit from <strong>java.lang.Object</strong>, but you could also say <strong>from java.lang

import Object</strong> and then you’d just inherit from <strong>Object</strong> without the package

specification. Unfortunately, you don’t get any warnings or errors if you get

this wrong, so you must be patient and keep trying.</p>

<p>Here is an example of a Python class created to produce a Java class. This also

introduces the ‘<strong>=T</strong>‘ directive for the makefile builder tool, which specifies

a different target than the one that is normally used by the tool. In this case,

the Python file is used to build a Java <strong>.class</strong> file, so the class file is

the desired target:</p>

<p>First note that <strong>PythonToJavaClass</strong> is inherited from <strong>java.lang.Object</strong>; if

you don’t do this you will quietly get a Java class without the right

signatures. You are not required to inherit from <strong>Object</strong>; any other Java

class will do.</p>

<p>This class is designed to demonstrate different  arguments and return values, to

provide you with enough examples that you’ll be able to easily create your own

signature strings. The first three of these are fairly self-explanatory, but

note the full qualification of the Java name in the signature string.</p>

<p>In <strong>returnArray()</strong>, a Python array must be returned as a Java array. To do

this, the Jython <strong>array()</strong> function (from the <strong>jarray</strong> module) must be

used, along with the type of the class for the resulting array. Any time you

need to return an array to Java, you must use <strong>array()</strong>, as seen in the

methods <strong>ints()</strong> and <strong>doubles()</strong>.</p>

<p>The last methods show how to pass arguments in from Java. Basic types happen

automatically as long as you specify them in the <strong>@sig</strong> string, but you must

use objects and you cannot pass in primitives (that is, primitives must be

ensconced in wrapper objects, such as <strong>Integer</strong>).</p>

<p>In <strong>argIn3()</strong>, you can see that a Java <strong>List</strong> is transparently converted to

something that behaves just like a Python array, but is not a true array because

you cannot take a slice from it. If you want a true Python array, then you must

create and pass a <strong>PyArray</strong> as in <strong>argIn4()</strong>, where the slice is

successful. Similarly, a Java <strong>Map</strong> must come in as a <strong>PyDictionary</strong> in

order to be treated as a Python dictionary.</p>

straightforward, as <strong>PythonToJavaClass</strong> appears, from the Java side, to be

just another Java class. <strong>dumpClassInfo()</strong> uses reflection to verify that the

method signatures specified in <strong>PythonToJavaClass.py</strong> have come through

properly.</p>

<p>Part of the trick of creating Java classes from Python code is the @sig

information in the method documentation strings. But there’s a second problem

which stems from the fact that Python has no “package” keyword – the Python

equivalent of packages (modules) are implicitly created based on the file name.

However, to bring the resulting class files into the Java program, <strong>jythonc</strong>

must be given information about how to create the Java package for the Python

code. This is done on the <strong>jythonc</strong> command line using the <strong>–package</strong> flag,

followed by the package name you wish to produce (including the separation dots,

just as you would give the package name using the <strong>package</strong> keyword in a Java

program). This will put the resulting <strong>.class</strong> files in the appropriate

subdirectory off of the current directory. Then you only need to import the

package in your Java program, as shown above (you’ll need ‘<strong>.</strong>‘ in your

CLASSPATH in order to run it from the code directory).</p>

<p>Here are the <strong>make</strong> dependency rules that I used to build the above example

(the backslashes at the ends of the lines are understood by <strong>make</strong> to be line

continuations):</p>

<strong>TestPythonToJavaClass.java</strong> and the <strong>PythonToJavaClass.class</strong>, which is the

Python code that’s converted to a class file. This latter, in turn, depends on

the Python source code. Note that it’s important that the directory where the

target lives be specified, so that the makefile will create the Java program

with the minimum necessary amount of rebuilding.</p>

<p>This chapter has arguably gone much deeper into Jython than required to use the

interpreter design pattern. Indeed, once you decide that you need to use

interpreter and that you’re not going to get lost inventing your own language,

the solution of installing Jython is quite simple, and you can at least get

started by following the <strong>GreenHouseController</strong> example.</p>

<p>Of course, that example is often too simple and you may need something more

sophisticated, often requiring more interesting data to be passed back and

forth. When I encountered the limited documentation, I felt it necessary to come

up with a more thorough examination of Jython.</p>

<p>To me, Python and Java present a very potent combination for program development

because of Java’s architecture and tool set, and Python’s extremely rapid

development (generally considered to be 5-10 times faster than C++ or Java).