Hi All,
Just a reminder, our monthly scheduled meeting will be held
next
Wednesday, April 9th at 5:30PM (pizza and drinks) with the
discussion
beginning at 6:00PM (see map for meeting location:
http://www.clevelandjava.org/map.html).
David Caldwell (bio below) will be presenting
Patterns for
Integrating Java™ and JavaScript™ Technology: Tales from the Front
Lines. Dynamic (or "scripting") languages are growing enormously
in mind share and popularity. The combined use of Java and dynamic
languages on the Java platform
can boost developer productivity considerably. In this session, David
examines several patterns for including dynamic languages in a Java
technology-based project (see detailed abstract below).
David will be presenting this topic during
JavaOne in
May so I'm certain he would appreciate feedback from the group as he
prepares for the conference.
The agenda:
- Eat, Drink, Network (5:30-6:00 PM)
- March Meeting Recap (6:00-6:20 PM)
- News Items (6:20-6:30 PM)
- Patterns for Integrating Java™ and JavaScript™ Technology:
Tales from the Front Lines (6:30-8:00 PM)
Hope to see you there!
Scott
David's Bio
David Caldwell is a Java consultant with over 10 years of experience
building and architecting Java technology applications, mostly for
large corporate clients. He is also an active participant in the
Mozilla Rhino project. Rhino is a JavaScript interpreter which runs on
the Java platform, and provides the basis for the bundled JavaScript
implementation included in JDK 6. David is the primary author of its
support for the E4X (or ECMA-357) standard. E4X is a JavaScript
language extension which adds XML types to JavaScript's native type
system and provides a powerful, terse syntax for manipulating and
processing XML values.
David is an experienced speaker and trainer, having taught Java classes
in corporate and academic settings and conducted political skills
training for activist organizations around the United States.
Abstract
One of the hottest trends in the Java™ community is the exploding use
of scripting languages as a way to add more development options to the
Java technology ecosystem. A series of dynamic languages is available
for the Java platform, including ports of languages such as Python and
Ruby (Jython and JRuby) and new languages for the Java platform such as
Groovy and Scala. These dynamic languages run in the Java virtual
machine and typically allow access to the underlying Java
technology-based runtime and Java platform APIs along with a looser
type system, runtime interpretation, and the ability to embed a
language interpreter inside a larger application so that scripting can
be used to add dynamism to a Java platform or Java technology-based
application. JSR 223 (Scripting for the Java Platform) standardized a
set of bindings and an API that scripting engines could implement to
let Java technology-based programs discover their capabilities and
execute them at runtime.
Arguably the granddaddy of the JVM™ machine dynamic language
implementations is the Mozilla Foundation’s Rhino JavaScript™
technology-based interpreter. A version of Rhino is bundled with JDK™
release 6 as the only preinstalled scripting engine. Rhino is used in
many other projects, including Project Phobos, an initiative that lets
developers leverage JavaScript technology from within the GlassFish™
project’s Java Platform, Enterprise Edition (Java EE platform)
environment.
For adding scripting languages to the toolbox, what is the best way to
integrate them into the development process? Most developers probably
start using scripting languages because they allow “exploratory
programming,” executing individual lines of code that create and invoke
methods on Java technology-based objects with instant feedback. But
more-complex uses of scripting technologies raise questions about how
exactly to draw the line between Java language code and scripting
language code and how to get the most out of both tools while
minimizing the impedance mismatch a multilanguage application creates.
This session’s speaker, David Caldwell, is one of the developers on the
Rhino project and has been using Rhino in various ways to add more
agility and dynamic behavior to several Java technology-based projects.
In this session, he examines several patterns for including dynamic
languages in a Java technology-based project:
- Using the JavaScript programming language as the primary
programming language and creating Java technology-based objects on
demand to leverage the underlying platform
- Using a peer-based architecture, in which objects from the
scripting language add dynamic behavior to a Java technology-based
“peer” instance
- Using the Java programming language as the primary programming
language and the JavaScript programming language to extend abstract
Java classes
- Creating a script per operation and generating a unique scope for
each operation, with access to the appropriate Java technology-based
objects and methods
Attendees who are inexperienced with scripting languages for the Java
platform will likely be very surprised by how closely Java and
JavaScript programming language code can be integrated. Architects with
some exposure to Rhino or one of the other JVM machine dynamic
languages should come away with a deeper appreciation for the various
integration strategies available between Java and non-Java programming
languages running on the JVM machine and which approach(es) might work
best on their own projects. Developers already using an environment
that includes an embedded scripting language will learn more techniques
for using scripts in their embedding and gain insight into the
interaction model defined by their embedding. And attendees who think
Java technology is always the answer--or that it is passé and destined
to be replaced by new tools--will hear thought-provoking critique
--
Scott Seighman
Systems Engineer
Sun Microsystems
877.450.8885
scott.s...@sun.com