RIAs OR RIEs – CALL THEM WHAT YOU WILL, THEY’RE HERE PAGE 3

No. 1 i-Technology
-Technology Magazine in the World

JUNE 23-24, 2008 NEW YORK CITY

JDJ.SYS-CON.COM VOL.13 ISSUE:5

Detecting them
with FOSS tools
PLUS...
Java and the Mac
Interactive Storyboarding with JSP
The Rise of Functional Programming
Modernizing Axis1 Services Painlessly

T H E W O R L D ’ S L E A D I N G i - T E C H N O L O G Y M A G A Z I N E J D J . S Y S - C O N . C O M
 FROM THE PUBLISHER

RIAs or RIEs –
Editorial Board Call Them What You Will,
Java EE Editor:
Desktop Java Editor:
Eclipse Editor:
Yakov Fain
Joe Winchester
Bill Dudney
They’re Here Jeremy Geelan

“
Enterprise Editor: Ajit Sagar
Java ME Editor: Michael Yuan Enough with the new words al- perience (UX), whether that means experi-
Back Page Editor: Jason Bell ready.” That was how Sean Voisen menting with JavaFX or AJAX or whatever.
Contributing Editor: Calvin Austin recently ended a discussion about the The tools and platforms that encour-
Contributing Editor: Rick Hightower
burgeoning technology lexicon, which he age and support superior UX are becom-
Contributing Editor: Tilak Mitra
Founding Editor: Sean Rhody thinks can only be explained as “a ploy ing the pre-eminent tools for business
to keep Merriam-Webster in business.” survival and success, and their numbers
Voisen, who designs and builds Rich Inter- are growing all the time, as reflected by the
Production
Associate Art Director: Tami Lima net Applications, web applications, data mushrooming success of the AJAXWord
Executive Editor: Nancy Valentine visualizations, and what he calls “other Conference & Expo series – which in spite
Associate Online Editor: Lindsay Hock fun pieces of Internet-enabled software” of its name is now as much about Rich In-
Research Editor: Bahadir Karuv, PhD
for a living, is not a fan of “RIA” as a term. ternet Applications and Web Development
To submit a proposal for an article, go to
“Marketing gurus create new terminol- Frameworks as about merely AJAX per se.
http://jdj.sys-con.com/main/proposal.htm ogy like ‘RIA’ and ‘Web 2.0’ in order to The runaway success of Apple’s iPhone
force people to engage in new conversa- is another clear indicator of the busi-
Subscriptions tions without them dragging along their ness and market-share power of superior
For subscriptions and requests for bulk orders, please send your baggage of ingrained prejudices about user experience in 2008. Anthony Franco,
letters to Subscription Department:
what something is president of Effec-
888 303-5282 or is not,” Voisen tiveUI, who keynoted
201 802-3012
subscribe@sys-con.com contends. “They also at AJAXWorld in NYC,
One year digital edition subscription: $99.00 (12 issues)
do it – I am convinced summed up the
Two year digital edition subscription: $129.00 (24 issues) – to make themselves inflexion point very
seem smart,” he adds. succinctly: “Last year,
Editorial Offices Voisen’s view is echoed the overall demand
SYS-CON Media, 577 Chestnut Ridge Rd., Woodcliff Lake, NJ 07677 by Ethan Eismann, for RIAs outpaced the Jeremy Geelan is Sr.
Telephone: 201 802-3000 Fax: 201 782-9638
the senior experience qualified supply chain. Vice-President of SYS-
Java Developer’s Journal Digital Edition (ISSN#1087-6944) is design lead of Adobe This trend will con- CON Media & Events.
published monthly (12 times a year) for $99.00 by SYS-CON
Publications, Inc., 577 Chestnut Ridge Road, Woodcliff Lake, NJ Thermo with Adobe’s tinue in 2008. While He is Conference Chair
07677. Periodicals postage rates are paid at Woodcliff Lake, NJ XD team. He disagrees last year brought un- of the AJAXWorld
07677 and additional mailing offices.
Postmaster: Send address changes to:
with “RIA” as a term precedented growth in Conference & Expo
Java Developer’s Journal, SYS-CON Publications, Inc., for two reasons: “First, because like all RIA adoption – especially by Fortune 500 series and founder
577 Chestnut Ridge Road, Woodcliff Lake, NJ 07677. things techy, it’s already obsolete and companies – RIA adoption in 2008 brings of Web 2.0 Journal.
second because it’s limiting.” a new onslaught of risks, rewards, chal- From 2000-6, as first
But Eismann admits that while he hates lenges, and opportunities for companies editorial director and
©Copyright
Copyright © 2008 by SYS-CON Publications, Inc. All rights reserved. No “RIA,” he also loves it: “I love it because it’s of all sizes.” then group publisher
part of this publication may be reproduced or transmitted in now such a part of the common vernacu- In the end – quite aside from whether of SYS-CON Media,
any form or by any means, electronic or mechanical, including
photocopy or any information storage and retrieval system, without lar of web culture that when it’s used, you call them RIAs or RIEs – what matters he was responsible
written permission. For promotional reprints, contact reprint everyone immediately understands that is not words or terminology but business for the development
coordinator Megan Mussa, megan@sys-con.com. SYS-CON Media
and SYS-CON Publications, Inc., reserve the right to revise, republish you are talking about ‘something better and the realities of enterprise computing. of all new titles and i-
and authorize its readers to use the articles submitted for publication. than primitive HTML websites.’” “RIAs are impacting the way that com- Technology portals for
Its limiting factor as a term, according panies like eBay, Ford, Random House, the firm, and regularly
For List Rental Information: to Eismann, has to do with the two words Viacom, GE, Dow Jones, and NBC think represents SYS-CON at
Kevin Collopy: 845 731-2684, kevin.collopy@edithroman.com “Internet” and “application.” Personally about the Internet and desktop software, conferences and trade
Frank Cipolla: 845 731-3832, frank.cipolla@epostdirect.com
he prefers to use the acronym “RIE” – for and are demonstrating how innovative shows, speaking to
‘Rich Interactive Experience.’ thinking can completely change the way technology audiences
Java and Java-based marks are trademarks or registered Front-end engineering experts like they do business,” according to Franco. As both in North America
trademarks of Sun Microsystems, Inc., in the United States and
other countries. SYS-CON Publications, Inc., is independent of
Voisen and Eismann remind us that the president of EffectiveUI, he enjoys unique and overseas. He is
Sun Microsystems, Inc. All brand and product names used on emergence of Web 2.0 technologies and opportunities to see close up how Fortune executive producer
these pages are trade names, service marks or trademarks of
their respective companies.
the iPhone experience have shown that 500 companies are beginning to harness and presenter of
great user interface design makes a big RIAs and leverage them to improve the “Power Panels with
difference, that the era of what Eismann user experience and boost the bottom Jeremy Geelan” on
calls primitive HTML websites is truly line. SYS-CON.TV.
over, and that on the web the new priority Is your company doing the same? If not,
is innovation and optimizing the User eX- why not? jeremy@sys-con.com

JDJ.SYS-CON.com May 2008 3

 contents
MAY 2008 VOLUME:13 ISSUE: 5

JDJ Cover Story

24 FROM THE PUBLISHER

RIAs or RIEs – Call Them What

Uncommon
by Kris Lachor You Will, They’re Here
by Jeremy Geelan
...............................3

Java Bugs PRESSROOM

Industry News
............................6
JDJ News Desk

Detecting them
with FOSS tools
CASE STUDY

10
Java and the Mac
It all started with the boss out of Dilbert
by Bob Cusick
...........................8
by S.G. Ganesh
JSP

GET SMART. GET REAL-TIME. Feature Feature Interactive Storyboarding with JSP
Introduction to J-CASE tag library
by Masayuki Otoshi
...........................14
Next generation Internet applications will provide you with instant news
and real-time information without the need for plug-ins or 20th century JSR WATCH
polling techniques. Imagine using your Web browser to monitor ANY Java and Free Software in Brazil
real-time data, from server statistics to your favorite stock portfolio, with Bridging the digital divide
by Patrick Curran
NO polling, NO plug-ins, and NO issues with firewalls or proxy servers! ............................32

GET SMART. GET REAL-TIME. GET POWERED BY KAAZING.

18 28 Do you want to subscribe,
The Rise of Functional Programming Modernizing Axis1 Services Painlessly sign up a friend, or possibly have
an opportunity to write for us?
by Joe Morrison and Kalani Thielen by Michael Galpin Visit www.sys-con.com today!
www.kaazing.com 650.943.2436 sales@kaazing.com
Java Developer’s Journal Digital Edition (ISSN#1087-6944) is published monthly
(12 times a year) for $99.00 by SYS-CON Publications, Inc., 577 Chestnut Ridge Road,
Woodcliff Lake, NJ 07677. Periodicals postage rates are paid at Woodcliff Lake,
NJ 07677 and additional mailing offices. Postmaster: Send address changes to:
JDJ, SYS-CON Publications, Inc., 577 Chestnut Ridge Road, Woodcliff Lake, NJ 07677.

JDJ.SYS-CON.com May 2008 5

 PRESSROOM

Industry News President and CEO:

Fuat Kircaali fuat@sys-con.com

President and COO:

DigiSoft Announces General Availability of a Java
Platform Micro Edition Client Solution for IPTV
(Las Vegas) – DigiSoft.tv has signed a global
Binary Value Added Partner agreement with Sun
Microsystems for the distribution of a Java Plat-
form Micro Edition (Java ME) based software
stack for IPTV Set Top Boxes (STBs).
Sun’s Java technology-based media client
combined with DigiSoft’s middleware solution
for IPTV Set Top Boxes enables service providers
to launch high definition (HD) services such as
Video and Music on Demand, karaoke, home
shopping, network-based recording (NPVR)
/ time-shifted TV, games and more on a wide
range of IPTV STBs with H.264 HD and SD
video. Also supported is the latest encryption
and watermarking technologies from selected
partners. The combined DigiSoft / Sun software
stack offers IPTV service providers an open, flex-
ible IPTV middleware solution.
The use of Java technology for the software
stack enables the creation of multi-platform
(converged) Java applications for support on a
range of Java-based devices, including Blu-ray
Disc players, OCAP and other GEM-based set
top boxes, mobile handsets, and personal com-
puters while requiring minimal re-authoring,
simplifying application and service deployment.
www.digisoft.tv
Sun and Fujitsu Expand SPARC
Enterprise Server Line
(Santa Clara, CA / Tokyo) – Sun Microsystems
and Fujitsu Limited have expanded the Sun
and Fujitsu SPARC Enterprise server line with
the introduction of two new systems based
on the UltraSPARC T2 Plus processor. Scaling
from the edge of the network to the heart of the
enterprise, the third-generation CMT SPARC
VoiceObjects Introduces VoiceObjects Desktop for Eclipse
Enterprise T5140 and T5240 servers deliver
Carmen Gonzalez carmen@sys-con.com
performance and scalability and help enable
customers to consolidate the datacenter into an Senior VP, Editorial and Events:
ultra-dense, energy efficient compute environ- Jeremy Geelan jeremy@sys-con.com
ment, optimized and managed by the Solaris 10
Operating System (OS). The SPARC Enterprise
Advertising
T5140 and T5240 servers deliver up to 16 times
higher compute density than competitive two- Advertising Sales Director:
socket x86 systems and up to 32 times higher Megan Mussa megan@sys-con.com
compute density than competitive four-socket Associate Sales Manager:
x86 systems. The Sun and Fujitsu SPARC En- Corinna Melcon corinna@sys-con.com
terprise T5140 and T5240 servers provide up to
Advertising & Events Associate:
three times more performance than competitive
Alison Fitzgibbons alison@sys-con.com
RISC systems in half the space.
www.sun.com
www.fujitsu.com Events
Events Manager:
Appcelerator Integrates Rich Internet Application Sharmonique Shade sharmonique@sys-con.com
Platform with Google App Engine
(Atlanta) – Appcelerator, a provider of open
source rich Internet applications (RIA), it has Editorial
updated its platform to allow applications built Executive Editor:
using Appcelerator to be deployed to the free new Nancy Valentine nancy@sys-con.com
Google App Engine. Used together, the offerings Associate Online Editor:
give developers a route to developing, deploying, Lindsay Hock lindsay@sys-con.com
managing and scaling their applications.
Appcelerator is an integrated platform that
fuses RIA and service-oriented architecture Production
(SOA). With Appcelerator, developers can as- Lead Designer:
semble interactive web applications without the Tami Lima tami@sys-con.com
need for JavaScript or player-based plug-ins. Associate Art Directors:
Web applications can be implemented on Abraham Addo abraham@sys-con.com
Java/J2EE, PHP, Ruby, .NET, Python and Perl. Louis F. Cuffari louis@sys-con.com
Appcelerator for App Engine runs on Python,
the scripting language currently supported by
App Engine. As Google expands support to other Web Services
languages, Appcelerator for App Engine will fol- Information Systems Consultant:
low suit. Robert Diamond robert@sys-con.com
www.appcelerator.com
Web Designers:
Stephen Kilmurray stephen@sys-con.com
Richard Walter richard@sys-con.com

(San Mateo, CA) – VoiceObjects, a personalized phone self-service company, has announced the general availability of its VoiceObjects
Desktop for Eclipse and VoiceObjects Developer Edition. Using these new solutions, developers can create over-the-phone, multi-chan- Accounting
nel applications with personalization features to customize the experience for each user. Financial Analyst:
VoiceObjects 7 suite of products includes VoiceObjects Server for the deployment and management of personalized self-service Joan LaRose joan@sys-con.com
applications over voice, video, text, and Web self-service channels; VoiceObjects Desktop for creating, testing, deploying and moni-
Accounts Payable:
toring applications; and VoiceObjects Analyzer, a Web-based service used for caller behavior, system and application analysis. The
Betty White betty@sys-con.com
release of VoiceObjects Desktop delivers solutions that enable organizations to obtain 1:1 personalization. Built from the ground up
using open standards, VoiceObjects enhances VoiceXML capabilities in delivering applications that meet consumer demand.
Desktop for Eclipse is an Eclipse-based development environment that provides a graphical-use interface for the design, develop- Customer Relations
ment, deployment, testing and administration of voice, video, text and Web-based applications. The solution supports two opera- Circulation Service Coordinator:
tional modes: a network mode that allows for team collaboration, and a standalone mode that allows developers and consultants to Edna Earle Russell edna@sys-con.com
perform offline development and testing.
www.voiceobjects.com

6 May 2008 JDJ.SYS-CON.com


Java and the Mac
It all started with the boss out of Dilbert
T
his is the story of a Mac application
developer (okay – it’s about two of
them) who set out on a quest to find
an application development tool
based on Java so his boss would let him de-
velop on the Mac platform, which he loved.
There was only one catch – he had to find a
tool that was fast. Traditional Java program-
ming was going to take waaaay too long to
convert the internal custom programs that
had been written in an old 4GL. But the boss
still wanted the excellent user interfaces that
he was used to – because our hero was good
on the Mac and could make the screens look
“pretty.” If possible – the boss wanted the
impossible – make the application run on a
desktop AND over the Web – “just in case.”
Here’s the story of our intrepid hero and how
he searched, and found, a way to meet all
the “Dilbert boss-like” requirements.
John Allen, a researcher at Stanford
Medical Center, used to use 4GL environ-
ments to assist the research divisions at this
well-known university. Stanford Medical is
one of the most advanced research facilities
for oncology (cancer), and with the cutting
-edge research it does, there’s no standard
software package that can be used. The
oncology unit’s only solution was code-it-
yourself. 4GL worked well for a long time,
but a couple of key areas started to become
problematic. 4GLs in general don’t scale very
well, aren’t very secure due to proprietary
security systems, and worst of all don’t run
very well over the Internet. Stanford, with
over 200 buildings, uses the Internet as its
Bob Cusick, managing LAN. Essentially this means the applications
director of Servoy, USA, it uses must run secure, with easy deploy-
has one of the oldest ment, and have excellent Web capabilities.
blogs on the Internet Another issue is that it needed to access
(started in 1994). He has multiple databases, another problem for
been writing business propriety 4GL tools – which often have their
applications for over own databases built-in.
15 years, using popular Because of these challenges, Stanford
4GLs, Oracle, HTML, decided that the 4GL would have to be
and Servoy. He was the switched to Java, which would deliver
charter technical editor all it needed; however, it turned out that
for FileMaker Magazine programming in Java was much more com-
and speaks at developer plex and much more time-consuming (of
conferences all over the course!). After trying some projects in 2003
world. Visit his blog at with the then-promising WebObjects (a Java
bobcusick.blogspot.com. environment from Apple used among oth-
8 May 2008
ers for the iTunes store) it became evident
that something else was necessary, and John
Allen found it after he came in contact with
Servoy. Servoy is a Java-based environment
that lets the application developer use pre-
built scripts AND write in Java.
Our hero contacted Servoy, Inc. and
asked them to have a look at a prototype
that was built in WebObjects. The proto-
type was an application used to manage
data around oncology, and it had taken the
WebObjects team hired by Stanford two
months of coding to come up with a mock-
up. John was a bit suspicious about Servoy’s
response to the prototype: “It’s faster to build
this in Servoy than to write you an offer and
project document.” A couple of days later,
Servoy delivered a working version of the
prototype. Going ahead with Servoy was
now a no-brainer for Stanford. John is very
much a Mac guy: “I just prefer to have a
no-hassles OS where everything I need is in
the right place, one that’s stable and doesn’t
suffer from all types of viruses and malware.
With Servoy, I can work on Mac all day, even
if the applications I use are deployed to Win-
dows. What’s nice is that I don’t even have to
build specifically for Windows – Servoy and
Java take care of this for me!” John was able
to meet all his boss’s requirements, re-train
himself on a Java-based product, and stay
on the development platform he loves – the
Mac. He deploys to Windows, Linux, and
even Solaris across the multiple divisions at
Stanford. Many other departments includ-
ing Child Psychology and the Stanford Law
School have also adopted Servoy technology
since John first contacted the firm.
Our second example is Darren Clarke,
principal programmer at The Support
Group. The Support Group is a business
application consulting firm with offices
all over the country. “I love Java, I love my
Mac, I love the cross-platform capabilities of
Java – I just hate the fact that a lot of simple
things are very difficult to achieve with plain
Java!” Darren prefers to develop on his Mac,
but his customers often use Windows. The
beauty of Java and Servoy is that it doesn’t
matter. Business customers often have
complicated business rules – but a lot of
end users need a very easy-to-use interface.
CASE STUDY �
�� ����
�����������
� ��
�� ����
�������������
� ����������
��� ���
��
��
���
�� �����
�
������������
��
by Bob Cusick
Darren says, “On my Mac, it’s easier to use
Java with Servoy for all the aspects involved
������������������������
ISBN 0-9777622-0-3
in delivering business software: writing
���������������
business rules and workflow rules in a
productive way with very user-oriented and
friendly user interfaces. With Servoy I solve
those problems. Although it’s Java-based, it
offers a whole set of functionality that allows
me to focus on what I am good at: writing
���������������������������������������
business software that is very user-friendly,
stable, and scalable. And I can write it much, �� �������������������������������������������������������������������������������������
much faster in Servoy than in plain Java. � �����������������������������������������������������������������������������������
With this tool, I can write one code and de-
ploy to a client’s desktop or over the Web. It
���������������������������������������������
�������
eliminates the need for rewriting in PHP and
HTML – Servoy does most of that for me.”
�
����
So is Java for Mac all hallelujah? No, ������������������������
����
����
unfortunately it isn’t. Apple is sending very
mixed messages about Java: on one hand, �����������������
Steve Jobs mentions that it’s obsolete; on the from the Worldʼs Leading i-Technology Publisher © COPYRIGHT 2007 SYS-CON MEDIA
other hand he runs his Web store and iTunes
on it. Also, the Java team at Apple is very
responsive and can even be contacted per- �� ����
� ���������
sonally with problems. Yet that same team �
�� ����
����������
isn’t authorized to send you a patch, and �� ����
� ����������
you’ll have to wait before a bug fix makes it � ��
��� ���
into an OS X release – which in some cases
� ���� �� �����
���������������
can take up to six months. Jan Aleman, CEO ��
��
of Servoy, says, “Mac is the only platform
that we have to write specific ‘if’ statements
for. This is because, in particular, the Swing
�
classes aren’t paid enough attention.” Ac-
cording to Aleman, “This is partly a result
of Apple not using Swing itself, while at the
same time it’s decided to entirely map it on �������������������������������
ISBN 0-9777622-2-X
�����������������
its own set of Aqua GUI components. This
is the reason a lot of rather easy-to-fix bugs
aren’t solved and actually inspired Servoy to
run all our systems on our own technology.
In fact, before we release a new version to
our public, we run all our internal systems
on it. This way, we feel the pain before our
�������������������������������������������������������������������
customers do.” �����������������������������������������������������������������������������������������������������������������
Funny enough, Servoy’s CEO uses a Mac ������������������������������������������������������������������������������������������������������������������
himself too, not just personally but also for ���������������������������������������������������������������������������������������������������������
�������������������������������������
business. “I just got tired of Windows, with
the viruses, the instability, the slow boot, ��������������������������������������
�������
the lack of proper command -line tools so I
�
����
made the jump. I’ve noticed that I’m not the
������������������������
only one. Once a developer gets to choose,
����
����
he’d rather use the most hassle-free OS out
there.” �����������������
from the Worldʼs Leading i-Technology Publisher © COPYRIGHT 2007 SYS-CON MEDIA
JDJ.SYS-CON.com
 FEATURE
S. G. Ganesh is a research
engineer at Siemens (Corpo-
rate Technology), Bangalore.
Prior to Siemens, he worked
at Hewlett-Packard for
around five years. His areas
of interest are programming
languages and compilers. His
latest book is 60 Tips on Ob-
ject Oriented Programming
(ISBN-13 978-0-07-065670-3)
published by Tata McGraw-
Hill, New Delhi.
sgganesh@gmail.com
10 May 2008
Uncommon Java Bugs
by S.G. Ganesh
A
ny large Java source base can have insidious and
subtle bugs. Every experienced Java programmer
knows that finding and fixing these bugs can be
difficult and costly. Fortunately, there are a large
number of free open source Java tools available that can be
used to find and fix defects early in the development life-
cycle. In this article, we’ll look at a few examples of specific
uncommon1 or unusual defects that can happen in code and
see how different Java static analysis tools detect them.
Testing
As software gets more complex and ubiquitous, it becomes
more difficult to ensure high-quality code. One common
method of finding bugs is testing. But testing can’t cover all
paths and possibilities or enforce good programming practices.
Expert knowledge in the form of manual code review by peers is
one of the best ways to ensure good code quality. Code review is
often used as a mandatory process step for improving the code
and for finding the problems early in the software lifecycle.
Since testing and manual code review processes are re-
source-intensive, it would be helpful to use automated tools to
review code. Static analysis tools help considerably in detecting
the problems early in the software lifecycle and help enhance
the quality of the code significantly.
There are many high-quality Java tools available in the open
source domain. While it’s true that Java programs don’t suffer
from traditional C/C++ problems like memory issues and major
portability issues, Java software does suffer quality problems
like reliability, efficiency, maintainability, and security. A brief
discussion on benefits of using FOSS Java tools is given in the
sidebar.
Before getting into the meat of the matter, let’s discuss why
bugs happen. First, it’s important to recognize that everyone
makes mistakes, even experts2. Second, compilers only check
for syntax and semantic violations. Errors in language or API
use, which manifest themselves as bugs, aren’t detected by
compilers: This is left to static analysis tools and it’s important to
use them to detect coding problems. Third, programmers and
engineers are under constant pressure to “get-the-work-done”
under tight schedules; working under “almost-impossible-to-
meet” work schedules results in code that is often substandard
and filled with bugs. So, because of practical problems, most
code developed in the real world has bugs and it’s worthwhile
using static analysis tools to find them and fix them.
Detecting them with FOSS tools
In this article we’ll see an uncommon defect and introduce a
tool that detects it. We do this for two reasons: to illustrate the kind
of unusual problems that can happen in the code and to intro-
duce a FOSS tool that’s suitable for detecting this kind of problem.
Jlint
What does this program print?
class LongVal {
public static void main(String[] s) {
long l = 0x1l;
System.out.format(“%x”, l);
} such problem. Jlint ferrets out Java inconsistencies and bugs. It’s not
} a very sophisticated tool and if you don’t have experience using static
When you run it, it prints 1, not 11 – why? Let’s use a tool to
detect the problem. The antic tool (that’s part of JLint) finds it:
$antic –java LongVal.java
LongVal.java:3:26: May be ‘l’ is used instead of ‘1’ at the end of
integer constant
The programmer, possibly by mistake, typed ‘l’ (English
letter l) instead of ‘1’ (number one)!
long l = 0x1l;
Benefits of Using FOSS Java Static Analysis Tools
Using Java static analysis tools can significantly improve the quality of code.
Although static analysis tools can’t cover all the paths or possibilities, it pro-
vides significant help in providing coverage in detecting problems early in code;
such tools can also point out programming problems and warn of violations of
important and well-accepted programming rules and recommendations.
Using static analysis tools has many attractive benefits. A few of the salient
benefits of most of these tools are listed here. Most of the Java FOSS tools:
• Can cover code that’s not covered by testing or dynamic analysis
• Find many unusual or uncommon bugs that are usually missed
during testing or manual code review
• Work even on partial code – fully compilable source isn’t always needed
• Easily integrate with popular IDEs, so it’s comfortable to use them in
your favorite environment
• Are usually easy-to-run –with just a button click from your IDE
• Are absolutely free and high-quality
JDJ.SYS-CON.com
Figure 1 FindBugs detects the check-for-equality-to-NaN problem
To avoid this problem, it’s best to use ‘L’ (upper case letter L) as the
suffix for long constants instead of ‘l’ (lower case letter l).
Antic is part of the Jlint tool that’s meant to find problems related to
C syntax. There are quite a few coding problems that are common to
languages that use C-like syntax. The problem we saw now is just one
analysis tools, JLint is a good tool to start with. Antic works on Java
source files and Jlint works on Java class file builds. It’s a command
line tool and easy-to-use. It’s available at http://jlint.sourceforge.net.
FindBugs
What does this program print?
class NaNTest {
public static void main(String[] s) {
double d = getVal();
if(d == Double.NaN)
System.out.println(“d is NaN”);
} Exception!
private static double getVal() {
return Double.NaN;
}
} $ pmd Test.java text design
You might be surprised to find that it doesn’t print anything! What
went wrong? The FindBugs tool detects the problem and warns us
about it (see Figure 1).
The bug is that the condition (NaN == NaN) evaluates to false! In
the condition (d == Double.NaN), this code checks to see if a float-
ing-point value is equal to the special “Not A Number” value. The
IEEE 754 floating-point standard provides the special semantics of
NaN: no value is equal to NaN, including NaN itself. So, the check (d
== Double.NaN) always evaluates to false. The correct check to use is
the condition check Double.isNaN(x).
The FindBugs tool detects this problem and aptly names it
“Doomed test for equality to NaN”.
JDJ.SYS-CON.com
Figure 3 The DeadLock.java program results in
Figure 2 Test.java program results in NullPointerException a “deadlock condition”
The FindBugs tool is excellent. It detects correctness problems,
multithreading issues, performance problems, and bad practices.
It has less false positives and warns of only critical or important
problems that are likely to be actual defects in code. So, if you’re
pressed for time and want to look at only important problems, this
tool will suit you. It runs on Java class/jar files, so no Java source files
are needed to use it. And it runs in a nice standalone GUI. You can
download it at http://findbugs.sourceforge.net/.
PMD
What’s wrong with the program in Listing 1? If you
try to run it (as shown in Figure 2) you’ll get a NullPointer-
What could have gone wrong? PMD detects it and warns of the
problem:
Test.java:3 Overridable method ‘foo’ called during object
construction
The bug in this program is that the constructor of the Base class
calls an overridden method. Constructors don’t support runtime
polymorphism since derived objects aren’t constructed when the
base class constructor executes, the virtual method foo is called from
the base class constructor. Since foo is overridden, the overridden foo
calls the toString method from i, which isn’t initialized yet (note that
i gets initialized only after the Derived constructor has completed
executing). Because of this, the program terminates with a NullPoin-
terException. For this reason, it’s not a recommended programming
practice to call overridable methods from constructors.
May 2008 11
 FEATURE

The PMD tool checks for problems like possible bugs, design rule
violations, duplicates, sub-optimal or dead code, suggestions for mi-
gration to newer JDK versions, J2EE, JavaBeans, JSP, and JUnit rules. It
works on Java source files and can be used from the command line.
Plug-ins for popular IDEs like Eclipse, JBuilder, and JCreator are also
available. You can download it from http://pmd.sourceforge.net/.
QJ-Pro
What’s wrong with the program in Listing 2?
Acquiring multiple locks is prone to deadlock, particularly if not DoctorJ, and JarAnalyzer. More information and links on Java tools is provided in the
done in the same order or if the sleep()/wait() in the Thread is called Listing 1 Resource section.
after acquiring locks. In this program, foo and bar acquire locks in class Base {
public Base() {
opposite order and call sleep(). Hence deadlock occurs. Conclusion
foo();
Acquiring multiple locks is not a recommended programming We saw four specific static analysis tools that can be used to detect not-so-com-
}
practice. However, it’s often required in practice, so when we need public void foo() {
mon defects in code. They are free, easy-to-integrate with IDEs, and easy-to-use.
to acquire multiple locks, we should ensure that we acquire them in System.out.println(“In Base’s foo “); It’s highly recommended to use such tools to improve the quality of the software by
the same order in the code. } detecting and fixing bugs early in the software lifecycle.
Alternatively, we can consider using non-blocking locks when }

It’s likely that the program will hang after running successfully for
few times as shown in Figure 3; in other words, this program can lead
to a “deadlocked condition” (the program actually hint at this: the
name of the class is Deadlock!).
The QJ-Pro tool detects it as shown in Figure 4.
The bug in this code is that the code acquires two locks in op-
posite order; and after that a sleep/wait method is called – this
condition will usually result in a deadlock.
Locks are the basic Java synchronization mechanism. Using locks
ensures exclusive ownership for a thread while executing a critical
section. Incorrect use of synchronization can lead to deadlocks.
A big problem with deadlocks (as with most multithreading
problems) is that deadlocks are “non-deterministic” – they need not
reproduce consistently, and so it’s difficult to detect, reproduce, and
fix problems related to deadlocks.
Figure 4 QJ-Pro detects deadlock because of acquiring multiple locks
we attempt to acquire multiple locks. The tryLock method in the Resources
class Derived extends Base {
java.util.concurrent.locks.Lock interface provides this ability. It’s also • If you’re interested in a list of the Java FOSS static analysis tools available, check
public Derived() {
recommended to release locks quickly and not hold the locks for a i = new Integer(10); http://java-source.net/open-source/code-analyzers.
long time; so, it’s not recommended to use sleep/wait methods after } • “A Comparison of Bug Finding Tools for Java” by Nick Rutar, Christian B. Almazan,
acquiring a lock; consider using the wait/notify mechanism instead public void foo() { and Jeffrey S. Foster from the University of Maryland provides a detailed technical
to avoid deadlocks because of holding a lock for a long time waiting System.out.println(“In Derived’s foo “ comparison of Bandera, ESC/Java, FindBugs, JLint and PMD tools. See http://
+ i.toString());
for a condition to occur. www.cs.umd.edu/~jfoster/papers/issre04.pdf.
}
The QJ-Pro tool checks for problems like conformance to coding • If you’re using Eclipse, it’s very convenient to use Java tools as plug-ins. The list of
private Integer i;
standards, coding best practices, misuse of features, and APIs. It } available plug-ins for Java is at http://www.eclipseplugincentral.com/Web_Links-
gives lots of violations by default, so you’d have to spend some time index-req-viewcatlink-cid-14-orderby-rating.html.
selecting the list of rules you want to run for your project. It works class Test { • The book Java Puzzlers: Traps, Pitfalls, and Corner Cases by Joshua Bloch and
on Java source files and is easy-to-use in its standalone GUI version public static void main(String [] s) { Neal Gafter covers many interesting bugs that can happen in code. Check the link
new Derived().foo();
(shown in Figure 5). You can use its plug-ins with popular IDEs like http://www.javapuzzlers.com/.
}
Eclipse, JBuilder, JDeveloper or use it as an Ant job. You can get QJ-
}
Pro from http://qjpro.sourceforge.net/. 1
Here the word “uncommon” means the kind of defects we talk about are not defects due to usual pro-
gramming problems like null-pointer access or incorrect casts. The defects we are going to cover are little
Other Tools Listing 2 unusual that they don’t generally occur in programs; at least, they don’t occur everyday when we program.
Other than the four tools covered here – Jlint, FindBugs, PMD, class This {} 2
To err is human: It is only that novices make more mistakes, but experts know common pitfalls, so they
class That {}
and QJ-Pro – there are many other FOSS tools available. For exam- write code with lesser number of defects.
ple, CheckStyle checks for adherence to coding standards such as
class DoSynchronize implements Runnable {
Sun’s. You can get it from http://checkstyle.sourceforge.net/. JCSC public static void foo() throws InterruptedException {
(Java Coding Style Checker) checks for coding style adherence synchronized(This.class) {
and for common bugs. You can get it at http://jcsc.sourceforge. synchronized(That.class) {
net/. There are many more useful tools like Classycle, Condenser, Thread.currentThread().sleep(10);
}
}
}
public static void bar() throws InterruptedException {
synchronized(That.class) {
synchronized(This.class) {
Thread.currentThread().sleep(10);
}
}
}

public void run() {

try {
foo();
bar();
} catch (InterruptedException e) {
System.out.println(“Caught interrupted exception”);
}
}
}

class DeadLock {
public static void main(String []s) {
DoSynchronize pc = new DoSynchronize();
Thread t1 = new Thread(pc);
Thread t2 = new Thread(pc);
t1.start();
t2.start();
}
}

Figure 5 QJ-Pro detects deadlock because of acquiring multiple locks

12 May 2008 JDJ.SYS-CON.com JDJ.SYS-CON.com May 2008 13


Interactive Storyboarding
with JSP
Introduction to J-CASE tag library
A
lot of rework still happens in
projects applying UML tech-
niques because of conflicts
and omissions in require-
ments. To reduce rework, interactive
storyboarding is effective, but it seems
that projects using the technique are
limited because of the few tools avail-
able.
To improve this situation, this article
introduces the J-CASE open source Tag
Library that lets us describe story-
boards on JSPs based on use cases, and
explains how to generate document
and UML diagrams from the JSPs.
To reduce the rework and improve
quality of the requirements, we should
carefully realize the use cases in design
stage. There are two approaches to
realize (and see Figure 1):
• Class definitions – Find classes and
define object interactions. They are
represented in class and sequence
diagrams, etc.
• Storyboarding – Describe detail
scenarios based on use case
descriptions, and add user interface
information and system processes
to be executed.
Ideally both activities are neces-
sary. However, we tend to neglect the
storyboarding in software analysis
and design. Use cases only capture
core functional requirements; they’re
not enough for stakeholders to fully
understand how the system will work.
They don’t know what they really want
to do with the system until they see the
actual system we develop.
Storyboarding visualizes the use
Masayuki Otoshi cases and shows stakeholders what the
develops Web applications screens look like and what happens on
for a manufacturing each screen. It helps them get a better
company as a senior understanding and we could get more
developer. feedback before moving to implemen-
tation. Although storyboarding has lots
otoshi@mxd.mesh.ne.jp of benefits, why isn’t it more popular?
14 May 2008
One of the reasons is that there are few
storyboard tools available. In story-
boards, the scenarios defined in use
cases are detailed, and abstract screens
and process logic are also added. So
the flows typically become complex,
and we can’t easily maintain them
without tools.
The following features are required
in storyboard tools:
• Interactive Storyboarding – The
storyboards described should be
able to execute on a simulator or
Web site so that stakeholders can
experience the story on screens.
• Easy Maintenance – The require-
ments represented on the story-
boards are often changed. The
data we need to modify has to be
minimized. So tools should auto-
Figure 1 Two ways to use case realization
Figure 2 “Log In” use case description
JSP
by Masayuki Otoshi
matically generate supplemental
documents and diagrams.
• Use Case Description Style – Since
we’ve already captured requirements
in use case descriptions, it’s better to
describe storyboards using the same
format so we can describe them by
extending existing descriptions.
The tools available today fall into
two groups. One is “storyboard tools”
(tools for writing storyboards), and the
other is “tools for drawing diagrams”
like Visio, the UML tool, and Power-
Point.
Some storyboard tools are avail-
able to generate HTMLs for interactive
storyboarding from screen and flow
definitions. But these are commercial
products and not cheap.
In the case of tools for drawing dia-
grams, say, the UML tool, storyboards
can be expressed using class diagrams
and activity diagrams. However, the
UML diagrams created aren’t intuitive-
ly understood. It’s not easy to imagine
screens and flows from the diagrams,
especially for stakeholders who aren’t
familiar with UML. It also doesn’t
satisfy the requirements of interactive
JDJ.SYS-CON.com
storyboarding and easy maintenance.
A tool that supports all the features needed
is J-CASE Tag Library. J-CASE takes a different
approach than the other tools. First we create
JSP files describing use cases and screens. It
generates documents with use case style and
UML diagrams for use cases and navigation
maps. Compared to other GUI tools, we can
call J-CASE a tool for developers. If you have
expertise in JSP, you’ll understand how to use
the tags, and realize it can extend custom codes
using other tag libraries.
In general, you may think we shouldn’t code
for writing storyboards. However, I need to
emphasize that there’s an advantage in writing
them with JSP in the analysis and design phase.
My experience is that developers typically
find conflicts and missing requirements, even
though we’ve spent time reviewing the require-
ment and specification documents. That’s
because programming languages are limited in
expressions and requires more precision than
natural language. So, when developers can’t
translate the requirements written in natural
language into code, they recognize that’s some-
thing wrong or missing. Since J-CASE requires
us to write some codes, we can also get similar
recognitions when writing JSPs for storyboards.
Create Use Case and Action JSPs
Let’s start to create a use case and storyboard
using J-CASE tags. As a sample use case, I’ll use
a “Log In” use case available for download on
the J-CASE Web site. Before starting to create
the storyboards, core scenarios have to be cap-
tured in use cases. Figure 2 shows the use case
description of the “Log In” use case.
J-CASE expresses the use case using two
kinds of JSP, Use Case JSP and Action JSP. Main
and alternative flows (flows of events) are de-
scribed in Action JSPs, and the rest of informa-
tion, such as use case ID, name, Brief Descrip-
tion, and Actor, is described in Use Case JSP.
In the Use Case JSP, use case information
except flows of events is described using a <jc:
useCase> tag. Use Case ID, name, actor, and the
link to the first Action JSP are specified in the
attributes of the tag.
Other additional information (Brief Descrip-
tion and Actor) is added using a <jc:desc>
tag in the body of the <jc:useCase>. Listing 1
represents use case information of the “Log In”
use case.
The Use Case JSP is converted into a Use
Case Frame as shown in Figure 4. By clicking
the link labeled “[UC01] Log in” you can start
experiencing the use case.
In the Action JSP, actions performed by ac-
tors are described using <jc:actions> and <jc:
action> tags. Each <jc:action> represents an
event that the actor (end user or system) can
take on the page, and the flow of the events is
represented by making links between Action
JDJ.SYS-CON.com
Figure 3 Use Case JSP and Action JSPs
Figure 4 Use Case Frame generated by the useCase tag
Figure 5 Actions Frame generated by the actions tag
Figure 6 The login screen Figure 7 The confirmation dialog
generated by the screen tag generated by the dialog tag.
Figure 8 Process results generated by the processResults tag
JSPs. Listing 2 shows two actions that the user
may take on the login page.
The first action represents the event of Main
Flow Step 2 in Figure 2, and the second one
is Alternative Flow 1 Step 1. The Action JSP is
converted as in Figure 5.
Generate Use Case Document
Once you create all Use Case and Action
JSPs, you can execute a <jc:generateUseCase>
tag to generate a use case document from the
JSPs. The tag requires input and output attri-
butes. The path of the Use Case JSP is specified
in the input, and the HTML path of the use
case document to be generated is specified in
the output (see Listing 3).
Refer to Figure 2 again. It’s the use case
HTML generated by the <jc:generateUseCase>
tag.
Visualize the Use Case
Screens, system processes, and so on aren’t
typically mentioned in use cases to focus on
capturing core requirements. Now that the “Log
In” use case is created, it’s time to describe the
screens and processes.
To visualize the pages, J-CASE provides <jc:
screen>, <jc:dialog>, etc. For example, the login
form can be specified using HTML code in the
<jc:screen> tag as shown in Listing 4.
The <jc:screen> tag is displayed as shown in
Figure 6.
Figure 9 Storyboard document with screens and process results
Figure 10 Use case diagram generated by the generateUseCase tag
A dialog to ask the user for a “Yes” or “No”
can be represented using the <jc:dialog> tag
shown in Listing 5.
The code generates the dialog frame shown
in Figure 7 when accessing the JSP.
The logic of the system process can be de-
fined as a Java method in a JSP declaration tag
(<%! %>). In a JSP that represents a login process,
you can define, for example, the authenticate
method shown in Listing 6 that authenticates
the user by checking the credential parameter.
The method annotated with @JCaseProcess
is automatically executed when the page is
loaded, and you can see the execution results
using the <jc:processResults> tag. In case au-
thentication fails, you’ll see the process results
as shown in Figure 8.
Generate Storyboard Document
After adding screens and processes on the
JSPs, you can execute the <jc:generateUseCase>
tag again to generate the storyboard document.
When you access the JSP, including the <jc:
generateUseCase>, the storyboard.html shown
in Figure 9 is generated. You’ll also see the
screens and process results you added on it this
time.
May 2008 15
 JSP

Generate UML Diagrams cases and the specifications required

The <jc:generateUseCase> tag also
accepts useCaseDiagram and navigation-
Map attributes, which generate XML files
of the UML diagrams. If you execute <jc:
generateUseCase> with those attributes as
shown Listing 8, XML files that can be ed-
ited with EclipseUML are also generated.
Figure 10 shows the use case diagram
of the “Log In” use case.
Figure 11 shows the navigation map
that represents navigations among pages
(JSPs). With these diagrams, we can verify
if there are any conflicts or redundancies
in defined use cases and flows.
The World’s Leading Java Resource
Is Just a >Click< Away!
for actual implementation. While
writing storyboards, you’ll find con-
flicts, redundancy, and omissions in
the use cases. Visualized screens and
flows also give us a better understand-
ing. To get the benefits, it’s important
to choose the right storyboard tool
according to the requirements of your
project.
This article recommends using a
JDJ is the world’s premier independent, vendor-neutral print resource
tool that supports creating interactive
storyboarding, and introduced J-CASE Tag for the ever-expanding international community of Internet
technology professionals who use Java.
Library. It helps you refine use cases and
define better specifications.

Conclusion Resources
Storyboarding is a technique to J-CASE homepage: http://www5f.biglobe.
Figure 11 Navigation map of “Log In” use case bridge a considerable gap between use ne.jp/~webtest/jcase/

Listing 1: useCase tag Listing 5: Dialog tag

e s !
v y
<jc:useCase id=”UC01” <jc:dialog name=”Confirmation” button=”Yes,No”>

l n
name=”Log in”

l
Are you sure to remove the file?
link=”protected.jsp” </jc:dialog>

e t h i o ition er :
actor=”Consumer User”>

s
<jc:desc name=”Brief Description”>
The user logs in the system.

w t
</jc:desc> Listing 6: Process definition

i
<jc:desc name=”Actor”> <%!

T o n d int E ecem
Consumer user @JCaseProcess(“The system authenticates the user.”)
</jc:desc>
</jc:useCase>
public String authenticate(PageContext pageContext) throws
Exception { d b
String credencial = JCaseUtils.getParameter(pageContext, “cre-

E
dencial”);

M l ow mbe
Listing 2: Actions and action tags

r r, D
<jc:actions>
if (!”valid”.equals(credencial)) {

P
<jc:action name=”Correct Credencial”
throw new Exception(“Invalid ID or password.”);

a
link=”loginProcess.jsp?credencial=valid”>
}
The user enters correct ID and password.

t
</jc:action>

i
<jc:action name=”Invalid Credencial” JCaseUtils.setAttribute(pageContext, “auth_result”, “valid”);
link=”loginProcess.jsp?credencial=invalid”> return “Valid session has been created.”;

S h te
p
g
The user enters invalid ID or password. }
</jc:action> %>
l e
i pe June ia , S
</jc:actions>

c
D u r Sc h ,
Listing 7: Generate the storyboard document
Listing 3: Generate use case document <jc:generateUseCase
<jc:generateUseCase input=”useCase.jsp”
input=”useCase.jsp” output=”storyboard.html”
output=”useCase.html” />
/>

o a r
F M
Listing 4: Screen tag Listing 8: Generate UML diagrams
<jc:screen name=”Login Form” align=”center”> <jc:generateUseCase
<table> input=”useCase.jsp”
<tr><td>User ID </td><td><input type=”text”></td></tr>
<tr><td>Password</td><td><input type=”text”></td></tr>
output=”storyboard.html” www.JDJ.SYS-CON.com
useCaseDiagram=”useCase.uud”

or 1-888-303-5282
</table>
navigationMap=”navMap.uad”
<input type=”button” value=”Submit”>
/>
</jc:screen>

16 May 2008 JDJ.SYS-CON.com OFFER SUBJECT TO CHANGE WITHOUT NOTICE

 FEATURE
Functional Programming
Joe Morrison is a managing
consultant at Lab49, and
has over 20 years of experi-
ence leading engineering
teams in designing and
building complex network-
based applications. His
projects have ranged from
distributed object research
at Verizon Laboratories, to
value chain management
software at Benchmark-
ing Partners in Boston, to
in-the-trenches SOA projects
for financial services firms
in New York. Joe has a
BMath degree in computer
science from University
of Waterloo, and a MS in
computer science from MIT.
He is a regular blogger on
http://blog.lab49.com/.
joe.morrison@lab49.com
18 May 2008
The Rise of
by Joe Morrison and Kalani Thielen
J
ava applications have become steadily harder to un-
derstand and maintain in recent years. Object-oriented
programming has proven an effective way to develop
enterprise applications, but several recent trends are
causing a sharp increase in code complexity. One is the
increasingly common use of the Factory design pat-
tern, abstracting away the object creation process (e.g., the
creation of servlet objects by application servers, the use of
Spring as a general-purpose object factory, the use of JNDI,
etc.) Another is the increased use of the JavaBean pattern
with reflection and annotations (e.g., for object serializa-
tion and persistence). The result is that objects have more
mutable state than ever, and the code causing changes to that
state is increasingly decentralized. Programs are becoming
easier to write, but harder to debug as complexity spirals out
of control.
Functional programming is a model of computation that
avoids making repeated changes to objects, and computes
outputs from inputs in a stateless way. The implications are
far-reaching; functional programs are more concise, easier
to understand and debug, and can be executed more ef-
ficiently on modern computer hardware. Although functional
programming has been around for a long time there has been
a recent resurgence in interest with the advent of languages
like Scala, which support functional programming and can
be executed in a standard JVM. But even if you’re writing
code in Java, you can use functional programming patterns
and achieve many of the benefits.
In this article we explain the basic principles of functional
programming, and show some functional patterns that you
can start using in your Java programs immediately.
The Problem
Object-oriented programming is about being able to de-
fine packages of state, together with operations on that state.
Typical object-oriented languages support encapsulation,
i.e., the notion that the state can only be accessed via the
defined operations, and polymorphism, i.e., the notion that
objects of different types can be treated uniformly. Here is an
example that shows these concepts. The Reader interface de-
fines an operation for retrieving information one String at a
time. The ArrayReader class implements this interface, start-
ing from an array of Strings and returning them one at a time.
The CharReader class also implements the same interface,
Better living without side effects
starting from any type of Reader and returning its output one
character at a time. See Listing 1.
Notice that both ArrayReader and CharReader have pri-
vate, internal state. It’s part of the benefit of object-oriented
programming that these implementations could be changed
without affecting any other code as long as the public inter-
faces are preserved.
But in real life object-oriented programming, subtle prob-
lems begin to emerge due to the too frequent use of mutable
(i.e., changeable) state. Even this simple Reader example
can be hard to understand if readers are shared or accessed
concurrently from multiple threads. For example, what does
the following code example do?
public static void main(String[] args) {
Reader arrayReader = new ArrayReader (new String[] { “Foo”,
“Bar”, “Baz” });
Reader charReader = new CharReader (arrayReader);
String s = arrayReader.read();
while (s != null) {
System.out.println (s);
System.out.println (charReader.read()); // uh oh
s = arrayReader.read();
} s = arrayReader.read();
} }
As it turns out, the result is:
Foo
B the classes to the Spring framework. Would you be able to
Baz
a introduction to this article? For completeness, here is the ap-
The B and the a on the second and fourth line of the
output come from the word “Bar.” It’s confusing because the
loop alternates each call to arrayReader.read() that pops a
word from the ArrayReader, with a call to charReader.read()
that pops a word from the same ArrayReader every time it
runs out of characters. The spirit of these classes was to call
either the ArrayReader or the CharReader in a loop, but not
to make calls to the same ArrayReader both directly and
indirectly via the CharReader class. But nothing in the object-
JDJ.SYS-CON.com
oriented paradigm (or any paradigm) stops people from </list>
violating unwritten rules. As a result, you have to understand </constructor-arg>
exactly how the ArrayReader and CharReader objects interact </bean>
to predict what will happen. The problem is magnified if your
program is multithreaded. <bean id=”charReader” class=”CharReader”>
The fundamental problem is that each object behaves <constructor-arg ref=”arrayReader” />
differently depending on its current state. (Obviously the </bean>
second time you call read() on an ArrayReader you get a dif-
ferent result from the first time you call it.) That means that </beans>
in general, if you want to understand what any particular op-
eration is doing to an object, you have to know exactly what Note that we used constructor-based dependency injec-
state the object was in before you invoked the operation. But tion, but it’s common to use setter-based injection in which
to know that you have to know at what point the object was case we would have added setters to each class for the String
created, and the exact sequence of subsequent operations array and Reader dependencies, thus creating even more
that might have changed the object’s internal state. That’s mutable state. By changing this XML file we can cause our
easy if the object reference is assigned to only a local variable program to behave completely differently. Here is a version,
and never shared, but if the object reference can be obtained for example, that provides the CharReader object with its
from anywhere in your application via reflection or a direc- own private ArrayReader and eliminates the confusing shar-
tory service, then all bets are off. ing of the mutable state:
Adding Fuel to the Fire by Abstracting Away Object Creation <beans>
Design patterns that abstract away the process of object
creation bring a huge amount of benefit in terms of software <bean id=”arrayReader” class=”ArrayReader”>
configuration management and testability. Such design pat- <constructor-arg>
terns have become enormously popular in recent years, but <list>
they are problematic when combined with the use of mu- <value>Foo</value>
table state. A programmer cannot determine which classes <value>Bar</value>
a particular code sequence will instantiate just by looking at <value>Baz</value>
the code, and therefore cannot reason about the code until </list>
the runtime behavior of the object factory is fully under- </constructor-arg>
stood. For example, let’s say we decide to rewrite our example </bean>
based on Spring retaining the exact same behavior as before:
<bean id=”charReader” class=”CharReader”>
public static void main(String[] args) { <constructor-arg>
<bean class=”ArrayReader”>
BeanFactory factory = new XmlBeanFactory(new FileSystemResource(“ <constructor-arg>
applicationContext.xml”)); <list>
Reader arrayReader = (Reader) factory.getBean (“arrayReader”); <value>Hello</value>
Reader charReader = (Reader) factory.getBean (“charReader”); </list>
</constructor-arg>
String s = arrayReader.read(); </bean>
while (s != null) { </constructor-arg>
System.out.println (s); </bean>
System.out.println (charReader.read());
</beans>
Kalani Thielen is a Lab49
} This version produces the output: technology consultant,
working in the financial
The underlying classes have not been changed at all, Foo services industry. Prior
nor has the main logic, but we have left the instantiation of H to joining Lab49 in 2006,
Bar he worked for six years
understand the code sequence above if you hadn’t read the e developing products for the
Baz publishing, advertising, and
plicationContext.xml file: l communications industries.
As a specialist in program-
<beans> With this change to the configuration file, the main loop ming language theory,
prints Foo, Bar, and Baz as expected, and the CharReader his present work focuses
<bean id=”arrayReader” class=”ArrayReader”> prints out individual characters from the word Hello. They on the development and
<constructor-arg> no longer interfere with each other. The question of whether certification of compilers
<list> or not the main ArrayReader’s state is shared (creating the for bond pricing and trading
<value>Foo</value> undesired interaction between the classes) depends on the languages.
<value>Bar</value> application configuration file, which illustrates why the
<value>Baz</value> configuration file must be read and understood to predict the kthielen@lab49.com
JDJ.SYS-CON.com May 2008 19
 FEATURE
behavior of the actual program. When we are talking about
configuration files running to hundreds and thousands of
lines of XML, this can be daunting.
This is not a straw man argument. Code like this is getting
written and deployed every day in mission-critical enter-
prise applications. We’ve had to debug some of it. We are not
saying that object-oriented programming is bad, or that it’s
wrong to abstract away the process of object creation. On
the contrary, our point is that mutable state makes programs
hard to understand, and modern programming practices
magnify the problem. Complexity in software is inescapable,
but unnecessary complexity is, well, unnecessary. By attack-
ing the problem at its root (mutable state), we hope to have
our cake and eat it too.
Functional Programming: An Alternative Approach
To understand better how functional programming can
simplify this problem, we’ll first look at an even simpler prob-
lem in Haskell (one of the most mature modern functional
programming languages).
If you only remember one thing about functional program-
ming, it should be this central idea: that it should be possible
to substitute a function call with its result, without changing
the meaning of a program. This simple principle (generally re-
ferred to as referential transparency) has radical implications.
At its best, this idea strengthens the intuition we’ve developed
from high school algebra that, difficult as a problem may be,
we can write it out in its entirety and solve it by progressively
simplifying it.
Rather than taking on the full-grown horror of a decades-old
legacy system, let’s consider a very simple functional program
and analyze it in ways representative of real-life concerns.
sum [] = 0
sum x:xs = x + sum xs
This definition is intended to describe a function, “sum,”
that adds up all of the numbers in a list. If the input list is
empty (denoted by empty square brackets) the sum is 0.
Otherwise we can break the list into its head (“x”) and its tail
(“xs” – read as the plural of “x”), in which case the sum is just
the head plus the sum of the tail. It might help clarify this to
read the function out loud in English:
“The sum of an empty list is zero. Otherwise, the list has
an initial value x followed by the remaining values xs, and the
sum is x plus the sum of the xs.”
This is a recursive definition, and although it may at
first glance seem like an endless loop, the sum will always
decrease the length of the input list by one until the simplest
case (the empty list) is reached. Let’s try it out on an example:
sum [1, 2, 3, 4, 5]
Using the principle of referential transparency, and sub-
stituting the appropriate body of the “sum” function at each
step, we can proceed to rewrite this as follows:
sum 1:[2, 3, 4, 5]
1 + sum [2, 3, 4, 5]
1 + sum 2:[3, 4, 5]
20 May 2008
1 + 2 + sum [3, 4, 5]
1 + 2 + sum 3:[4, 5]
1 + 2 + 3 + sum [4, 5]
1 + 2 + 3 + sum 4:[5]
1 + 2 + 3 + 4 + sum [5]
1 + 2 + 3 + 4 + sum 5:[]
1 + 2 + 3 + 4 + 5 + sum []
1 + 2 + 3 + 4 + 5 + 0
Having made each step of the computation explicit, the
derivation of the final result is clear. What’s more, we can be
certain that each step in the above derivation completely
describes the computation, as we’ve given up the possibil-
ity of implicit “side effects” happening between steps. You
can imagine that if the “sum” function had a side-effect (like
updating the input list) this simple two-line example would
become much more difficult to understand.
Because a functional program implies that you can always
substitute a function call with its result, there are two very
important things that our compiler can do to help us without
any effort on our part. The first is that, according to the prin-
ciple of referential transparency, the compiler can substitute
the final result for the call to “sum” at compile-time, without
changing the behavior of the program. This has the effect, in
our example, of doing no runtime computation at all!
In more realistic cases, the compiler may not be able to
compute the entire function ahead of time, but with this
principle as a guide it can still simplify the inevitable runtime
computation by partially evaluating as much of it as possible
at compile-time. The second thing the compiler can do is to
perform the final computation in parallel where possible.
Given some simple properties of the functions involved (in
this case, the fact that a + b + c = a + (b + c) = (a + b) + c), the
compiler could easily generate code to compute the final
sum as (with concurrent evaluation denoted by parentheses):
1 + 2 + 3 + 4 + 5 + 0
(1 + 2) + (3 + 4) + (5 + 0)
3 + 7 + 5
(3 + 7) + (5)
10 + 5
(10 + 5)
15
Remarkably, the compiler can (given just these few rea-
sonable assumptions) produce a very specialized, efficient
executable from our compact functional program. The key
to passing all of this complexity off to the compiler is that
we go out of our way to leave the compiler as many imple-
mentation options as possible. To summarize this viewpoint:
functional programs describe what is to be computed,
allowing functional compilers to decide how to compute it.
Unnecessary complexity creeps into software projects where
these problems of what and how are intermixed.
Introduction to Scala
A good way for Java programmers to experiment with
functional programming concepts is to give Scala a try. Scala
is an interesting programming language first released in
2003 by Martin Odersky, a computer science professor at the
JDJ.SYS-CON.com
Swiss Federal Institute of Technology, and one of the designers
of Java generics. Scala is a multi-paradigm language, smoothly
integrating features of both object-oriented and functional
languages. Most importantly it is fully interoperable with Java.
It compiles to JVM bytecodes (i.e., standard .class files), Java li-
braries can be used freely in Scala programs, and it is possible to
inherit from Java classes and implement Java interfaces directly
in Scala. An Eclipse plug-in is even available.
Installation Instructions via the Eclipse Plug-in
If you’re an Eclipse user, it’s easy to get started with Scala
by installing the Scala Eclipse Plug-in. You don’t even have to
install Scala first. Just select:
Help -> Software Updates -> Find and Install -> Search for new fea-
tures to install
and create a new remote site called “Scala Plugin Update
Site” with this URL:
http://scala-lang.org/downloads/scala-plugin
Install the feature Scala Plugin UpdateSite. If you get an error
that package org.eclipse.pde.runtime is missing, then go back to:
Help -> Software Updates -> Find and Install -> Search for new fea-
tures to install
and select The Eclipse Project Updates, expand the category
corresponding to your version of Eclipse, and select the Eclipse
Plugin Development Environment. Install it and restart
Eclipse. That plug-in includes the required org.eclipse.pde.run-
time package, so once it’s installed you should be able to install
the Scala plug-in.
If you are not an Eclipse user, you can install Scala the tradi-
tional way, starting from this URL:
http://www.scala-lang.org/downloads/index.html
Once you’ve installed Scala, create a new Scala Project. Cre-
ate a package called com.lab49.example and within it create a
Scala Object called Main with the following contents:
package com.lab49.example;
object Main {
def main(args: Array[String]) {
println(“Hello, world!”)
} The idea of this interface is to provide access to a list of
} strings one at a time, presumably so we can do something to
Select Run as Scala Application. If it displays Hello, world
then congratulations! You have just written your first Scala
application.
Now let’s try rewriting the sum function in Scala:
package com.lab49.example;
object Main {
JDJ.SYS-CON.com
def sum (l: List[Int]): Int = {
l match {
case Nil => 0
case ::(x,xs) => x + sum(xs)
}
}
def main(args: Array[String]) {
println (sum(List(1, 2, 3, 4, 5)));
}
}
This is slightly more verbose, but similar in spirit to the two-
line Haskell example we started with. The Haskell version didn’t
declare a package, enclosing class, or Main function, so a fair
comparison is to look at only the sum function that is six lines
long in Scala and includes type declarations. Note the pattern-
matching syntax, for example, the use of :: to match a list and
split the head node from the remaining nodes. This is an example
of a nice Scala feature called case classes that lets you write pat-
tern-matching case statements for your own classes as well as
built-in ones.
Note that it’s not the objective of this paper to be a Scala
tutorial. There are already many of those on the Web. But we
want to introduce Scala because it provides excellent support
for functional programming, fits well with the Java technology
stack, and is gaining momentum in the Java community.
This sum example we started with may be simple, but it already
illustrates how functional programming is different. The obvious way
to code this in Java would have been to initialize a counter to zero,
iterate through the list, and keep modifying the counter by adding the
next value. If you’ve been writing Java code for a long time, you may not
realize how deeply ingrained it is for us to solve problems by constantly
modifying variables, calling methods that modify objects, and so on. But
in functional programming, your first instinct should be to think of every
problem in terms of computing an output directly from an input, break-
ing it into smaller problems that you solve recursively if necessary.
Let’s come back to our original problem now and try to apply
these concepts.
Rewriting Our Original Example
First let’s consider the Reader interface we started with:
public interface Reader {
String read();
}
those strings. But the fundamental idea of this interface is not
in keeping with functional programming, since every time you
call read you change the state of the object. Can we come up
with a more functional way of doing the same thing? Indeed we
can, by changing the responsibilities slightly. Instead of feeding
strings to a consumer one at a time, we will instead ask the con-
sumer to tell us what work they want done on each string (using
a callback) then we will do it to all of the strings. In Scala the
equivalent to a Java interface is a trait, so our revised example
will look like this:
May 2008 21
 FEATURE
trait Reader {
def repeatForEach (f: String => Unit) = ()
} cess to all of the items in that reader:
We are replacing the read method with one called repeat-
ForEach, which takes a callback as an argument. The callback
must take a string as input and return nothing as output (that’s
what the Unit type means in Scala), the idea being that repeat-
ForEach will invoke the callback for each individual string. We
say = () to declare that by default, this method does nothing.
Now we need an equivalent to the ArrayReader that takes a list
of strings at construction time, and can be used later to provide
one-at-a-time access to those strings. In Scala you don’t imple-
ment an interface, you extend a trait. Furthermore, although
Scala supports an Array type, we want to use the List type,
which is immutable and emphasizes our functional style. So we
end up with this:
class ArrayReader (strings : List[String]) extends Reader {
override def repeatForEach (f: String => Unit) = {
strings.foreach (f);
} on each character after converting it to a one-character string.
} Scala supports type inference, meaning that you can omit
This defines a class ArrayReader that extends the Reader
trait and that requires a list of Strings upon construction. Note
that in Scala you can specify arguments in a class defini-
tion (almost like a function definition). This means that the
arguments must be provided in every use of the constructor
and they automatically become available as immutable class
members. Thus the following code in Scala:
class ArrayReader (strings : List[String]) {
}
is analogous to the following Java code:
public class ArrayReader {
private final List<String> strings;
public ArrayReader (List<String> strings) {
this.strings = strings;
} }
} }
Once you have an instance of the Scala ArrayReader class,
at any point in the future you can call repeatForEach and
pass it a callback, and it will perform the callback on each of
the strings in the original list, in sequence. This is equivalent
in usefulness to our original ArrayReader class. For example,
here is how you would print out all of the strings:
object Main {
def main(args: Array[String]) {
val arrayReader: Reader = new ArrayReader(List(“Foo”, “Bar”,
“Baz”));
arrayReader.repeatForEach (println);
} a
} z
22 May 2008
Now let’s write the CharReader class. It requires a Reader
upon construction, and provides character-by-character ac-
���������������������������
class CharReader (r: Reader) extends Reader { ���������������������������������
override def repeatForEach (f: String => Unit) = {
r.repeatForEach ((s: String) =>
s.toList.foreach ((c: Char) =>
f (c.toString)));
}
}
This is more difficult to understand, so let’s work through it
step-by-step. The CharReader takes any kind of Reader as an
argument upon construction, and is also a Reader itself – just like
in our original example. Like the ArrayReader it provides a re-
peatForEach method that takes a callback argument. Whenever
this method is called with a callback argument f, the CharReader
calls repeatForEach on its underlying reader, providing its own
callback, which calls toList.foreach on each String, allowing each
character to be processed individually. The callback f is invoked
many of the type declarations without sacrificing any type
safety at all. Thus you can write this more compactly this way:
�������������������������
�������������������������������������
class CharReader (r: Reader) extends Reader {
override def repeatForEach (f: String => Unit) = {
��������������������������������
r.repeatForEach (s => s.toList.foreach (c => f (c.toString)));
}
}
Now let’s try using our new classes: ���������������������������������������
object Main {
�������������������������������������������������������� ��������������������������������������������������
def main(args: Array[String]) {
���������������������������������������������������������
������������������������������������������������������� ��������������������������������������������������������
val arrayReader: Reader = new ArrayReader(List(“Foo”, “Bar”,
������������������������������������������������������ �������������������������������������������������������
“Baz”));
������������������������������������������������������� ����������������������������������������������������������
val charReader: Reader = new CharReader (arrayReader);
������������������������������������������������������ �������������������������������������������������������������
����������������������������������������������������������� �����������������������������������������������������������
arrayReader.repeatForEach (println);
��������������������������������������������������������� �����������������������������������������������
charReader.repeatForEach (println);
���������������������������������������������������������
���������������������������������������������������������� ��� ���������������������
������������������������� ��� ������������������������������
��� ��������������
Here’s the output:
������������������������������������������������������ ��� ��������������
��������������������������������������������������������� ��� ��������������
Foo
����������������������������������������������������� ��� �����������������������������
Bar
����������������������������������������������������������
Baz
F
������������������������������������������������������ ������������������
��������������������������������������������������������� ��������������������������������������������������������
o
������������������������������������������������������� ���������������������������������������������������������
o
������������������������������������������������������� �����������������������������������������������������������������
B
��������������������������������������������������������� �����������������������������������
a
r
B
������������������������
JDJ.SYS-CON.com ��������������������
 FEATURE
This looks surprisingly like our original example, doesn’t it?
We have a Reader interface with ArrayReader and CharRead-
er implementations with roughly the same meanings as in the
corresponding Java versions. The only difference is that this
example has no mutable state whatsoever. There is no point
at which any variable is modified from an old value to a new
value. Although state is still shared between the arrayReader
and charReader objects (the charReader contains a reference
to the arrayReader), it’s simply not possible for them to inter-
act inappropriately. Whenever you call:
arrayReader.repeatForEach (...)
a given input of ... will always produce exactly the same
result. There isn’t any method for resetting the iterator either,
because there’s no such concept in this design. You can call
arrayReader.repeatForEach as many times as you like, and
each time it will iterate through the entire list with no possibil-
ity of problems occurring. It can be used in a multithreaded
environment and race conditions won’t even be possible. Race
conditions can only occur when you have mutable state.
It may seem like cheating to convert the program to a
functional one by changing the design to use callbacks, but we
argue that it’s fair game. Functional programming is all about
programming without side effects (i.e., mutating state), and
that means coming up with new idioms for solving familiar
problems. In this case, the original iterator-based solution
was very typical Java code. To achieve the same thing without
side effects we had to pass callbacks around (also known as
closures, function objects, or anonymous functions) but this is
very typical in functional languages, which typically provide a
clean, elegant syntax to support that style of programming.
Functional Programming in Java
Let’s explore how we can introduce functional program-
ming concepts into our Java code, in case our managers are
not yet ready to allow the use of Scala for commercial software
development. Unfortunately Java lacks many advanced
functional programming features and its syntax is not ideal
for this. Higher order functions (i.e., functions that operate on
other functions) are almost impossible to express, especially
if you want to make them strongly typed. (Defining strongly
typed higher order functions requires the use of generics and
Java’s “type erasure” implementation of generics throws away
a significant amount of type information at runtime in the in-
terest of efficiency. Martin Odersky giveth and Martin Odersky
taketh away.)
That being said, the recent support in Java for anonymous
classes still allows us to represent our Scala Reader example
reasonably faithfully in Java.
The reader example is revisited on Listing 2.
This Java solution is written in a functional style, although
it may look awkward to most Java programmers. We had to
introduce a StringCallback interface to represent the callback,
and used the new anonymous class capability in several
places. However this solution has all the virtues of the Scala
solution. It is immune to the problems associated with shared
mutable state, and can be used safely in a multithreaded
environment without any need for locking or any risk of race
conditions.
24 May 2008
Not all functional programming idioms can be translated
into Java, but some of the simpler ones can, and although
they may seem unnatural at first, they do bring benefits. It’s
always worth asking the question: Can I solve this problem
without the use of mutable state?
A Reconciliation Example
Say you have two lists of information that have to be
reconciled. You want to know which items are in one list
and not in the other, and vice versa. This kind of problem
sometimes crops up in financial applications, and is often
solved by traversing both lists and building a data structure
to store the differences (e.g., a hash table). A more function-
al solution to the problem is to write code that can subtract
the contents of one list from another as shown in Listing 3.
This example shows a functional approach to reconcil-
ing lists of information, but also shows the kind of com-
promise that has to be made when doing this style
of programming in Java. Unfortunately the built-in Java
Collection classes do not efficiently support immutable
lists, so there is no way in the diff function to build up
the result without either using mutation or creating our
own immutable collection classes. We chose a practi-
cal approach: Create a fresh LinkedList object when the
recursion bottoms out then mutate it repeatedly by calling
addFirst to build up the result. Although this is not func-
tional, we are doing it in only one place, and we are chang-
ing an object that was created within the diff method, is
never shared, and has no permanent state after the initial
call returns. So the implementation of diff is “mostly func-
tional,” and the rest of the example is completely func-
tional. This solution has most of the virtues of functional
programming in terms of avoiding the problems of shared
mutable state, and doesn’t destroy its input lists the way
the removeAll method would (as defined in the Java Col-
lection classes).
A Tree Aggregation Example
Say you have a tree of any type of object. Let’s keep it
simple and represent the tree as an array of Java objects,
each element of which could be a leaf node or another
array. You might want to calculate a value based on all
elements of the tree. A functional approach to this
problem is to define a TreeWalker that can traverse any
tree and accept a user-provided aggregation function.
See Listing 4.
Once again we rely on Java’s new anonymous class capa-
bility, but we avoid the use of generics because Java’s “type
erasure” implementation of generics would not allow us to
use instanceof.
In this example we created a tree of numbers called my-
Tree with eight nodes. Then we used the TreeWalker twice,
each time passing it a different aggregation rule; one that
knows how to aggregate a tree by adding, and another that
knows how to aggregate a tree by multiplying.
The point is that tree traversal and aggregation have
been factored into a general-purpose capability, and
complex operations can be performed on the tree without
any need for mutable state. As in the previous example,
there is brief use of mutable state in the implementa-
JDJ.SYS-CON.com
tion of the aggregate function, but it’s on a locally created the meaning of the program. The loss of expressive power
unshared object, so it’s acceptable. Programming languages from having to avoid the use of mutable state is compen-
like Scala that are designed for functional programming sated for by providing better support for manipulating func-
would not even require that, since they support immutable tion objects and combining them in useful ways.
collections. You can start using rudimentary functional programming
techniques in Java immediately, but advanced techniques
Summary require better programming language support than Java
The use of mutable state makes programs hard to under- offers. Scala is a useful language for Java programmers to
stand, especially in conjunction with currently popular pro- explore, as it provides excellent support for functional pro-
gramming practices in which objects are created indirectly and gramming while fitting smoothly into the Java developer’s
state sharing is not obvious from reading the code. Furthermore world.
in multithreaded environments, programs relying on mutable
state are prone to race conditions, requiring the use of locking Additional Reading
that can impact performance and make programs even harder • Wikipedia: http://en.wikipedia.org/wiki/Functional_
to understand and debug. programming.
Functional programming offers an alternative approach • Can Your Programming Language Do This?: http://www.
to solving computing problems based on transforming joelonsoftware.com/items/2006/08/01.html.
inputs into outputs in a stateless way. Functional programs • Bill Venners, Martin Odersky, and Lex Spoon. First Steps
are referentially transparent, meaning function calls can to Scala. May 9, 2007: http://www.artima.com/scalazine/
always be substituted with their results without changing articles/steps.html.
Listing 1 Listing 2
public interface Reader { public interface StringCallback {
String read(); public void doString (final String s);
} }
public class ArrayReader implements Reader { public interface Reader {
public void repeatForEach (final StringCallback f);
private String[] sourceArray; }
private int currentIndex;
public class ArrayReader implements Reader {
public ArrayReader(String[] s) {
sourceArray = s; private final String[] strings;
currentIndex = 0;
} public ArrayReader (final String[] strings) {
this.strings = strings;
public String read() { }
if (sourceArray != null && currentIndex < sourceArray.length) {
return sourceArray[currentIndex++]; public void repeatForEach(final StringCallback f) {
} for (String s : strings) {
return null; f.doString(s);
} }
} }
}
public class CharReader implements Reader {
public class CharReader implements Reader {
private Reader reader;
private String currentString; private final Reader r;
public CharReader (Reader r) { public CharReader (final Reader r) {
reader = r; this.r = r;
currentString = null; }
}
public void repeatForEach(final StringCallback f) {
public String read () { r.repeatForEach(new StringCallback() {
while (currentString == null || currentString.length() == 0) {
currentString = reader.read(); public void doString(String s) {
if (currentString == null)
return null; for (char c : s.toCharArray()) {
} f.doString(Character.toString(c));
}
String s = currentString.substring(0, 1);
currentString = currentString.substring(1); } });
return s; }
} }
}
JDJ.SYS-CON.com May 2008 25
 FEATURE

public class Main { System.out.println (“In first list but not second:”);
for (String s : reconciler.diff(firstList, secondList)) {
public static void main(String[] args) { System.out.println (“ “ + s);
final Reader arrayReader = new ArrayReader(new String[] { “Foo”, }
“Bar”, “Baz” });
final Reader charReader = new CharReader (arrayReader); System.out.println (“In second list but not first:”);
for (String s : reconciler.diff(secondList, firstList)) {
System.out.println (“ “ + s);
arrayReader.repeatForEach(new StringCallback() {
}
}
public void doString(String s) {
System.out.println (s);
}
} });

charReader.repeatForEach(new StringCallback() {

Listing 4
public void doString(String s) {
public interface Aggregator {
System.out.println (s);
public Object initialValue ();
}
public Object combine (Object x, Object y);
}
});
}
public class TreeWalker {

}
Output:
public Object aggregate (Object[] tree, Aggregator a) { �����������������������������������������������
Foo
Bar
Baz
Object o = a.initialValue();
for (Object item : tree) { ���������������������������
if (item instanceof Object[]) {
F
o = a.combine(o, aggregate((Object[])item, a));
o
} else {
o
o = a.combine(o, item);
B ������������������������������������ �������������������������������������������������������������
}
a ������������������������������������ ������������������������������������������������������
}
r
return o; ��������������������������������������� ������������������������������������������������������
B
a
} �������������������������������������� ���������������������������������������������������������
z
} ���������������������������������������� ��������������������������������������������������������������
������������������������������������� ���������������������������������������������������������������
public class Main {
���������� ���������������������������������������� ����������������������������������������������������������
Listing 3 ��������������������
public static void main(String[] args) {
��������������������������������������� �������������������������������������������
public class Reconciler<T> { ����������������������
�����������������
public LinkedList<T> diff (final List<T> l1, final List<T> l2) { Object[] myTree = ��������������������������������������������������������������
new Object [] { 4, ��������������������������������������������������� �������������������������������������������������������������
if (l1 == null) 7, ����������������������������������������������������� �������������������������������������������������������
return null; new Object[] {3, 8},
������������������������������������������������������ ������������������������������������������������������������
new Object[] {2, new Object[] { 5, 9 }},
if (l1.size() == 0) ����������������������������������������������������� ��������������������������������������������������
6 };
return new LinkedList<T>(); ��������������������������������������������������������
TreeWalker treeWalker = new TreeWalker(); ��������������������������������������������������� �����������������������������������������������������������
final T head = l1.get(0);
������������������������������������������������������ �����������������������������������������������������������
final List<T> tail = l1.subList(1, l1.size());
Object sum = treeWalker.aggregate(myTree, new Aggregator() { ������������������������������������������������������� �����������������������������������������������������������
public Object initialValue() { return 0; } ����������������������������������������������������������� ��������������������������������������������������������������
if (l2.contains(head))
public Object combine(Object x, Object y) {
return diff (tail, l2); ������������������������������������������������ �������������������������������������������������������
return ((Integer)x).intValue() + ((Integer)y).intValue();
} });
�������� �����������������������������������������������������������
LinkedList<T> result = diff (tail, l2);
result.addFirst(head); System.out.println (“Sum is “ + sum); ��������������������������������������������������������������
return result; ������������������������������������������������������� ������������������������������������������������������������
} Object product = treeWalker.aggregate(myTree, new Aggregator() { ����������������������������������������������������������� ������������������������������������������������������������
public Object initialValue() { return 1; } �����������������������������������������������������
public static void main(String[] args) { public Object combine(Object x, Object y) {
�����������������������������������������������������������
return ((Integer)x).intValue() * ((Integer)y).intValue();
final List<String> firstList = Arrays.asList(new String[] } });
�����������������������������������������������������������
{“Adam”, “Bob”, “Charlie”}); System.out.println (“Product is “ + product); ������������������������������������������������������������ ��������������������
final List<String> secondList = Arrays.asList(new String[] } �����������������������������������������
{“Bob”, “David”});

}
final Reconciler<String> reconciler = new Reconciler<String>();

�����������������������
26 May 2008 JDJ.SYS-CON.com ���������������������������������
������������������������������������������� ����������������������������� ��
 FEATURE
by Michael Galpin
I
f you’ve been working with Web Services for a long
time, chances are you’ve worked with Apache Axis
and that you have an Axis Web Service somewhere
in your code base. You probably also know about
the many improvements in Axis2, especially around
support for the more modern WS-* standards. So maybe
you’ve been planning on migrating these old Axis services,
but it can be hard to justify spending a lot of time on
something that’s working just fine. However, there’s a great
new migration path available to you: WSO2’s Web Services
Application Server (WSAS.) With WSAS, you can take your
existing Axis Web Service, redeploy it to WSAS, and then
with just a few clicks enable things like WS-Security and
WS-Reliable Messaging. There’s no need to rewrite or
regenerate any code.
Does this sound too good to be true? It’s not, just
read on.
Prerequisites
In this article, you’ll work with WSO2 WSAS. You’ll
definitely want to download the latest version of WSAS.
You can run it with any Java Web container, such as
Tomcat. Or you can run it in standalone mode. This
article assumes experience with Axis, and in particular
with deploying an Axis Web Service. It references a sample
from Axis 1.4. Obviously a familiarity with Web Services in
general, and with some of the modern WS-* standards is
very useful.
Example of an Existing Axis Web Service
Let’s take a typical starting point for a lot of people. You
have a service you developed and used Axis to expose as a
Web Service. There’s a good chance that the service might
not have been originally intended to be a Web Service. May-
be it was just an internal service used by one application.
Michael Galpin is an archi- You then realized it would be valuable to other applications
tect at eBay in San Jose, you were developing and used Axis to do this. There are a
CA. He’s been developing couple of different ways to do this with Axis, but the most
software since 1998, and powerful and flexible is to use Axis’s Web Service Deploy-
holds a degree in math- ment Descriptor (WSDD.)
ematics from the California Let’s take a look at a sample WSDD. Axis ships several
Institute of Technology. great samples. We’ll use the bid-buy sample. It mimics an
e-commerce system. It exposes a Web Service for doing
mike.sr@gmail.com typical e-commerce tasks like requesting a price quote and
28 May 2008
Migrating with WSAS
submitting purchase orders. Let’s take a look at its WSDD
file shown in Listing 1.
This is a fairly typical WSDD. It describes two services.
Each service has several operations that can be called. It
also describes mappings between the parameter types of
the service to Java classes. To deploy this you’d use Axis’s
deployment tool, the AdminClient.
If you’ve been using Axis over the years, all of this is old
news. You’ve probably seen dozens of WSDDs and used
Figure 1 WSAS Management Console: Services Tab
Figure 2 WSAS Management Console: Services Tab
Figure 3 Upload of WSDD confirmed
JDJ.SYS-CON.com
the AdminClient on a regular basis. It works great and is
reliable – that’s a big part of why Axis has been such a huge
success. Still, Web Services have evolved and you need
more than Axis to take advantage of these advances. For a
simple service like the one in Listing 1, it might not be too
hard to change the code to get it to work on a newer Web Figure 4 Axis service deployed
Service stack. It would still take some work. That work only
goes up for more complicated services. This is where WSAS
comes in. Let’s take a look at just how easy the upgrade is
with WSAS.
Redeploying to WSAS: Using WSDD
You can upgrade your Axis service with WSAS very easily. Figure 5 Link to Bid WSDL
There’s no code to change. There’s no code to generate or
regenerate. There’s no configuration file to alter or add.
All you need is a WSDD and JAR file with the classes for
the service. That’s it. If you’ve been using Axis, there’s a
good chance you already have both of these laying around
already.
For the Axis bid-buy sample we’re using, all we have to
do is put the class files in a JAR. To do this we move them
into a directory structure reflecting the package structure
(samples.bidbuy) and then run Java’s jar command as
shown in Listing 2 (Listings 2 and 3 can be downloaded
from the online version of this article at http://jdj.sys-con.
com).
Now we’re ready to get started with WSAS. Load up the
Management Console. Go to the Services tab and you
should see something similar to Figure 1.
Notice the Upload Axis1 Service (.wsdd) Option. That’s Figure 6 Bid WSDL
exactly what we want to do. Go ahead and choose that and
you’ll see a screen similar to Figure 2.
This is a straightforward interface. Simply use the
Browse buttons to locate the deployment descriptor for
your Web Service and the jar file you created for your
service. Then click upload. You should get a confirmation
screen similar to Figure 3.
The upload is asynchronous, but shortly afterwards
your list of Service Groups should show a “deploy.wsdd”
(that was the name of the deployment descriptor from the
bidbuy sample) similar to Figure 4.
That’s all you have to do! Your crusty old Axis Web
Service is now running on the super-modern WSAS Web
Service stack. Your Web Service is going to benefit greatly
even if this is where you stop. Since it’s running on WSAS
(and thus Axis2) you’ll get great performance benefits.
WSAS uses a powerful combination of a StAX parser and
the Axis Object Model (AXIOM) for parsing SOAP. This is
much more efficient in terms of both speed and memory
usage than Axis1. The Axis2 architecture also lets you plug
in whatever data binding you want, such as JAXB. It also
enables Message Transmission Optimization (MTOM)
for your service, by default. This allows for much more
efficient transport of binary data if your service accepts or Figure 7 Manage the bid service
receives binary data. Of course you probably don’t want to
stop here, as now there’s a whole new world of options that file that WSAS has created to describe your service. It should
you’ve just enabled by migrating to WSAS. Let’s take a look look similar to Figure 6.
at those now. One thing to notice here is the “invokeAxis1Service” sec-
tion. The bid-buy sample we picked was an RPC-encoded
Examining the Service on WSAS service, a style of SOAP that’s been deprecated because of its
In our list of services, click on the WSDL 2.0 link for the Bid brittleness. So what has WSAS done here?
Service, as shown in Figure 5. First, just because RPC-encoding is far from a best prac-
This should bring a graphical representation of the WSDL tice doesn’t mean that your service isn’t using it. You could
JDJ.SYS-CON.com May 2008 29
 FEATURE
Figure 8 Manage modules for bid service
Figure 9 Enabling WS-Security
Figure 10 WS-Security enabled
very well have partners, both internal and external, that are
using this format when invoking your service. No migration
path can simply leave those partners high and dry by telling
them to re-code their client code. So WSAS has deployed a
fully backwards-compatible version of your service. Any-
body using RPC-encoding to invoke your Web Service can
continue to do so. Not only do you not have to change any
code to upgrade to WSAS, your clients don’t either.
30 May 2008
Second, WSAS has created more modern bindings for
your service. This is for either existing clients that can
be re-coded or new clients who want to take advantage
of new Web Service standards. Again, you didn’t have
to write any code, yet now there’s a SOAP 1.2 binding to
your service. This is important, because now we can start
enabling other SOAP-based technologies, i.e., various WS-*
technologies.
Managing the Service on WSAS
Go back to your list of service, but this time click on the
bid link under services. This should bring up the interface
shown in Figure 7.
There’s a lot you can do here, but for now let’s click on
the Manage Module Engagements link. That should bring
up the interface shown in Figure 8.
The various modules in the Module combo box repre-
sent Axis2 modules that implement various WS-*. Let’s say
we’re interested in WS-Security. To enable this, we simply
pick rampart from the list, as shown in Figure 9.
Click the Engage button, and just like that WSAS will
activate its WS-Security module for your service, as shown
in Figure 10.
Similarly, you can pick sandesha from the Module list
and WSAS will enable WS-Reliable Messaging for your
service. Let’s take a look at some of the security options we
have available to us.
Security Configuration
Let’s go back to our Service listing (Figure 7) and this
time click the Security Configuration link. This will bring
up the interface shown in Figure 11.
What is this list you see here? This list represents 11 dif-
ferent pre-set security configurations included with WSAS.
These 11 configurations represent the most common sce-
narios for securing a Web Service. Whatever your security
requirements are, it’s probably covered by one of them.
Enabling any of them is trivial, just pick its radio button
and continue. For example, let’s say we pick the “Sign and
encrypt - TripleDES/RSA15 – DK” option then we’ll bring
up the interface shown in Figure 12.
Notice that WSAS already has both a trusted certificate
store and a keystore location provided to support encryp-
tion. The Management Console has a Keystore tab (on the
left) that you can use to manage certificates and provid-
ers. Once you apply the security configuration, you can
go back to the list of services and click on the Policy, as
shown in Figure 13.
This will bring up the Policy, shown in Listing 3. The
Policy is an extensible way to configure any/all of the WS-*
technologies you have enabled for your service. Where did
this Policy come from? It was generated by WSAS for you
when you selected the Security Configuration. You can
still manually edit this file either to tweak security or to
configure your WS-Reliable Messaging policy.
Summary
In this article we’ve started with an Axis service, and very
easily redeployed it to WSAS. All we needed was its WSDD
deployment descriptor and a JAR of all its classes. We saw
JDJ.SYS-CON.com
how WSAS made sure to maintain backwards compatibility
with the original service, even though the original service
used the deprecated RPC-encoding format. Once we brought
our service into WSAS, we could easily enable WS-Security
and WS-Reliable Messaging. Finally, WSAS made it especially
easy to pick a powerful Security Configuration, automatically
managing the Policy for us.
Resources
• Take a look at the WS-RM specification from the devel-
operWorks library (http://www.ibm.com/developerworks/
library/specification/ws-rm/).
• Learn about the benefits of WS-Security in the developer-
Works article Implementing WS-Security (http://www.ibm.
com/developerworks/webservices/library/ws-security.
html).
• WSAS enables WS-Addressing automatically. Learn how Figure 11 Security configuration of bid service
important this is in the developerWorks article The hidden
impact of WS-Addressing on SOAP (http://www.ibm.com/
developerworks/webservices/library/ws-address.html).
• Read about the Axis2 module system in the developer-
Works article Web Services and Axis2 architecture (http://
www.ibm.com/developerworks/webservices/library/ws-
apacheaxis2/).
• Explore the benefits of using a StAX processor in the devel-
operWorks article StAX’ing up XML, Part 1: An introduction
to Streaming API for XML (http://www.ibm.com/devel-
operworks/opensource/library/x-stax1.html).
• Keystores are integral part to your security. Learn all about
them in the developerWorks article Unshackling key man-
agement in Java security (http://www.ibm.com/developer-
works/ibm/library/it-keyjava.html).
• You’re going to want to download WSO2 WSAS (http://
wso2.com/products/wsas/).
• Read about the latest features in WSO2 WSAS 2.0 (http:// Figure 12 Enabling Triple DES/RSA15 - DK
blog.ruchith.org/2007/07/wso2-wsas-20-released.html).
• Learn from and interact with the WSO2 community on
the WSAS Wiki (http://wso2.org/wiki/display/wsasjava/
Home).
• Learn about exposing your services as Web Services easily
with Axis2 (http://ws.apache.org/axis2/).
• Learn how Axis2 can enable your SOA designs in the devel- Figure 13 Accessing the policy for the bid service
Listing 1: WSDD for Axis bid-buy sample samples.bidbuy.Address”/>
<deployment xmlns=”http://xml.apache.org/axis/wsdd/” xmlns: <beanMapping qname=”bid:LineItem” languageSpecificType=”java:
java=”http://xml.apache.org/axis/wsdd/providers/java” xmlns: samples.bidbuy.LineItem”/>
bid=”http://www.soapinterop.org/Bid” xmlns:reg=”http://www.soapin- <!-- * * * * * * * * * * * * * * * * * * * * * * * * * * *
terop.org/Registry”> * -->
<service name=”Bid” provider=”java:RPC”> <service name=”BidRegistry” provider=”java:RPC”>
<namespace>http://www.soapinterop.org/Bid</namespace> <parameter name=”className” value=”samples.bidbuy.
<parameter name=”className” value=”samples.bidbuy. RegistryService”/>
BidService”/> <parameter name=”allowedMethods” value=”Register
<parameter name=”allowedMethods” value=”RequestForQuote Unregister Lookup LookupAsString”/>
SimpleBuy Buy Ping”/> </service>
</service>
<beanMapping qname=”reg:Service” languageSpecificType=”java:
<beanMapping qname=”bid:PurchaseOrder” languageSpecificType=”j
samples.bidbuy.Service”/>
ava:samples.bidbuy.PurchaseOrder”/>
</deployment>
<beanMapping qname=”bid:Address” languageSpecificType=”java:
JDJ.SYS-CON.com May 2008 31

Java and
Free Software in Brazil
Bridging the digital divide
A
couple of recent Brazil-related
news events suggested the
theme for this column: Java
in Brazil. First, the annual
International Free Software Forum
(FISL) (http://fisl.softwarelivre.
org/9.0/www/) was recently held in
Porto Alegre, Brazil. FISL is one of the
world’s most important free software
conferences, and more than 7,400
people attended this year, including
many from Sun’s Java organization.
Second, Sun Microsystems and the
Brazilian organization responsible for
digital television (DTV) conversion
announced (http://java.sys-con.com/
read/514870.htm) that they would
join forces to develop an open source
content platform based on Java tech-
nology for use in the country-wide
conversion of television applications
and services.
Software Livre
FISL is a major event in the free
software world, not only because
Brazil is a significant emerging
economy but also because the Brazil-
ian government, under the presi-
dency of Luiz Inácio Lula da Silva
(Lula), has championed the cause of
free software. (SouJava (http://www.
soujava.org.br/display/v/Inicial),
the largest Java Users Group in Brazil
and possibly in the world – they have
more than 18,000 members – is a ma-
jor participant in FISL. SouJava was
the first Java User’s Group to join the
JCP back in 2005, and its president,
Bruno Souza – now a Sun employee
– is a tireless champion of Java and
open source.)
Patrick Curran is Chair of The Brazilians believe that “soft-
the JCP and Director of ware livre” can help to bridge the
the JCP Program at Sun “digital divide,” (http://en.wikipedia.
Microsystems, Inc. org/wiki/Digital_divide) to ensure
that all citizens have free access
patrick@jcp.org to public services, to preserve and
32 May 2008
defend national sovereignty (avoid-
ing domination by non-Brazilian cor-
porations), and to conserve national
resources by eliminating software
licensing fees. Because Java is based
on open standards and is freely avail-
able, it has been – and is increasingly
– adopted by Brazilian government
agencies for the development of
software that delivers services to its
citizens, from taxation to health care.
For example, in Brazil, health care
is free to all citizens. This posed a
variety of organizational and man-
agement problems, from tracking
patients’ records to scheduling ap-
pointments. To solve these problems,
a comprehensive health-care auto-
mation system (http://www.infoq.
com/articles/Brasilian-Healthcare-
System) was developed entirely in
Java. The system is designed to handle
all the requirements of a public health
care information system including
scheduling, inventory management,
billing, disease tracking, reporting
and auditing, regulatory compli-
ance, and security access control. The
system, claimed to be the largest Java
Enterprise application ever built, was
first deployed to automate all health
JSR WATCH
Advertiser Index
Advertiser URL Phone Page
DataServices World at SOA World dataservicesworld.sys-con.com 888-303-5282 27
Patrick Curran
Fiorano www.fiorano.com/downloads 7
care services in Sao Paulo – the largest
city in Brazil, and the fourth largest in InterSystems www.intersystems.com/cache27p 617-621-0600 Cover IV
the world with over 20 million people.
Today the application is in production
in Sao Paulo and 20 other cities and is
being implemented nationally. Java Developer’s Journal www.jdj.sys-con.com 888-303-5282 17
The system has been open sourced by
the Brazilian government for use by
any public health organization, and
its implementation is being con-
Kaazing www.kaazing.com 650-943-2436 4
sidered in other Portuguese-speak-
ing countries, such as Angola and
Mozambique.
A couple of other recent an-
nouncements illustrate the strength NetBeans/Sun Microsystems www.netbeans.org Cover II
of the free software movement in
Brazil. At this year’s FISL, the Brazil-
ian Ministry of Education announced
plans (http://news.northxsouth. Northwoods Software Corp. www.nwoods.com 800-434-9820 13
com/2008/04/24/brazilian-govern-
ment-to-deploy-53k-open-source-
labs-serving-52-million-students/)
to deploy 53,000 computer labs
SOA World Conference & Expo 2008 www.soaworld2008.com 888-303-5282 23
throughout the country, giving 52
million students access to computer
resources. The computers in the labs
will be run as a Linux distribution
called Linux Educacional, which is Software FX www.softwarefx.com 561-999-8888 Cover III
based on Debian and the KDE desk-
top. Also this month, the Brazilian
Election Supreme Court announced
SYS-CON e-Newsletters www.sys-con.com 888-303-5282 33
SYS-CON Media books.sys-con.com 888-303-5282 9
General Conditions: The Publisher reserves the right to refuse any advertising not meeting the standards that are
set to protect the high editorial quality of Java Developer’s Journal. All advertising is subject to approval by the
Publisher. The Publisher assumes no liability for any costs or damages incurred if for any reason the Publisher
fails to publish an advertisement. In no event shall the Publisher be liable for any costs or damages in excess
of the cost of the advertisement as a result of a mistake in the advertisement or for any other reason. The
Advertiser is fully responsible for all financial liability and terms of the contract executed by the agents or agen-
cies who are acting on behalf of the Advertiser. Conditions set in this document (except the rates) are subject
to change by the Publisher without notice. No conditions other than those set forth in this “General Conditions
Document” shall be binding upon the Publisher. Advertisers (and their agencies) are fully responsible for the
content of their advertisements printed in Java Developer’s Journal. Advertisements are to be printed at the
discretion of the Publisher. This discretion includes the positioning of the advertisement, except for “preferred
positions” described in the rate table. Cancellations and changes to advertisements must be made in writing
before the closing date. “Publisher” in this “General Conditions Document” refers to SYS-CON Publications, Inc.
This index is provided as an additional service to our readers. The publisher does not assume any liability for errors or omissions.
JDJ.SYS-CON.com JDJ.SYS-CON.com May 2008 33
 JSR WATCH
“ It’s fitting that Java is now the platform of choice for
implementing interactive TV infrastructure and applications,
since the language – back when it was called Oak –
was originally designed for just this purpose”
that the 2008 elections in Brazil
will switch from proprietary OS-
based electronic voting machines
to systems based on GNU/Linux
(http://www.techforce.com.br/
index.php/news/linux_blog/tse_
migrates_to_linux).
Digital TV in Brazil
Brazil, like the United States,
is facing a transition to digital TV
transmission in the near future. By
the year 2016, analog transmissions
will cease, and all TV broadcast-
ing will be digital. Brazil intends
to tackle this transition in a more
ambitious manner than the US
– defining a digital TV standard
that will not only serve TVs but
also mobile devices. In line with
its policy of providing equal access
to all citizens, they have chosen
an open source and royalty-free
approach (http://biz.yahoo.com/
bw/080304/20080304005617.html?.
v=1) that defines a Java-based plat-
form for the delivery of interactive
services for digital TV devices. The
specification builds on the same
Java platform that currently serves
as the basis for other widely de-
ployed digital television standards,
including OpenCable/tru2way,
Multimedia Home Platform, GEM-
IPTV, and Blu-ray Disc/BDJ.
It’s fitting that Java is now the
platform of choice for implement-
ing interactive TV infrastructure
and applications, since the lan-
guage – back when it was called Oak
– was originally designed for just
this purpose.
This Month’s Active JSRs
This month three JSRs reached
the Early Draft Review (EDR)
stage. The Early Draft is the Expert
Group’s first deliverable. There’s
34 May 2008
no ballot at this stage – the draft is
simply intended to provide the JCP
membership and the public with
something that is detailed enough
to generate useful feedback. I
encourage you to download the
drafts from the JCP website (follow
the links below) and to send your
feedback to the Spec Leads.
JSR 303: Bean Validation (http://
jcp.org/en/jsr/detail?id=303), led by
RedHat, defines a metadata model
(based on annotations and XML
descriptors) and API for JavaBean
validation, enabling simple and
reusable validation mechanisms at
each tier of the application.
JSR 235: Service Data Ob-
jects (http://jcp.org/en/jsr/
detail?id=235), led by IBM and BEA,
standardizes Data Objects in terms
of change history, compound data
objects, dynamic and generated
API, metadata, support for XML and
Web services, neutral representa-
tion of business data, import/ex-
port from common formats, valida-
tion and constraints, relationship
integrity, and navigation.
JSR 249: Mobile Service Archi-
tecture 2 (http://jcp.org/en/jsr/
detail?id=249), led by Vodafone and
Nokia, updates the Mobile Service
Architecture (MSA) specifica-
tion ( JSR 248) to incorporate new
component JSRs and to define ad-
ditional clarifications and require-
ments for implementing the JSRs in
mobile devices.
Two JSRs Submitted for
Initial Approval Ballot
It may seem as if JSR approval
ballots are a foregone conclusion
and that rejection is unlikely, but
the example of JSR 324: On Screen
MIDlet API for Java ME (http://jcp.
org/en/jsr/detail?id=324) (led by
SK Telecom) demonstrates that
it’s not always so simple. This JSR
proposed to define APIs to enable
MIDlets to be displayed and acti-
vated on the idle screen of em-
bedded devices. The JSR failed its
approval ballot in April 2008. Those
voting “no” argued that idle screen
integration should be handled by
JSR 271 MIDP 3, and that a separate
JSR defining additional APIs is un-
necessary.
The ballot for JSR 325: IMS Com-
munication Enablers (ICE) (http://
jcp.org/en/jsr/detail?id=325) has
not yet closed (as I write this), but
since this JSR extends rather than
overlaps with another it’s more
likely to be approved. The JSR
builds on JSR 281, defining a high-
level framework and API that will
provide Java ME-based devices with
a simple way to access IP Multime-
dia Subsystem (IMS) Communica-
tion Enablers for services such
as Presence, Instant Messaging,
Multimedia Telephony, and Push to
talk Over Cellular (PoC).
Finally this month, JSR 113:
Java Speech API 2.0 (http://jcp.
org/en/jsr/detail?id=113), led by
Conversational Computing Corpo-
ration, is up for its Final Approval
Ballot. Version 1 of the Java Speech
API, which was developed by
Sun before the JCP was created,
defines APIs that allow developers
to incorporate speech technology
into user interfaces for their Java
programming language applets
and applications. Version 2.0 ex-
tends and builds on version 1,
and tracks the emerging W3C
Speech Interface Framework
(http://www.w3.org/TR/voice-
intro/) whenever possible.
That’s all for now. On to
JavaOne…
JDJ.SYS-CON.com
 Embed the fastest engine.

For software developers seeking competitive advantages, InterSystems Caché® makes

applications more valuable by increasing their speed and scalability, while decreasing hard-
ware and administration requirements. This is the fastest database engine you can put in
your applications, and it's the only database that gives you the combined benefits of
object and relational technologies. Thanks to its innovative architecture, Caché spares Java
and .NET programmers a lot of tedious work by eliminating the need for object-
relational mapping. Caché is available for Unix, Linux, Windows, Mac
OS X, and OpenVMS – and it supports MultiValue development. Caché
is deployed on more than 100,000 systems worldwide, ranging from two
to over 50,000 users. Embed our innovations, enrich your applications.

Make
Applications
More
Valuable
Come see product demonstrations at booth #410 at JavaOne, May 6th-9th, San Francisco

Download a free, fully functional, no-time-limit copy of Caché, or request it on CD, at InterSystems.com/Cache27P
© 2008 InterSystems Corporation. All rights reserved. InterSystems Caché is a registered trademark of InterSystems Corporation.3-8 EmbedCache27JDJ