 |
|
|
|
|
|
Java Web services: WS-Security with Metro
The Metro Web services stack is based on the reference implementations of the JAXB 2.x and JAX-WS 2.x Java standards but also includes support for a full range of WS-* SOAP extension technologies. This article continues Dennis Sosnoski's Java Web services column series with coverage of WS-Security configuration and usage in Metro.
|
|
Articles |
|
01 Dec 2009 |
|
| |
Integrating FileNet P8 with the J2EE messaging infrastructure
Learn how to integrate existing systems across different industries
using the IBM FileNet(R) P8 workflow. This article offers a guided tour to show how
to integrate a J2EE message infrastructure with FileNet P8. Learn the details
of the message format that FileNet P8 uses to talk to any messaging
infrastructure.
|
|
Articles |
|
25 Nov 2009 |
|
| |
Using Simple for XML serialization
Java developers have a variety of choices when it comes to serializing and deserializing Extensible Markup Language (XML) objects. Simple is one such example, and it offers a number of advantages over its competitors. In this article, explore an introductory overview of how to use Simple within an XML communication system.
|
|
Articles |
|
24 Nov 2009 |
|
| |
Practically Groovy: SwingBuilder and the Twitter API, Part 2
In this Practically Groovy article, Scott Davis continues building the Groovy Twitter client named Gwitter that he began in Part 1. This time, he tackles HTTP Basic authentication and use of Groovy's ConfigSlurper to read in configuration settings.
|
|
Articles |
|
17 Nov 2009 |
|
| |
Java development 2.0: REST up with CouchDB and Groovy's RESTClient
A burst of innovation in the open source world over the last few years has led to an increase in Java developer productivity. Freely available tools, frameworks, and solutions address once-common time sinks. A promising new entry on the scene is Apache CouchDB, hailed by some as the database for Web 2.0. The big picture of CouchDB is easy to grasp, and using it is as simple as using a Web browser. This Java development 2.0 column introduces CouchDB and shows you how Groovy's RESTClient can help you tap into its strengths.
|
|
Articles |
|
17 Nov 2009 |
|
| |
The Support Authority: Know what your Web application is really doing
The IBM Monitoring and Diagnostic Tools for Java - Health Center is a
lightweight tool that monitors IBM virtual machines for Java with minimal
performance overhead. It provides live information and recommendations about
classes being loaded, the virtual machine environment, garbage collection,
locking, and profiling. This article introduces you to the Health Center and
shows an example of how it can be used to check the impact of a source code
change in a Web application.
|
|
Articles |
|
04 Nov 2009 |
|
| |
Use Sun SPOTs as your build canary
Find out how to turn a new, open source wireless device -- Sun's Small Programmable Object Technology (SPOT) -- into a highly visible indicator of the health of a Continuous Integration build. Craig Caulfield introduces you to Sun SPOTs and the SPOT SDK, then shows how to use SPOTs as an early-warning system for CruiseControl builds.
|
|
Articles |
|
03 Nov 2009 |
|
| |
Java Web services: Introducing Metro
The Metro Web service stack provides a comprehensive solution for accessing and implementing Web services. It's based on the reference implementations of the JAXB 2.x and JAX-WS 2.x Java standards, with added components to support WS-* SOAP extension technologies and actual Web service deployment. This article continues Dennis Sosnoski's Java Web services column series with a look at the basic principles of Metro client and server development.
|
|
Articles |
|
03 Nov 2009 |
|
| |
Patching in Eclipse Galileo
Eclipse Galileo includes new features for applying patches, including the ability
to copy a patch to the clipboard and paste it directly into the Project Explorer.
This article introduces this and provides an overview of the method for
creating and applying patches, and includes an overview of the patch format used by Eclipse.
|
|
Articles |
|
03 Nov 2009 |
|
| |
Introduction to the eSWT mobile extension, Part 2: Use advanced controls for your mobile applications
As mobile platforms become increasingly sophisticated, the demand for
mobile computing will increase. In this "Introduction to the eSWT mobile extension" series, learn about the embedded
Standard Widget Toolkit (eSWT). You can use eSWT to develop native-looking
Java applications for a variety of mobile phones. In this article, learn how to
use more of the mobile controls: MobileShell, SortedList, HyperLink,
TextExtension, and TaskTip.
|
|
Articles |
|
03 Nov 2009 |
|
| |
Java development 2.0: Easy EC2
Provisioning an EC2 instance for hosting a Java Web application is a snap. In this Java development 2.0 column, you'll quickly build a Web application that leverages Groovy, Spring, and Hibernate (via the Grails framework) and deploy it on an EC2 instance.
|
|
Articles |
|
27 Oct 2009 |
|
| |
Joda-Time
No enterprise application can escape time. Applications need to know
what time it is and what time it's going to be, and sometimes they must calculate the path
between the two. Using the JDK to do this job can be painful and tedious. Enter Joda-Time, an easy-to-use open source date/time library for the Java platform. As
you'll see in this article, Joda-Time eases the pain and tedium of manipulating
dates and time.
|
|
Articles |
|
27 Oct 2009 |
|
| |
Create and implement an XPCOM component for the Firefox browser
Learn how to create, develop, and test
a Cross-Platform Component Object Model (XPCOM) component that can be used by
the Firefox browser as an extension of an
application. Sample code provided with the example used in the article gives
you a quick start for developing your component for Firefox.
|
|
Articles |
|
27 Oct 2009 |
|
| |
Mastering Grails: Mock testing with Grails
In this Mastering Grails installment, Scott Davis shows you how to take advantage of the built-in mocking capabilities of the GrailsUnitTestCase and ControllerUnitTestCase classes included with Grails.
|
|
Articles |
|
20 Oct 2009 |
|
| |
GWT fu, Part 2: Beyond the basics
Google Web Toolkit (GWT) lets you implement desktop-like applications that run in a browser. In the second half of a two-part series, David Geary shows you how to use some of the more advanced aspects of GWT, including sinking events, using timers, and previewing events.
|
|
Articles |
|
20 Oct 2009 |
|
| |
The busy Java developer's guide to Scala: Updating Twitter, with Scitter
The Scitter client library is almost ready to be released into the
wild, but it needs a few finishing touches. In this installment of The
busy Java developer's guide to Scala, Ted Neward shows you how to incorporate update, show, and delete functionality into the Scala-based library for accessing Twitter.
|
|
Articles |
|
20 Oct 2009 |
|
| |
Meet the Object/XML mapping support in Spring
Within the Java Platform, Enterprise Edition (Java EE) community, Spring is becoming a widely accepted framework. One new feature in the latest release of Spring is its Object/XML (O/X) mapping support. The API enables developers to convert Java objects into XML and vice versa. In this article, learn to use the Object/XML mapping in Spring and explore its advantages.
|
|
Articles |
|
20 Oct 2009 |
|
| |
Writing great code with the IBM FileNet P8 APIs, Part 3: Take a number
Yes, you, too, can have an ECM-backed corner bakery with a tidy customer queue! Just have them take a number. This article discusses
implementation techniques for getting reliably unique sequence numbers from a FileNet P8 repository. Some of the obvious approaches have hidden dangers,
but a correct and useful approach is simple and performant. Along the way to solving this common problem, we'll see some things about
P8 development that have a much wider scope.
|
|
Articles |
|
15 Oct 2009 |
|
| |
Developing with real-time Java, Part 3: Write, validate, and analyze a real-time Java application
Building on the previous two articles in this three-part series and on the Real-time Java series, this article shows how to design, code, validate, and analyze a basic real-time application. The emphasis is on the practical aspects of validating the achievement of an application's deterministic quality of service.
|
|
Articles |
|
14 Oct 2009 |
|
| |
Java diagnostics, IBM style, Part 5: Optimizing your application with the Health Center
IBM Monitoring and Diagnostic Tools for Java - Health Center is a tool for monitoring a running Java application. It reports on all aspects of system health via charts, graphs, and tables, and it makes recommendations for fixing problems. The Health Center includes an extremely low-overhead method profiler, a garbage-collection visualizer, a locking profiler to identify contention bottlenecks, and a configuration explorer. Find out how you can use this tool to diagnose and fix performance, configuration, and stability issues in your applications.
|
|
Articles |
|
07 Oct 2009 |
|
| |
memcached and Grails, Part 2: Integrating memcached into Grails
James Goodwill completes his two-part introduction to integrating
memcached and Grails with a sample Grails application and a Java-based memcached
client. Learn how to integrate Spymemcached into your Grails-built, contact-management
application, then try caching individual request results with memcached. You'll also
use the memcached client commands introduced in Part 1 to test the effectiveness of your new cache.
|
|
Articles |
|
06 Oct 2009 |
|
| |
Comment lines by Scott Johnson: Loading Java resource bundles via HTTP
Learn how to load a Java resource bundle that resides in a different Web
application. Before Java Platform Standard Edition (Java SE) 6, support for
accomplishing this was not part of the JDK. But with the addition of the
ResourceBundle.Control class in Java SE 6, loading a "remote" resource bundle became possible by simply extending the Control class and adding some custom code.
|
|
Articles |
|
30 Sep 2009 |
|
| |
Comment lines by Kevin Sutter: An update on Java Persistence API 2.0
As the JPA Expert Group (JSR-317) nears completion of the JPA 2.0
specification, this article introduces you to some of the new concepts and features in this updated specification. It also explains how you can experience this new functionality with the Apache OpenJPA project, an open-source, robust, high performance, scalable implementation of the JPA specification.
|
|
Articles |
|
30 Sep 2009 |
|
| |
The Support Authority: Analyze memory management problems with the Memory Dump Diagnostic for Java
(MDD4J)
The Memory Dump Diagnostic for Java (MDD4J) tool helps you diagnose
memory leaks and other excessive memory consumption problems in applications
running in IBM Java Virtual Machines (JVMs). This article introduces you to
MDD4J and shows you how to use its sophisticated analysis engine and user
interface to peer into the Java heap so you can see which objects are
consuming the most amount of memory.
|
|
Articles |
|
30 Sep 2009 |
|
| |
Java development 2.0: You can borrow EC2 too
In this Java development 2.0 installment, Andrew Glover give you a hands-on introduction to developing for and deploying on the Amazon Elastic Compute Cloud (EC2). Learn how EC2 differs from Google App Engine, and leverage an Eclipse plug-in and the concise Groovy language to get a simple Web application up and running quickly on EC2.
|
|
Articles |
|
29 Sep 2009 |
|
| |
Practically Groovy: SwingBuilder and the Twitter API, Part 1
In this Practically Groovy article, Scott Davis tackles a topic that strikes fear into most server-side Java developers: Swing. As you'll learn, Groovy's SwingBuilder takes some of the sting out of this powerful yet complex GUI framework.
|
|
Articles |
|
29 Sep 2009 |
|
| |
developerWorks Java technology: 10 years and counting
Since taking the reins of the Java technology zone, Jenni Aloi has published nearly
1000 pieces of content and collaborated with writers from (seemingly) every specialty
in Java development. As developerWorks celebrates its 10th anniversary, she thought
it would be nice to give props to those writers who've made the zone a success.
|
|
Articles |
|
28 Sep 2009 |
|
| |
Dynamic, typesafe queries in JPA 2.0
A query for persistent Java objects is typesafe if a compiler can verify it for syntactic correctness. Version 2.0 of the Java Persistence API (JPA) introduces the Criteria API, which brings the power of typesafe queries to Java applications for the first time and provides a mechanism for constructing queries dynamically at run time. This article describes how to write dynamic, typesafe queries using the Criteria API and the closely associated Metamodel API.
|
|
Articles |
|
22 Sep 2009 |
|
| |
Create stand-alone Web services applications with Eclipse and Java SE 6: Part 2: The Web service client application
Use the Eclipse Integrated Development Environment (IDE) and Java Platform, Standard Edition (Java SE) 6 to
create a stand-alone Web services application that can be run from the console. In this tutorial, the second in the
series, continue getting familiar with the Eclipse IDE and its built-in feature the TCP/IP Monitor. View the
network traffic between server and client applications and then run the applications from the command line.
|
|
Tutorial |
|
18 Sep 2009 |
|
| |
Introduction to the eSWT mobile extension, Part 1: Use simple widgets to quickly build mobile applications
As mobile platforms become increasingly sophisticated, the demand for
mobile computing will increase. In this series, learn about the embedded Standard Widget Toolkit
(eSWT). You can use eSWT to develop native-looking Java applications for a
variety of mobile phones. This article explores how to use eSWT mobile controls.
Code examples walk you through using five of the classes in the eSWT mobile
extension.
|
|
Articles |
|
15 Sep 2009 |
|
| |
memcached and Grails, Part 1: Installing and using memcached
In this first half of a two-part article focusing on memcached and Grails,
author James Goodwill introduces you to the open source caching solution memcached.
Topics covered in this article include installation, configuration, memcached client
commands, and evaluating the effectiveness of your cache. Unlike articles about using
memcached with a language-specific client, this one focuses on direct interaction with
the memcached server. The goal is to give you the tools you need to monitor your
instance of memcached as well as to prepare you for the second half of the article, in which you will integrate memcached into a Grails application.
|
|
Articles |
|
15 Sep 2009 |
|
| |
Java Web services: JAXB and JAX-WS in Axis2
Apache Axis2 supports a range of data-binding technologies, including the official Java standard, JAXB 2.x. Axis2 also supports the Java standard for Web service configuration, JAX-WS 2.x, as an alternative to its own custom configuration technique. Dennis Sosnoski continues his Java Web services column series by demonstrating how you can use each of these Java standards with Axis2 and discussing some of the limitations of Axis2's current support for them.
|
|
Articles |
|
15 Sep 2009 |
|
| |
Mastering Grails: Creating a custom plug-in
In this Mastering Grails installment, Scott Davis shows you how to create your own Grails plug-in. Once you see how effortless it is to create a plug-in, you'll understand why more than 250 Grails plug-ins are available now, with new ones being added all the time.
|
|
Articles |
|
15 Sep 2009 |
|
| |
Introducing Apache Mahout
Once the exclusive domain of academics and corporations with large research budgets, intelligent applications that learn from data and user input are becoming more common. The need for machine-learning techniques like clustering, collaborative filtering, and categorization has never been greater, be it for finding commonalities among large groups of people or automatically tagging large volumes of Web content. The Apache Mahout project aims to make building intelligent applications easier and faster. Mahout co-founder Grant Ingersoll introduces the basic concepts of machine learning and then demonstrates how to use Mahout to cluster documents, make recommendations, and organize content.
|
|
Articles |
|
08 Sep 2009 |
|
| |
Developing with real-time Java, Part 2: Improve service quality
Some Java applications fail to provide reasonable quality of
service despite achieving other performance goals, such as average latency or overall
throughput. By introducing pauses or interruptions that aren't under the application's
control, the Java language and runtime system can sometimes be responsible for an
application's inability to meet service-performance metrics. This article, second in a
three-part
series, explains the root causes of delays and interruptions in a JVM and describes techniques you can use to mitigate them so that your applications deliver more consistent service quality.
|
|
Articles |
|
08 Sep 2009 |
|
| |
ICEfaces and Google Translate
Globalization has had an enormous impact on our lives and cultures. As a
result, translation is becoming an increasingly important tool to enhance
understanding between cultures. Organizations try to use Web technologies with
different languages, scripts, and cultures, and developers search for new
technologies that will help them create efficient applications as quickly as
possible. Fortunately, JavaServer Faces (JSF) simplifies life for application developers, making it
possible for them to focus on the view without needing to know the underlying
markup or scripts. ICEfaces, an integrated Asynchronous JavaScript and XML (Ajax)
application framework, enables Java Platform, Enterprise Edition (Java EE) application developers to easily create and deploy thin-client,
rich Internet applications in pure Java code. This tutorial describes how to develop Web applications using
JSF with the translation option.
|
|
Tutorial |
|
08 Sep 2009 |
|
| |
Creating a declarative XML UI language
Writing GUIs in program code can often lead to messy design choices, which
in turn results in a blurring between business logic and UI code. Discover how to create a
declarative XML UI tag set with an accompanying Java(TM) framework that parses, validates,
constructs, and finally binds the declared GUI components to business logic at runtime.
|
|
Articles |
|
01 Sep 2009 |
|
| |
Developing with real-time Java, Part 1: Exploit real-time Java's unique features
Real-time Java combines ease of programming in the Java language with the performance required by applications that must conform to real-time constraints. Extensions to the Java language provide features for real-time environments that are lacking in the traditional Java runtime environment. This article, the first in a three-part series, describes some of these features and explains how you can apply them to enable real-time performance in your own applications.
|
|
Articles |
|
01 Sep 2009 |
|
| |
Evolutionary architecture and emergent design: Language, expressiveness, and design, Part 2
The ability to see and harvest idiomatic patterns is critical for emergent design. Also vitally important to design is code's expressiveness.
In Part 2 of this two-part article, Neal Ford continues discussing the intersection of
expressiveness and patterns, demonstrating these concepts with both idiomatic patterns and
formal design patterns. He recasts more of the classic Gang of Four patterns in dynamic
languages for the JVM to show how more-expressive languages enable you to see design elements obscured by more-opaque languages.
|
|
Articles |
|
01 Sep 2009 |
|
| |
GWT fu, Part 1: Going places with Google Web Toolkit
Google Web Toolkit (GWT) lets you use the Java language to implement rich client user interfaces that run in a browser. In this two-part article, David Geary brings you up to speed on the latest version of GWT and shows you how to implement a desktop-like Web application.
|
|
Articles |
|
01 Sep 2009 |
|
| |
GMaps4JSF in the JSF 2.0 Ajax world
GMaps4JSF, a JavaServer Faces (JSF) mashup library, integrates Google Maps
with JSF. Using GMaps4JSF, you can construct complex street view panoramas and
maps with just a few
JSF tags. You can also easily attach different components to the map. This
article explains how to configure GMaps4JSF inside JSF 2.0
applications, and includes a brief introduction to JSF 2.0 Ajax. Using the
article, learn how you can create a simple
mashup application that uses both GMaps4JSF and JSF 2.0 Asynchronous
JavaScript and XML (Ajax).
|
|
Articles |
|
25 Aug 2009 |
|
| |
Practically Groovy: The @Delegate annotation
Scott Davis continues the discussion about Groovy metaprogramming with an in-depth look at
the @Delegate annotation, which blurs the distinctions between
data type and behavior and static and dynamic typing.
|
|
Articles |
|
25 Aug 2009 |
|
| |
Google App Engine for Java: Part 3: Persistence and relationships
Data persistence is a cornerstone of scalable application delivery in
enterprise environments. In this final article of his series introducing Google App
Engine for Java, Rick Hightower takes on the challenges of App Engine's current
Java-based persistence framework. Learn the nuts and bolts of why Java persistence in
the current preview release isn't quite ready for prime time, while also getting a
working demonstration of what you can do to persist data in App Engine for Java
applications. Note that you will need to have the contact-management application from
Part 2 up and running as you learn how to use the JDO API to persist, query, update, and delete Contact objects.
|
|
Articles |
|
25 Aug 2009 |
|
| |
Implementing composite keys with JPA and Hibernate
Nowadays, with the widespread use and deployment of Object-Relational Mapping (ORM) tools, you don't generally have to think too hard about such arcane issues as composite keys. Normally, the choice of key design can be a simple integer, and this can be left with confidence to the tooling. Occasionally, you come across a situation where a composite key is required, and you need a strategy for this. This tip shows you how to implement composite keys with JPA and Hibernate.
|
|
Articles |
|
25 Aug 2009 |
|
| |
Using Apache Lucene to search text
In this article, learn about Apache Lucene, the high-performance, full-featured
text search-engine library. Explore the Lucene
architecture and its core APIs. Learn to use Lucene for cross-platform full-text searching, indexing, displaying results, and extending a search.
|
|
Articles |
|
18 Aug 2009 |
|
| |
Java development 2.0: Hello Google App Engine
Open source solutions and borrowed infrastructures are changing the character of Java development, letting you deliver better software quickly and at a low cost. Andrew Glover, coining the term Java development 2.0 to encapsulate the cumulative force of these phenomena, launches a new series on some of the relevant tools and technologies. This first installment heralds the arrival of Java development 2.0 and explains how you can bring its concepts to fruition quickly with Google's App Engine for Java.
|
|
Articles |
|
18 Aug 2009 |
|
| |
Google App Engine for Java: Part 1: Rev it up!
Remember when Google App Engine was just for Pythonistas? Those
were some dark days. Google Inc. opened up its cloud-computing platform to
Java developers in April 2009. In this three-part article series, Java technology author and
trainer Rick Hightower gets you started with this reliable, robust, and fun platform
for Java-based development. In this article, you'll get an overview of why Google App
Engine for Java could
be the deployment platform for your next highly scalable killer app, then start using
the Google Plugin for Eclipse to build two example apps: one based on Google Web Toolkit (GWT) and one based on the Java Servlet API. You'll learn for yourself what a difference Google App
Engine for Java makes, both in building out an application from scratch and in deploying it to the tune of up to five million views. (And that's just the free version.)
|
|
Articles |
|
11 Aug 2009 |
|
| |
Google App Engine for Java: Part 2: Building the killer app
The whole point of a cloud platform like Google App Engine for Java is
in being able to imagine, build, and deploy professional-quality killer apps that
scale -- without breaking the bank or driving yourself insane. In this second part of
his three-part introduction to Google App Engine for Java, Rick Hightower takes you
beyond the ready-made examples of Part 1 with a step-by-step guide to writing and
deploying a simple contact-management application using Google App Engine for Java.
|
|
Articles |
|
11 Aug 2009 |
|
| |
Java Web services: Granular use of WS-Security
WS-Security for SOAP Web services doesn't have to be an all-or-nothing proposition. By configuring WS-Security at the operation or message level, you can apply an appropriate degree of protection to every exchange, reducing or eliminating the WS-Security overhead for operations that don't need full protection. Dennis Sosnoski continues his Java Web services series with a look at granular WS-Security in Web Services Description Language (WSDL) using Apache Axis2 and Rampart.
|
|
Articles |
|
04 Aug 2009 |
|
| |
Evolutionary architecture and emergent design: Language, expressiveness, and design, Part 1
The ability to see and harvest idiomatic patterns is critical for emergent design. Also vitally important to design is code's expressiveness.
In a two-part article, Neal Ford discusses the intersection of expressiveness and patterns, demonstrating these concepts with both idiomatic patterns and formal design patterns. He recasts some of the classic Gang of Four patterns in dynamic languages for the JVM to show how more expressive languages enable you to see design elements obscured by more opaque languages.
|
|
Articles |
|
28 Jul 2009 |
|
| |
Transaction strategies: The High Performance strategy
In this final installment, Transaction strategies series author Mark Richards describes how to implement a transaction strategy in the Java platform for high-performance applications. Your application can maintain fast processing times while still supporting some degree of data integrity and consistency -- but you need to be aware of the trade-offs involved.
|
|
Articles |
|
22 Jul 2009 |
|
| |
Tip: Migrating from JBoss 4 to JBoss 5
Trying to migrate your EJB code to JBoss 5? Can't get the code to deploy and run? If so, this tip is for you. Or, are you new to JBoss 5 but you want to get a feel for the EJB 3 environment? This tip details the required XML deployment files to build, deploy, and run EJB3 code on JBoss5.
|
|
Articles |
|
21 Jul 2009 |
|
| |
Mastering Grails: Understanding plug-ins
In this Mastering Grails installment, Scott Davis introduces you to the world of Grails plug-ins. Adding whole areas of new functionality to your applications couldn't be easier. You'll learn how plug-ins do their magic, and you'll use a plug-in to implement powerful search capabilities in the Blogito application.
|
|
Articles |
|
21 Jul 2009 |
|
| |
JSF 2 fu, Part 3: Event handling, JavaScript, and Ajax
JavaServer Faces (JSF) 2 Expert Group member David Geary wraps up his three-part series on JSF 2's new features. Find out how to use the framework's new event model and built-in support for Ajax to make your reusable components all the more powerful.
|
|
Articles |
|
14 Jul 2009 |
|
| |
Globalize your Eclipse RCP application
The Eclipse Rich Client Platform (RCP) is gaining wide acceptance in software
development. For multinational enterprises, delivering software that supports
multiple languages is increasingly important to worldwide customers. In this
article, learn how to globalize the user interface (UI) elements in
an RCP application, including the window, menu, toolbar, dialog, welcome page, splash
screen, and standard Eclipse UI elements. A sample Hello World application walks you through the
process.
|
|
Articles |
|
07 Jul 2009 |
|
| |
Best practices for using the Java Native Interface
The Java Native Interface (JNI) is a standard Java API that enables Java code to integrate with code written in other programming languages. JNI can be a key element in your toolkit if you want to leverage existing code assets -- for example, in a service-oriented architecture (SOA) or a cloud-based system. But when used without due care, JNI can quickly lead to poorly performing and unstable applications. This article identifies the top 10 JNI programming pitfalls, provides best practices for avoiding them, and introduces the tools available for implementing these practices.
|
|
Articles |
|
07 Jul 2009 |
|
| |
Java Web services: The high cost of (WS-)Security
WS-Security offers powerful features for securing Web service
applications, and for many applications these features are essential. But these
features come at a high cost in terms of performance and message overhead. Dennis
Sosnoski continues his Java Web services column series with a look at how using WS-Security or WS-SecureConversation affects Axis2 performance, and he discusses when the simpler (and better performing) alternative of HTTPS-secured connections is a more appropriate choice.
|
|
Articles |
|
07 Jul 2009 |
|
| |
Evolutionary architecture and emergent design: Emergent design through metrics
Software metrics can help you find hidden design elements in your code, enabling them to
emerge as idiomatic patterns. This installment of Evolutionary architecture and emergent design shows how intelligent use of metrics and visualizations lets you discover important code elements that are obscured by accidental complexity.
|
|
Articles |
|
30 Jun 2009 |
|
| |
Basics steps: Converting an IBM Lotus Notes application to use Lotus Notes 8 Java components
Java™ views were introduced in the IBM® Lotus® Notes® client in release 8.0. Many new features were implemented using the Java views to modernize the Lotus Notes interface. This article outlines the steps that IBM Lotus Domino developers would take to convert their own Lotus Domino® (simple) applications into Java views. This document presumes that you have an installed version of Lotus Notes 8.5, IBM Lotus Domino Designer 8.5, and Lotus Notes composite application editor 8.5 and that you are familiar with working in Lotus Domino Designer.
|
|
Articles |
|
29 Jun 2009 |
|
| |
Advanced Java view features in IBM Lotus Notes 8.5
Java™ views were introduced in the IBM® Lotus® Notes® client in release 8.0. Many new features were implemented through the Java views to modernize the Lotus Notes interface. After you have converted your application to use the Java view, you can follow the steps outlined in this article to take advantage of the new view features offered, such as threads, narrow mode, business cards, split action buttons, and custom context menus. This article presumes that you have an installed version of Lotus Notes 8.5, IBM Lotus Domino Designer 8.5, and the Lotus Notes 8.5 composite application editor. You should also be familiar with working in Lotus Domino® Designer.
|
|
Articles |
|
29 Jun 2009 |
|
| |
Get started with DB2 Performance Expert Extended Insight
Feature
IBM DB2 Performance Expert Extended Insight Feature extends the
capabilities provided in DB2 Performance Expert by providing end-to-end
database monitoring for Java technology applications, with even more
capabilities for those running in IBM WebSphere Application Server. This
feature gives you the capability to address performance issues, regardless of
where they occur in the software stack. This tutorial will help you get started with DB2 Performance Expert
Extended Insight Feature. Learn how to install, configure, and
validate DB2 Performance Expert Extended Insight Feature.
|
|
Tutorial |
|
25 Jun 2009 |
|
| |
Practically Groovy: Metaprogramming with closures, ExpandoMetaClass, and categories
Enter into the world of metaprogramming, Groovy-style. The ability to add new
methods to classes dynamically at run time -- even Java classes, and even final Java
classes -- is incredibly powerful. Whether used for production code, unit tests, or anything in between, Groovy's metaprogramming capabilities should pique the curiosity of even the most jaded Java developer.
|
|
Articles |
|
23 Jun 2009 |
|
| |
Java Web services: Axis2 WS-Security signing and encryption
Get an introduction to the principles of public key cryptography, then see how WS-Security applies them for signing and encrypting SOAP messages using public-private key pairs in combination with secret keys. Dennis Sosnoski continues his Java Web services series with a discussion of WS-Security and WS-SecurityPolicy signing and encryption features, along with example code using Axis2 and Rampart.
|
|
Articles |
|
16 Jun 2009 |
|
| |
Transaction strategies: The High Concurrency strategy
Transaction strategies series author Mark Richards describes how to implement a transaction strategy in the Java platform for applications with high-throughput and high-user-concurrency requirements. An understanding of the trade-offs involved will help you ensure a high level of data integrity and consistency -- and spare you painful refactoring work late in the development process.
|
|
Articles |
|
16 Jun 2009 |
|
| |
Mastering Grails: File uploads and Atom syndication
In this Mastering Grails installment, Scott Davis shows you how to upload files to your Grails application and set up an Atom syndication feed. With these last pieces in place, Blogito becomes a full-fledged blog server.
|
|
Articles |
|
09 Jun 2009 |
|
| |
The busy Java developer's guide to Scala: Enhancing the Scitter library
Scala is fun to talk about in the abstract, but using it in a practical
way makes the difference between seeing it as a "toy" and using it on the job. In this
follow-up article to his introduction to Scitter, a Scala client library for accessing Twitter, Scala enthusiast Ted Neward offers a more interesting and useful set of features for the client library.
|
|
Articles |
|
02 Jun 2009 |
|
| |
JavaScript EE, Part 3: Use Java scripting API with JSP
In the previous two parts of this series, you've seen how to run JavaScript
files on the server and how to call remote JavaScript functions with Ajax. This
article explains how to use server-side JavaScript code with the JavaServer Pages
(JSP) technology and how to build Asynchronous JavaScript and XML (Ajax) user
interfaces that remain functional when JavaScript is disabled in the Web browser.
The sample code consists of a small JSP tag library that you can reuse in your own
applications as well as a dynamic Web form, which is generated with a piece of JavaScript code that can be executed on the Web server or in the Web browser.
|
|
Articles |
|
02 Jun 2009 |
|
| |
JSF 2 fu, Part 2: Templating and composite components
JavaServer Faces (JSF) 2 lets you implement user interfaces that are easy to
modify and extend with two powerful features: templating and composite components. In
this article -- second in a three-part series on JSF 2's new features -- JSF 2 Expert
Group member David Geary shows you how your Web applications can best take advantage of templating and composite components.
|
|
Articles |
|
02 Jun 2009 |
|
| |
Java Web services: Axis2 WS-Security basics
Learn how to add the Rampart security module to Apache Axis2 and start using WS-Security features in your Web services. Dennis Sosnoski resumes his Java Web services series with a look at WS-Security and WS-SecurityPolicy use in Axis2, starting with UsernameToken as a simple first step. The next few columns will take you further with WS-Security and WS-SecurityPolicy, as implemented by Axis2 and Rampart.
|
|
Articles |
|
26 May 2009 |
|
| |
Evolutionary architecture and emergent design: Refactoring toward design
Earlier installments in this series discuss how unit testing leads you to a better design. But if you already have lots of code, how do you discover design elements lurking within it? The preceding installment talked about building structural targets for your code. In this article, series author Neal Ford expands on those ideas and covers techniques that use refactoring to allow emergent design.
|
|
Articles |
|
26 May 2009 |
|
| |
Using the Java language NamespaceContext object with XPath
If you want to use namespaces in XPath expressions, you have to
provide the link of the used prefix to the URI of the namespace.
This article describes three variants of providing the prefix to
namespace mapping. It contains example code to make it easy
to code your own NamespaceContext.
|
|
Articles |
|
19 May 2009 |
|
| |
Practically Groovy: Building, parsing, and slurping XML
Learn how easy it is to slice and dice XML using Groovy. In this installment of Practically
Groovy, author Scott Davis shows that whether you're creating XML with MarkupBuilder and StreamingMarkupBuilder, or parsing XML with XmlParser and XmlSlurper, Groovy offers a set of compelling tools for dealing with this ubiquitous data format.
|
|
Articles |
|
19 May 2009 |
|
| |
Transaction strategies: The Client Orchestration strategy
Sometimes an application's presentation layer must handle the coordination of multiple API layer method calls to complete a single transactional unit of work. In this article, Transaction strategies series author Mark Richards describes the Client Orchestration transaction strategy and explains how to implement it in the Java platform.
|
|
Articles |
|
19 May 2009 |
|
| |
JSF 2 fu, Part 1: Streamline Web application development
With version 2.0, JavaServer Faces (JSF) makes it easy to implement robust, Ajaxified Web applications. This article launches a three-part series by JSF 2.0 Expert Group member David Geary showing you how to take advantage of the new features in JSF 2. In this installment, you'll learn how to streamline development with JSF 2 by replacing XML configuration with annotations and convention, simplifying navigation, and easily accessing resources. And you'll see how to use Groovy in your JSF applications.
|
|
Articles |
|
12 May 2009 |
|
| |
Java postmortem diagnostics, Part 1: Introduction to JSR 326 and Apache Kato
The artifacts produced when your Java application fails can
help you analyse the root causes of the failure. A standard API to facilitate
postmortem analysis is being developed by the Java Community process, and the Apache Kato project is under way to produce a reference implementation and tools for this API. This article, the first in a two-part series, introduces the Post mortem JVM Diagnostics API (JSR 326) and summarises the ways Kato will help you make good use of it. Part 2 will explore postmortem-diagnosis scenarios in greater depth.
|
|
Articles |
|
05 May 2009 |
|
| |
The busy Java developer's guide to Scala: Scala + Twitter = Scitter
Scala is fun to talk about in the abstract, but for most of the readers of this
column, using it in a practical way makes the difference between seeing it as a "toy"
and using it on the job. In this installment, Ted Neward uses Scala to build the basic
framework for a client library for accessing Twitter, a popular micro-blogging system.
|
|
Articles |
|
05 May 2009 |
|
| |
Developing widgets with Dojo 1.x
Learn the basics of developing HTML widgets using the Dojo JavaScript
toolkit. This article gives you an introduction, and provides several examples
to help you in the process--starting with sample
widgets and moving up to more complex widgets, while highlighting and solving the common
issues you could encounter in the development phase.
|
|
Articles |
|
28 Apr 2009 |
|
| |
Easier testing with EasyMock
Join Elliotte Rusty Harold for a look at some hard unit tests made easy through
mock objects -- more specifically, the EasyMock framework. This open source library saves you time and helps make your mock-object code concise and legible.
|
|
Articles |
|
28 Apr 2009 |
|
| |
Mastering Grails: Authentication and authorization
Grails provides all the basic building blocks you need to put together a secure Web application, ranging from a simple login infrastructure to role-based
authorization, and in this installment of Mastering
Grails, Scott Davis gives you a hands-on lesson in securing your Grails application. You'll also learn about some plug-ins that can help you extend your applications' security capabilities in new directions.
|
|
Articles |
|
28 Apr 2009 |
|
| |
Mike Brickley on Brickley Engine and super-efficient internal combustion
An independent inventor in Austin, Texas, innovator Mike Brickley talks about his quest to make the internal combustion engine far more efficient, his hopes to ease the transition to next-gen engines, and his thoughts on inventing in general and on the urgency of instilling a forward-thinking pattern so humans can continue to co-exist comfortably with the ecosystem. He's had a lifelong interest in engines and inventing and has designed and built a number of steam engines, internal combustion engines, and Stirling engines.
|
|
Articles |
|
22 Apr 2009 |
|
| |
Thanks for the memory
Running out of Java heap isn't the only cause of a java.lang.OutOfMemoryError. If native memory runs out, OutOfMemoryErrors that your normal debugging techniques won't be able
to solve can occur. This article explains what native memory is, how the Java runtime
uses it, what running out of it looks like, and how to debug a native OutOfMemoryError
on AIX. A companion article covers the same topics for Linux and Windows systems.
|
|
Articles |
|
21 Apr 2009 |
|
| |
Thanks for the memory
Running out of Java heap isn't the only cause of a java.lang.OutOfMemoryError. If native memory runs out, OutOfMemoryErrors that your normal debugging techniques won't be able to solve can occur. This article explains what native memory is, how the Java runtime uses it, what running out of it looks like, and how to debug a native OutOfMemoryError on Windows and Linux. A companion article covers the same topics for AIX systems.
|
|
Articles |
|
21 Apr 2009 |
|
| |
Evolutionary architecture and emergent design: Composed method and SLAP
How do you find hidden design in aging code bases? This article discusses two important patterns for code structure: composed method and single level of abstraction. Applying these principles to your code allows you to find reusable assets that remained hidden before, with the further benefit of letting you abstract existing code into harvested frameworks.
|
|
Articles |
|
21 Apr 2009 |
|
| |
IBM
|
|
Articles |
|
20 Apr 2009 |
|
| |
Transaction strategies: The API Layer strategy
An effective and robust transaction strategy is critical for
maintaining data consistency and integrity. The API Layer transaction strategy is
easy to implement and is well-suited for most business applications. Using examples
from the Enterprise JavaBeans (EJB) 3.0 specification, Transaction
strategies series author Mark Richards explains what this transaction strategy is
and how to implement it in the Java platform.
|
|
Articles |
|
14 Apr 2009 |
|
| |
Practically Groovy: Reaching for each
In this Practically Groovy installment, Scott Davis provides a dizzying array of ways to iterate through ... arrays. And lists. And files. And URLs. And on and on and on. The most impressive part is that Groovy provides a consistent mechanism for walking through all of those collections and more.
|
|
Articles |
|
14 Apr 2009 |
|
| |
The busy Java developer's guide to Scala: Dive deeper into Scala concurrency
Concurrency quickly became the sizzling topic on the minds of every
software developer after major chip manufacturers started to release chips that
weren't necessarily faster but were running two or more cores in parallel. In this
follow-up to his introduction to
Scala concurrency, Ted Neward takes a deeper look at this hot-topic with an examination
of actors, those executing entities that pass messages among themselves to coordinate work.
|
|
Articles |
|
10 Apr 2009 |
|
| |
XML: The bridge between GWT and PHP
Google Web Toolkit (GWT) applications, apart from connecting to servlets in time-honored Java fashion, can also use PHP Web services to send and receive data
in XML. You'll explore methods to generate XML documents and process them, both in the Java language and in PHP.
|
|
Articles |
|
07 Apr 2009 |
|
| |
Evolutionary architecture and emergent design: Test-driven design, Part 2
Testing is only a side effect of test-driven development (TDD); when done right, TDD improves the overall design of your code. This Evolutionary architecture and emergent design installment completes a walk-through of an extended example showing how design can emerge from the concerns that float up from testing.
|
|
Articles |
|
07 Apr 2009 |
|
| |
Storage made easy with S3
Amazon Simple Storage Service (S3) is a publicly available service that Web application developers can use for storing digital assets such as images, video, music, and documents. S3 provides a RESTful API for interacting with the service programmatically. Learn how to use the open source JetS3t library to leverage Amazon's S3 cloud service for storing and retrieving data.
|
|
Articles |
|
07 Apr 2009 |
|
| |
JavaScript EE, Part 2: Call remote JavaScript functions with Ajax
In Part 1 of this series, you learned how to use the javax.script API in
Asynchronous JavaScript and XML (Ajax) and Java Platform, Enterprise Edition (Java EE) applications and how to build a Java servlet that lets you run server-side JavaScript files. This article shows how to implement a Remote Procedure Call (RPC) mechanism for Web applications that use JavaScript on both servers and clients. You'll also learn several interesting techniques, such as implementing Java interfaces with JavaScript, building an XMLHttpRequest wrapper, making Ajax debugging easier, and using JSP tag files to generate JavaScript code.
|
|
Articles |
|
31 Mar 2009 |
|
| |
Mastering Grails: Rewiring Grails with custom URIs and codecs
In this installment of Mastering
Grails, Scott Davis shows you how to customize the standard Uniform
Resource Identifier (URI) that Grails generates for Web pages. Moving from primary
keys to descriptive titles in URIs gives users a more memorable and more meaningful
path to the resources that they seek.
|
|
Articles |
|
10 Mar 2009 |
|
| |
Use XQuery for the presentation layer
Many Web applications use the Model-View-Controller (MVC) pattern to separate the three concerns. Using XQuery for presentation enables view-side developers to create robust presentation effects without tying the view to any particular underlying application server or programming language. This article explains in detail the advantages of using XQuery over other view technologies, how XQuery is implemented in the presentation layer,
and a realistic example of such an implementation.
|
|
Articles |
|
10 Mar 2009 |
|
| |
JiBX 1.2, Part 1: Java code to XML schema
XML schema definitions are the basis for many types of data exchanges, including most forms of Web services. But XML Schema is a complex standard, and most tools for creating and modifying schema definitions are not as powerful or easy to use as those for working with Java code. The new features of JiBX 1.2 let you start from Java code and easily generate quality schema definitions to match your data structures. You can then use the schemas directly, whether you use JiBX data binding or not.
|
|
Tutorial |
|
03 Mar 2009 |
|
| |
JiBX 1.2, Part 1: Java code to XML schema
XML schema definitions are the basis for many types of data exchanges, including most forms of Web services. But XML Schema is a complex standard, and most tools for creating and modifying schema definitions are not as powerful or easy to use as those for working with Java code. The new features of JiBX 1.2 let you start from Java code and easily generate quality schema definitions to match your data structures. You can then use the schemas directly, whether you use JiBX data binding or not.
|
|
Tutorial |
|
03 Mar 2009 |
|
| |
JiBX 1.2, Part 2: XML schema to Java code
Code generation from XML schema definitions is widely used for all types of XML data exchange, including Web services. Most data-binding tools rigidly structure generated code based on the schema, even aspects of the schema that may be irrelevant to your application. JiBX 1.2 generates cleaner code by doing a better job of interpreting the schema and eliminating unnecessary class clutter. It also provides extensive customizations for the generated code, including customizations for easily eliminating unnecessary components of the schema.
|
|
Tutorial |
|
03 Mar 2009 |
|
| |
Transaction strategies: Models and strategies overview
It's a common mistake to confuse transaction models with transaction strategies. This second article in the Transaction strategies series outlines the three transaction models supported by the Java platform and introduces four primary transaction strategies that use those models. Using examples from the Spring Framework and the Enterprise JavaBeans (EJB) 3.0 specification, Mark Richards explains how the transaction models work and how they can form the basis for developing transaction strategies ranging from basic transaction processing to high-speed transaction-processing systems.
|
|
Articles |
|
03 Mar 2009 |
|
| |
Building an AIM-enabled application in Eclipse
Today's applications take advantage of an interface that many people are already using: instant messaging (IM). Applications offer integration with IM because it offers easy access through an interface that people are familiar with and many people already have up and running. IM applications are also available on many mobile platforms, giving your users the ability to interface with your application from mobile devices.
|
|
Articles |
|
24 Feb 2009 |
|
| |
Evolutionary architecture and emergent design: Test-driven design, Part 1
Most developers think that the most beneficial part of using test-driven development (TDD) are the tests. But, when done right, TDD improves the overall design of your code. This installment in the Evolutionary architecture and emergent design series walks through an extended example showing how design can emerge from the concerns that float up from testing. Testing is only a side effect of TDD; the important part is how it changes your code for the better.
|
|
Articles |
|
24 Feb 2009 |
|
| |
Evolutionary architecture and emergent design: Investigating architecture and design
Software architecture and design generate a lot of conversational heat
but not much light. To start a new conversation about alternative ways to think about
them, this article launches the Evolutionary
architecture and emergent design series. Evolutionary architecture and emergent design are agile techniques for deferring important decisions until the last responsible moment. In this introductory installment, series author Neal Ford defines architecture and design and then identifies overarching concerns that will arise throughout the series.
|
|
Articles |
|
24 Feb 2009 |
|
| |
Social mashups with Groovy
Build a Groovy mashup that lets users view a map of their Twitter friends with Twitter4J, Google Maps, and a bit of Ajax.
|
|
Articles |
|
24 Feb 2009 |
|
| |
Scott Davis on rebooting the Practically Groovy series
Scott Davis, author, speaker, software developer, founder of ThirstyHead.com, a Groovy and Grails training company, gets excited about rebooting the "Practically Groovy" series on developerWorks. His article "Groovy: A DSL for Java Programmers" is highlighted this week.
|
|
Articles |
|
18 Feb 2009 |
|
| |
Scott Davis on rebooting the Practically Groovy series
Scott Davis, author, speaker, software developer, founder of ThirstyHead.com, a Groovy and Grails training company, joins to talk about rebooting the Practically Groovy series on developerWorks. His Groovy: A DSL for Java Programmers is highlighted this week.
|
|
Articles |
|
18 Feb 2009 |
|
| |
Practically Groovy: Groovy: A DSL for Java programmers
Groovy expert Scott Davis reboots the Practically Groovy series, dormant since 2006. This initial installment catches you up on Groovy's recent history and the current state of the Groovy union. Then you'll learn how easy it is to get started with Groovy, circa 2009.
|
|
Articles |
|
17 Feb 2009 |
|
| |
Automation for the people: Deployment-automation patterns, Part 2
Java deployments are often messy, error-prone, and manual, leading to delays in making software available to users. In Part 2 of this two-part article, automation expert Paul Duvall expands on a collection of key patterns for developing a reliable, repeatable, and consistent deployment process capable of generating one-click deployments for Java applications.
|
|
Articles |
|
10 Feb 2009 |
|
| |
The busy Java developer's guide to Scala: Explore Scala concurrency
The "gateway drug" to Scala for many, if not most, Java
programmers is the promise of easier coding when dealing with concurrency
and writing thread-safe code. In this installment, Ted Neward begins to dive
into the various concurrency features and libraries provided by the Scala
language and environment.
|
|
Articles |
|
04 Feb 2009 |
|
| |
Transaction strategies: Understanding transaction pitfalls
Transaction processing should achieve a high degree of data integrity
and consistency. This article, the first in a series on developing an effective transaction strategy for the Java platform, introduces
common transaction pitfalls that can prevent you from reaching this goal. Using code examples from the Spring Framework and the Enterprise JavaBeans (EJB) 3.0 specification, series author Mark Richards explains these all-too-common mistakes.
|
|
Articles |
|
03 Feb 2009 |
|
| |
Generate DITA Java API reference documentation using DITADoclet
and DITA API specialization
Combine DITADoclet and DITA API specialization to save time and still produce quality API documentation directly from the Java source code.
|
|
Articles |
|
03 Feb 2009 |
|
| |
Essential Java resources
The Java platform will be celebrating its 14th birthday soon and one side-effect when a successful and ubiquitous language reaches this kind of milestone is the widespread proliferation of libraries, tools, and ideas -- this bonus can leave many newcomers to the Java language adrift in a sea of material. In this article, the author (a solid contributor to that overwhelming sea) tacks through the vast tides and presents a list of the key resources any up-and-coming Java developer should have.
|
|
Articles |
|
23 Jan 2009 |
|
| |
Mastering Grails: Give your Grails applications a facelift
In this installment of Mastering Grails, Scott Davis demonstrates how to make drastic changes to the look and feel of a Grails application using Cascading Style Sheets (CSS), templates, tag libraries (TagLibs), and more.
|
|
Articles |
|
20 Jan 2009 |
|
| |
Java's new math, Part 2: Floating-point numbers
Join Elliotte Rusty Harold for a look into "new" features in the classic java.lang.Math class in this two-part article. Part 1 focuses on more purely mathematical functions. Part 2 explores the functions designed for operating on floating-point numbers.
|
|
Articles |
|
13 Jan 2009 |
|
| |
Automation for the people: Deployment-automation patterns, Part 1
Java deployments are often messy, error-prone, and manual, leading to delays in making software available to users. In Part 1 of a two-part article in the Automation for the people series, automation expert Paul Duvall identifies a collection of key patterns for developing a reliable, repeatable, and consistent deployment process capable of generating one-click deployments for Java applications.
|
|
Articles |
|
13 Jan 2009 |
|
| |
Groovier Spring, Part 1: Integration basics
The Spring Framework provides a solid foundation for Web and enterprise applications. Spring's support for dynamic languages like Groovy adds capabilities that can make your application architecture more flexible and dynamic. In Part 1 of this two-part series, you'll learn the basics of integrating Groovy into Spring applications.
|
|
Articles |
|
06 Jan 2009 |
|
| |
Groovier Spring, Part 2: Change application behavior at run time
The Spring Framework provides a solid foundation for Web and enterprise applications. Spring's support for dynamic languages like Groovy adds capabilities that can make your application architecture more flexible and dynamic. In the second and final installment of the Groovier Spring series, you'll learn how to change the behavior of Spring applications at run time using dynamically refreshable beans.
|
|
Articles |
|
06 Jan 2009 |
|
| |
The busy Java developer's guide to Scala: Scala and servlets
If Scala is a fully JVM-compatible language, then you should be able
to use it in various "real-world" environments such as one in which you build servlets
and other Web applications. In this article, the author explores using Scala in a servlet
environment.
|
|
Articles |
|
22 Dec 2008 |
|
| |
JavaScript EE, Part 1: Run JavaScript files on the server side
Combine JavaScript with Java code on the server to get the freedom to use the
same JavaScript routines on both servers and clients. In addition, the
techniques presented throughout this series will allow you to maintain a
single code base for both Ajax and non-Ajax clients. Because much of the
server-side code would still be written in the Java language, you'll find it
necessary to expose the Java Platform, Enterprise Edition (Java EE) features to JavaScript. In this series, learn
how to run JavaScript files on the server side, call remote JavaScript
functions with Ajax, and use the Java Scripting API with the JavaServer Pages
(JSP) technology.
|
|
Articles |
|
16 Dec 2008 |
|
| |
Mastering Grails: Grails in the enterprise
In this installment of Mastering Grails, series author Scott Davis puts to rest any qualms about Grails' readiness for the enterprise. You'll see how to use Grails with enterprise-caliber libraries including the Java Management Extensions (JMX), Spring, and log4j.
|
|
Articles |
|
16 Dec 2008 |
|
| |
Stop writing so much code!
Write less code by leveraging a battle-hardened collection of open source utilities from the Apache Commons project's Lang library. Reusing other people's reliable code helps you get your software to market more quickly, with fewer defects.
|
|
Tutorials |
|
16 Dec 2008 |
|
| |
Prelude to a software profiler: Work you should do before the tool works for you
Today's software profilers do a great job of identifying the
resource-intensive code in your application. It takes a lot more work on your
part,
however, to determine which components need the most tuning to make your
application run faster. In this article, learn about a methodical approach for
efficiently finding the root performance problems. Rein in the
resource hogs, and zero in on the performance pickles that are the most fixable.
|
|
Articles |
|
09 Dec 2008 |
|
| |
Dependency injection with Guice
Guice is Google's open source dependency injection framework for Java development. It enables better testing and modularity by taking away the pain of writing your own factories. Nicholas Lesiecki offers a tour of the most important Guice concepts that will leave you ready to Guice up your applications.
|
|
Articles |
|
09 Dec 2008 |
|
| |
Debug Java applications remotely with Eclipse
You don't need to debug Java applications on just your local desktop. Learn how to spread around your debugging using different connection types that make up remote debugging. This article outlines the features and examples that show how to set up remote application debugging.
|
|
Articles |
|
09 Dec 2008 |
|
| |
Build faster Web applications with caching
Web developers who use Java technologies can quickly improve their applications'
performance by using a cache utility. Java Caching System (JCS), a powerful
distributed caching system for Java applications, is a highly configurable tool with a
simple API. This article gives you an overview of JCS and shows how you can use it to speed up your Web applications.
|
|
Articles |
|
02 Dec 2008 |
|
| |
Building Ajax-enabled JSP TagLib controls, Part 2: Auto-populate and field validator controls
Build Asynchronous JavaScript + XML (Ajax) controls that can be used in
business-line applications. These configurable JavaServer Pages (JSP) TagLib-based controls
leverage JavaScript Object Notation (JSON), JavaScript scripting language, and
Cascading Style Sheets (CSS). Because they are standard JSP TagLib controls, find out how
you can easily drop them into any application to provide more intuitive and responsive user
interfaces.
|
|
Articles |
|
25 Nov 2008 |
|
| |
The busy Java developer's guide to Scala: Building a calculator, Part 3
Domain-specific languages (DSLs) have become a hot topic; much of the buzz around functional languages is their ability to build such languages. After having established both an AST scheme and a basic front-end parser designed to take text and produce a graph of objects suitable for interpretation, in this article the author thinks it's time to wire everything together into a seamless -- if somewhat trivial at this point -- whole. Then he'll turn around and suggest some extensions that could be made to the language and interpreter.
|
|
Articles |
|
25 Nov 2008 |
|
| |
Automation for the people: Wielding wizard-based installers
Installing software is often a painful chore for most users. The installation
package you generate -- the "last mile" of software development -- can make the
difference between user adoption and another product thrown into the virtual waste bin. In this installment of Automation for the people, automation expert Paul Duvall demonstrates how the freely available, open source IzPack tool for writing wizard-based installers can make installing your software a snap for users.
|
|
Articles |
|
25 Nov 2008 |
|
| |
Pointillism meets pixelation
Paul Reiners shows how to animate images in unexpected and artistic ways using the Java 2D API and cellular automata. In the process, he demonstrates implementation of an image operator in Java code and explains cyclic space, a type of 2D cellular automaton. You can use the ideas from this article to create your own image operators and artistic programs using Java technology.
|
|
Articles |
|
18 Nov 2008 |
|
| |
Mastering Grails: Asynchronous Grails with JSON and Ajax
JavaScript Object Notation (JSON) and Asynchronous JavaScript + XML (Ajax) are staples of Web 2.0 development. In this installment of the Mastering Grails series, author Scott Davis demonstrates the native JSON and Ajax capabilities baked into the Web framework.
|
|
Articles |
|
18 Nov 2008 |
|
| |
Create stand-alone Web services applications with Eclipse and
Java SE 6, Part 1: The Web service server application
Use the Eclipse Integrated Development Environment (IDE) and Java
Platform, Standard Edition (Java SE) 6 to create a stand-alone Web services
application that can be run from the console. In this tutorial, the first in a
series, start by getting familiar with the Eclipse IDE. Configure the
environment; create projects, packages, and classes; then run the application
from the command line.
|
|
Tutorials |
|
13 Nov 2008 |
|
| |
Advanced XQuery: Creating custom functions
XQuery functions enable you to define common expressions once and reuse them frequently. The end result is tighter, more robust code that is easier to maintain. Using XQuery API for Java (XQJ), this tutorial demonstrates an implementation of XQuery functions within a Java environment.
|
|
Tutorials |
|
11 Nov 2008 |
|
| |
Drive development with easyb
A disconnect between the stakeholders who define requirements and the developers
who implement them has long plagued software development. In recent years, frameworks
based on dynamic languages and domain-specific languages (DSLs) have tried to bridge
the stakeholder-developer gap by making code read more like normal language. This
tutorial shows how easyb -- which provides a more natural DSL that is closely attuned to stakeholders -- helps developers and stakeholders collaborate effectively.
|
|
Tutorials |
|
05 Nov 2008 |
|
| |
What's new with Apache Solr
Leverage Apache Solr's many new enhancements to add best-in-breed capabilities to your application.
|
|
Articles |
|
04 Nov 2008 |
|
| |
Java's new math, Part 1: Real numbers
Join Elliotte Rusty Harold for a look into "new" features in the classic
java.lang.Math class in this two-part article. Part 1 focuses on more purely
mathematical functions. Part 2 will explore the functions designed for operating on floating-point numbers.
|
|
Articles |
|
28 Oct 2008 |
|
| |
The busy Java developer's guide to Scala: Building a calculator, Part 2
Domain-specific languages (DSLs) have become a hot topic; much of the buzz
around functional languages is their ability to build such languages. In this latest
installment, Ted Neward tackles the problem of transforming
textual input into the AST for interpretation by continuing with a simple calculator DSL
that demonstrates the power of functional languages for building "external" DSLs. To parse
textual input and transform it into the tree structure used by the interpreter in the last
article, Ted introduces "parser combinators," a standard Scala library designed solely for the task. (In the previous article, we built a calculator interpreter and AST.)
|
|
Articles |
|
21 Oct 2008 |
|
| |
Writing great code with the IBM FileNet P8 APIs, Part 1: Hello, Document!
This article gets you started with developing a simple application,
HelloDocument, with the IBM FileNet P8
Content API. Through a sequence of simple operations, learn to use coding patterns
to perform a wide variety of your own operations. The P8 APIs are extensive, and it
can be a little tricky for first-timers to know how to get started. This article
gives you that start: an orientation and launchpad from which you can easily build
your own applications. Even if you are an old hand at P8 development, you will
certainly find useful information in this article and subsequent articles in the
series. Future articles in this series go into more depth on specific topics in both the process and content APIs.
|
|
Articles |
|
16 Oct 2008 |
|
| |
Mastering Grails: Testing your Grails application
Grails makes it easy to ensure that your Web applications start out bug
free and stay that way. As a bonus, you can leverage your test code to produce a rich
set of executable documentation that is always up-to-date. This month, Grails guru Scott Davis shows you the Grails testing ropes.
|
|
Articles |
|
14 Oct 2008 |
|
| |
Cross-platform development with JRuby and Swing
In addition to building Web and console applications with Ruby, you can write complex GUI desktop applications that run unmodified on multiple platforms. Thanks to JRuby, a robust alternative to the traditional C implementation of Ruby, Ruby GUI toolkits can use UI tools available to the Java platform. This article introduces Monkeybars, a library that uses JRuby and Swing for building applications, and takes you through an example application.
|
|
Articles |
|
07 Oct 2008 |
|
| |
Automation for the people: Parallel development for mere mortals
Although many development teams use version-control systems to manage code changes, they can struggle when developers code off the same code base, in parallel. In this Automation for the people installment, automation expert Paul Duvall shows how to effectively tag, branch, and merge source code using the open source, freely available Subversion version-control system.
|
|
Articles |
|
07 Oct 2008 |
|
| |
Enhance performance with class sharing
The latest release of the IBM JRE for Java SE
6 enhances IBM's class sharing feature first introduced in Version 5. In
this article, performance analysts Adam Pilkington and Graham Rawson detail the changes, which
include improvements in application startup times and memory utilisation.
|
|
Articles |
|
30 Sep 2008 |
|
| |
Build configurable workflows with WS-BPEL and IoC, Part 2: Developing and hosting BPEL workflows
In Part 2 of this brief series, Bilal Siddiqui explains how to use BPEL to express the logic of configurable business workflows. You'll learn how to host your BPEL applications on a BPEL engine and make them work in conjunction with an IoC implementation.
|
|
Articles |
|
30 Sep 2008 |
|
| |
Securing a multitenant SaaS application
The multitenant nature of Software as a Service (SaaS) applications makes security an essential concern. This article introduces a viable and practical approach to securing a multitenant Java application with the open source Spring Security framework combined with Apache Directory Server. The authors present a multitenant example Web application to demonstrate this approach.
|
|
Articles |
|
30 Sep 2008 |
|
| |
Java theory and practice: Are all stateful Web applications broken?
The session state management mechanism provided by the Servlets framework, HttpSession, makes it easy to
create stateful applications, but it is also quite easy to
misuse. Many Web applications that use HttpSession
for mutable data (such as JavaBeans classes) do so with
insufficient coordination, exposing themselves to a host of
potential concurrency hazards.
|
|
Articles |
|
23 Sep 2008 |
|
| |
Mastering Grails: RESTful Grails
We live in the era of mashups. Creating Web pages that give users the information they
want is a good start, but offering a source of raw data that other Web developers can
easily mix in with their own applications is better. In this installment of Mastering Grails, Scott Davis introduces various ways to get Grails to produce XML instead of the usual HTML.
|
|
Articles |
|
16 Sep 2008 |
|
| |
Create a Java applet to download information in remote Web services
Start with a Java applet and build a server-based
proxy system that uses your browser to access an arbitrary Web service. You'll use
JavaScript code to access applet-based information and call a servlet, which retrieves
the remote information. Thus, you bypass the same-server restrictions on what an
applet can and cannot do.
|
|
Articles |
|
04 Sep 2008 |
|
| |
Efficient data transfer through zero copy
This article explains how you can improve the performance of I/O-intensive Java applications running on Linux and UNIX platforms through a technique called zero copy. Zero copy lets you avoid redundant data copies between intermediate buffers and reduces the number of context switches between user space and kernel space.
|
|
Articles |
|
02 Sep 2008 |
|
| |
Dynamically manage XML schema variations in XMLBeans applications
Apache XMLBeans does not inherently support multiple versions of an XML
schema. For applications that need this type of support to manage
compatibility, this limitation is serious. But there is a solution, and in
this article, you'll learn how dynamic class loading techniques can help.
|
|
Articles |
|
26 Aug 2008 |
|
| |
The busy Java developer's guide to Scala: Building a calculator, Part 1
Domain-specific languages have become a hot topic; much
of the buzz around functional languages is their applicability to build such
languages. In this installment, Ted Neward starts building
a simple calculator DSL that demonstrates the power of functional languages for
building "external" DSLs. Toward that end, he explores a new feature of Scala,
case classes, and revisits an old functional friend, pattern matching.
|
|
Articles |
|
26 Aug 2008 |
|
| |
The Java XPath API
Elliotte Rusty Harold demonstrates Java 5's new XPath API.
|
|
Articles |
|
25 Aug 2008 |
|
| |
Customize JAX-RPC Web services and clients with advanced tools
This tutorial takes you beyond the basics of the JAX-RPC and shows how to customize your JAX-RPC Web services and clients with the help of Apache Axis. On the client side, you can autogenerate much of the code required to connect with new JAX-RPC Web services, focusing your time on the interactions themselves rather than on routine Web service calls. On the server side, you can add additional options, limit the methods you expose, and restrict parameters you'll accept. All of this is possible with a little customization and a deeper understanding of the Apache Axis toolset.
|
|
Tutorials |
|
19 Aug 2008 |
|
| |
Java run-time monitoring, Part 3: Monitoring performance and availability of an application's ecosystem
The third and final installment in this series on run-time monitoring of Java
applications focuses on strategies and techniques for monitoring the performance and availability of an application's supporting and dependent services. These include the underlying host operating system, the operational database, and messaging infrastructures. The article concludes with a discussion of performance data management issues and data reporting and visualization.
|
|
Articles |
|
12 Aug 2008 |
|
| |
Mastering Grails: The Grails event model
Everything in Grails, from build scripts to individual artifacts such as domain classes and controllers, throw events at key points during an application's life cycle. In this Mastering Grails installment, you'll learn how to set up listeners to catch these events and react to them with custom behavior.
|
|
Articles |
|
12 Aug 2008 |
|
| |
IBM Cognos SDK Validation tool
Download and try the IBM Cognos Validation tool, a command line utility written in Java using the IBM Cognos SDK.
This tool can run a complete validation check of all the reports in the Content Store by automating the Report Studio validate process.
|
|
Articles |
|
07 Aug 2008 |
|
| |
Automation for the people: Hands-free database migration
Databases are often out of sync with the applications they support, and getting the database and data into a known state is a significant challenge to manage. In this installment of Automation for the people, automation expert Paul Duvall demonstrates how the open source LiquiBase database-migration tool can reduce the pain of managing the constant of change with databases and applications.
|
|
Articles |
|
05 Aug 2008 |
|
| |
Java run-time monitoring, Part 2: Postcompilation instrumentation and performance monitoring
Part 1 of this three-part series on run-time monitoring of Java applications focuses on the JVM's health and ways to instrument source code to capture performance metrics. This second installment presents techniques for instrumenting Java classes and constructs without modifying the original source code.
|
|
Articles |
|
05 Aug 2008 |
|
| |
Ajax and Java development made simpler, Part 4: Create JSF-like components, using JSP tag files
JavaServer Pages (JSP) and JavaServer Faces (JSF) used to have different variants
of the Expression Language (EL). Their unification in JSP 2.1 opened new possibilities,
allowing you to use deferred values and deferred method attributes in your custom JSP
tags. This article shows how to develop Java Web components based on JSP tag files,
which are much simpler and easier to build than the JSF components.
|
|
Articles |
|
29 Jul 2008 |
|
| |
Java run-time monitoring, Part 1: Run-time performance and availability monitoring for Java systems
Run-time performance monitoring is critical to achieving and maintaining a well-performing system. In this article, the first in a three-part series, Nicholas Whitehead explains how to do low-level granular monitoring of Java performance efficiently. The data you generate can provide valuable insights into system operation and reveal constraints and influences that affect an environment's stability and performance.
|
|
Articles |
|
29 Jul 2008 |
|
| |
The busy Java developer's guide to Scala: Packages and access modifiers
Code has to be referenced and packaged in the real world, and in this installment of his series, Ted Neward covers Scala's package and access modifier facilities before continuing to explore of the functional side of Scala by examining the "apply" mechanism.
|
|
Articles |
|
29 Jul 2008 |
|
| |
Using the Ruby Development Tools plug-in for Eclipse
This article introduces using the Ruby Development Tools (RDT) plug-in for Eclipse, which allows Eclipse to become a first-rate Ruby development environment. Ruby developers who want to learn how to use the rich infrastructure of the Eclipse community to support their language will benefit, as will Java developers who are interested in using Ruby.
|
|
Articles |
|
24 Jul 2008 |
|
| |
Use XStream to serialize Java objects into XML
XML serialization has a myriad of uses, including object persistence and data transport. However, some XML-serialization technologies can be complex to implement. XStream is a lightweight and easy-to-use open source Java library for serializing Java objects to XML and back again. Learn how to set up XStream, and discover how to use it to serialize and deserialize objects as well as to read configuration properties from an XML configuration file.
|
|
Articles |
|
23 Jul 2008 |
|
| |
Deal with errors in XML parsing
XML parsing is a part of nearly every enterprise application. Error handling, though, is absent from most of those same applications. Learn how to use the Simple API for XML (SAX) to deal with errors in your XML parsing -- even if your applications are using the DOM, JAXP, or another API to deal with XML.
|
|
Articles |
|
22 Jul 2008 |
|
| |
Ajax and Java development made simpler, Part 3: Build UI features based on DOM, JavaScript, and JSP tag files
In the first part of this series, you saw how to generate JavaScript code for sending Ajax requests and processing Ajax responses. The second part showed how to create HTML forms, using conventions and JSP tag files to minimize setup and configuration. In this third part of the series, you'll learn how to develop client-side validators based on JavaScript as well as server-side validators, which are implemented as JSP tag files backing up their JavaScript counterparts. You'll also learn how to use resource-bundles that are reloaded automatically when changed, without requiring the restart of the application.
|
|
Articles |
|
22 Jul 2008 |
|
| |
Build a RESTful Web service
Representational state transfer (REST) is a style of designing loosely coupled applications that rely on named resources rather than messages. The hardest part of building a RESTful application is deciding on the resources you want to expose. Once you've done that, using the open source Restlet framework makes building RESTful Web services a snap. This tutorial guides you step-by-step through the fundamental concepts of REST and building applications with Restlets.
|
|
Tutorials |
|
22 Jul 2008 |
|
| |
Build an RPC service and client using JAX-RPC
Remote procedure calls (RPCs) are the precursors to modern Web services
that are based on the Simple Object Access Protocol (SOAP) or Representational State
Transfer (REST). Because all of the Java platform's Web service APIs are built on the concepts introduced in RPC, understanding the Java APIs for XML-Based RPC (JAX-RPC) is an almost mandatory step for writing efficient and effective Web services in the Java language. This tutorial takes you through getting and installing JAX-RPC, configuring it, and building a server-side RPC receiver and a simple client-side application.
|
|
Tutorials |
|
15 Jul 2008 |
|
| |
Mastering Grails: Grails and legacy databases
In this Mastering Grails installment, Scott Davis explores the various ways that Grails can use database tables that don't conform to the Grails naming standard. If you have Java classes that already map to your legacy databases, Grails allows you to use them unchanged. You'll see examples that use Hibernate HBM files and Enterprise JavaBeans 3 annotations with legacy Java classes.
|
|
Articles |
|
15 Jul 2008 |
|
| |
Evaluating XPaths from the Java platform
XPath makes selecting elements, attributes, and text in an XML document easy.
Learn how to evaluate XPaths from Java programming, and work with the returned nodes.
|
|
Articles |
|
08 Jul 2008 |
|
| |
IBM Data Studio pureQuery Runtime for z/OS Performance
In this article, get a brief overview of pureQuery technology, the enhancements announced with Version 1.2, and the results of a performance study comparing pureQuery access methods with a variety of popular Java data access alternatives.
|
|
Articles |
|
08 Jul 2008 |
|
| |
Build configurable workflows with WS-BPEL and IoC, Part 1: Understanding dynamic business workflows
Inversion of Control (IoC) and Web Services Business Process Execution Language (WS-BPEL) can be effective tools for implementing dynamic business workflows. In this article, the first in a two-part series, Bilal Siddiqui describes business workflows' dynamic nature and proposes a two-layer workflow model that lets you use XML to build configurable and flexible solutions.
|
|
Articles |
|
08 Jul 2008 |
|
| |
Automation for the people: Continual refactoring
Refactoring is a well-accepted practice for improving existing code.
Yet, how do you find the code that should be refactored, in a consistent and
repeatable manner? In this installment of Automation
for the people, you'll learn how to use static analysis tools to identify code smells to refactor, with examples showing how to improve odiferous code.
|
|
Articles |
|
08 Jul 2008 |
|
| |
Java theory and practice: Going wild with generics, Part 2
Wildcards can be very confusing when it comes to generics in the Java
language, and one of the most common mistakes is to fail to use one of the two forms of
bounded wildcards ("super T" and "?
extends T") when needed. You've made this mistake? Don't feel bad, even
the experts have, and this month Brian Goetz shows you how to
avoid it.
|
|
Articles |
|
01 Jul 2008 |
|
| |
The busy Java developer's guide to Scala: Collection types
Objects have their place in Scala, but so do functional types such as tuples, arrays, and lists. In this installment of Ted Neward's popular series, you'll begin to explore the functional side of Scala, starting with its support for types common to functional languages.
|
|
Articles |
|
27 Jun 2008 |
|
| |
Robust Java benchmarking, Part 1: Issues
Program performance is always a concern, even in this era of
high-performance hardware. This article, the first in a two-part series, guides you
around the many pitfalls associated with benchmarking Java code. Part 2 covers the statistics of benchmarking and offers a framework for performing Java benchmarking. Because almost all new languages are virtual machine-based, the general principles the article describes have broad significance for the programming community at large.
|
|
Articles |
|
24 Jun 2008 |
|
| |
Robust Java benchmarking, Part 2: Statistics and solutions
Program performance is always a concern, even in this era of high-performance hardware. This article, the second in a two-part series, covers the statistics of benchmarking and offers a framework you can use to benchmark Java code ranging from self-contained microbenchmarks to code that calls a full application.
|
|
Articles |
|
24 Jun 2008 |
|
| |
Locate specific sections of your XML documents with XPath, Part 2
Part 1 of this tutorial gave you a foundational understanding of XPath. Using slash notation, wildcards, unions, and simple text, you learned how to locate elements and attributes anywhere within an XML document. However, sometimes you need more than just matching based on the name of a node. Predicates give you advanced and refined searching capabilities, allowing you to evaluate the values of attributes and the parent and child nodes of a targeted element. Rather than find a wider node set and refine or filter that set programmatically, you can add predicates to your XPaths to find exactly the nodes you want.
|
|
Tutorials |
|
17 Jun 2008 |
|
| |
Mastering Grails: Grails and the mobile Web
The number of cell phone users worldwide is at 3.3 billion and rising, and Internet access from mobile phones is on a rapidly upward trajectory. Developing for the mobile Web has its unique demands. In this Mastering Grails installment, Scott Davis shows you how to make your Grails applications mobile phone friendly.
|
|
Articles |
|
17 Jun 2008 |
|
| |
Automation for the people: Pushbutton documentation
Project documentation is often one of the necessary evils in delivering a software product. But imagine being able to generate your documentation at the click of a button. In this installment of Automation for the people, automation expert Paul Duvall explains how you can use open source tools to automate the generation of Unified Modeling Language (UML) diagrams, build figures, entity-relationship diagrams (ERDs), and even user documentation.
|
|
Articles |
|
10 Jun 2008 |
|
| |
Locate specific sections of your XML documents with XPath, Part 1
XML is a data format concerned primarily with compatibility and flexibility. But
as useful as XML is, it's limited without the abilities to find specific portions of a
document quickly and to filter and selectively locate data within a document. XPath
provides the ability to easily reference specific text, elements, and attributes within
a document -- and with a fairly low learning curve. Additionally, XPath is key to many other XML vocabularies and technologies, such as XSL and XQuery. This tutorial will teach you the fundamentals of XPath, including all of its various selectors and semantics, in an example-driven and hands-on manner.
|
|
Tutorials |
|
10 Jun 2008 |
|
| |
Reuse Java code in your Ruby on Rails applications
The Ruby Java Bridge (RJB) lets you load Java classes directly
to, and call them from, Ruby on Rails applications. This tutorial shows how you can
put this toolkit to work by reusing your legacy Java Web application code in a modern Web development platform.
|
|
Tutorials |
|
05 Jun 2008 |
|
| |
Embed the NASA World Wind Java SDK in Eclipse
The open source World Wind Java (WWJ) SDK by NASA creates new possibilities for the open Geographic Information Systems (GIS) community. World Wind, a 3D interactive world viewer written in the Java language and OpenGL, lets users zoom from outer space into any place on Earth. This article explains how GIS developers who want to enhance their Eclipse-based applications can embed the WWJ SDK as an Eclipse plug-in.
|
|
Articles |
|
03 Jun 2008 |
|
| |
The busy Java developer's guide to Scala: Implementation inheritance
Scala gives you just as much support for implementation inheritance as
the Java language does -- but Scala's inheritance yields a few surprises. This month, Ted Neward
introduces you to polymorphism done the Scala way, blending functional and
object-oriented language styles while still mapping perfectly to the Java platform's inheritance model.
|
|
Articles |
|
28 May 2008 |
|
| |
Build software with Gant
Gant is a highly versatile build framework that leverages both Groovy and Apache Ant to let you implement programmatic logic while using all of Ant's capabilities. In this tutorial, Andy Glover guides you step-by-step through Gant's fundamental concepts. You'll learn how to define behavior in your build through Gant's flexible domain-specific language, how to reuse Ant features, and how to define functions that make your builds more efficient and even proactive.
|
|
Tutorials |
|
27 May 2008 |
|
| |
Dead like COBOL
With the recent reports of Java's imminent demise, you're
probably wondering if it's time to leave the platform behind for
greener pastures. Before you make a decision, step back and examine the Java ecosystem, along with
that of its competitors, to see if the rumors have any substance. It's time, in other
words, to have a State of the Java Union address, holding neither pride nor prejudice in
the evaluation of the platform.
|
|
Articles |
|
27 May 2008 |
|
| |
Creating business model templates with WebSphere Service Registry and Repository V6.1
Creating new enterprise-specific business models for use within the IBM WebSphere Service Registry and Repository enables your organization to represent your business concepts within WSRR, relate them to other concepts, and manage them using WebSphere Service Registry and Repository's governance capabilities. The default business models demonstrate what you can represent in WebSphere Service Registry and Repository, but how do you create your own models? This article describes how to create, load, update, and use new business models within WebSphere Service Registry and Repository V6.1 without having to use any special tooling.
|
|
Articles |
|
22 May 2008 |
|
| |
Ajax and Java development made simpler, Part 2: Use conventions to minimize setup and configuration
Most Web frameworks try to be as flexible and extensible as possible to accommodate different application needs and development styles. Unfortunately, sometimes this leads to complexity, processing overheads, and large configuration files. This article shows how to use JSP Standard Tag Library (JSTL) and JSP tag files to implement data binding, page navigation, and style conventions, which make both development and maintenance easier. You will learn how to build custom JSP tags with dynamic attributes to facilitate rapid application changes. In addition, the last section of the article contains an example that uses Ajax to submit a Web form.
|
|
Articles |
|
20 May 2008 |
|
| |
Mastering Grails: Grails services and Google Maps
Scott Davis shows you how you can add maps to a Grails application using freely
available APIs and Web services in this latest installment of Mastering
Grails. He uses the trip-planner sample application from previous installments and
takes it to the next level with geocoding, Google Maps, and Grails services.
|
|
Articles |
|
20 May 2008 |
|
| |
Developing long term strategies for using Java EE technology
Changes to technology are inevitable and necessary, and some of these changes could affect how your existing applications operate. Such inevitability might make it seem risky to commit to technologies that are driven by changing specifications, such as Java EE. However, it is possible to minimize the impact of incompatible changes with informed choices and good planning when determining which technologies are appropriate for you to use. This article offers information to help you make those informed choices, and also explains what IBM does to minimize the impact of these changes to your organization.
|
|
Articles |
|
14 May 2008 |
|
| |
Automation for the people: Manage dependencies with Ivy
Managing source-code dependencies among projects and tools is often a burden, but it doesn't need to be. In this installment of
Automation for the people,
automation expert Paul Duvall describes how you can use the Apache Ant project's Ivy dependency manager to handle the myriad dependencies that every nontrivial Java project must manage.
|
|
Articles |
|
06 May 2008 |
|
| |
Java theory and practice: Going wild with generics, Part 1
One of the most complicated aspects of generics in the Java
language is wildcards, and in particular, the treatment and confusing error messages surrounding wildcard capture. In this installment of Java
theory and practice, veteran Java developer Brian Goetz deciphers some of the weirder-looking error messages emitted by javac and offers some tricks and workarounds that can simplify using generics.
|
|
Articles |
|
06 May 2008 |
|
| |
The busy Java developer's guide to Scala: Of traits and behaviors
Scala doesn't just bring functional concepts to the JVM, it
offers us a modern perspective on object-oriented language design. In this
month's installment, Ted Neward shows you how
Scala exploits traits to make objects simpler and easier to build. As you'll
learn, traits are both similar to and different from the traditional
polarities offered by Java interfaces and C++ multiple
inheritance.
|
|
Articles |
|
29 Apr 2008 |
|
| |
Jenabean: Easily bind JavaBeans to RDF
The Resource Description Framework (RDF) is the World Wide Web
Consortium (W3C) proposed standard for linking and expressing data on the Web.
Java developers who develop applications for the Semantic Web will need to convert RDF properties to or from Java types. Jenabean uses the Jena Semantic Web framework's flexible RDF/OWL API to persist JavaBeans, making the task of writing these applications easier and more familiar to Java developers.
|
|
Articles |
|
29 Apr 2008 |
|
| |
Scala and XML
Scala is a popular new programming language that runs on the Java Virtual Machine (JVM.) Scala compiles into byte-code and thus it can leverage the Java programming language. Its syntax, however, makes it a powerful alternative to Java in certain scenarios. One of those scenarios is XML processing. Scala lets you navigate and process parsed XML in several ways. It also has first class support for XML built right in, so there is no need to create strings of XML or programmatically build DOM trees. In this article, you will see these aspects of Scala in action and see how Scala can make working with XML a joy to do.
|
|
Articles |
|
22 Apr 2008 |
|
| |
Patterns of persistence, Part 2: Increase code reuse and enhance performance
Part 1 of this
two-part article covers the basics of achieving a consistent, concise domain model and persistence tier with modern object-relational mapping (ORM) tools. In Part 2, the authors describe base domain entities, behavior in the domain model, and more-advanced features of a generic DAO. They also share strategies for enhancing data-retrieval performance with the domain model.
|
|
Articles |
|
22 Apr 2008 |
|
| |
Patterns of persistence, Part 1: Strategies and best practices for modern ORM tools
Although many developers use object-relational mapping (ORM) tools for
their applications' persistence tier, some are confused about how to use them and
duplicate code unnecessarily. The authors' experience constructing many persistence
tiers has given them a clear understanding of persistence patterns and best practices.
The first part of this two-part article covers the basics of a consistent, concise
domain model and persistence tier. Part 2 builds and
expands on the concepts covered in this article.
|
|
Articles |
|
22 Apr 2008 |
|
| |
Data binding with Castor, Part 4: Bind your Java objects to SQL databases
Castor allows you to bind the data in your Java objects directly into database
tables. Learn how to marshal from Java objects to SQL in this article.
|
|
Articles |
|
18 Apr 2008 |
|
| |
Mastering Grails: Many-to-many relationships with a dollop of Ajax
Many-to-many (m:m) relationships can be tricky to deal with in a Web
application. In this installment of Mastering Grails, Scott Davis shows you how to
implement m:m relationships in Grails successfully. See how they're handled by the
Grails Object Relational Mapping (GORM) API and the back-end database. Also find out
how a bit of Ajax (Asynchronous JavaScript + XML) can streamline the user interface.
|
|
Articles |
|
15 Apr 2008 |
|
| |
Tapestry and Wicket compared
JSF and Struts are the traditional component frameworks developers turn to for
Web development. You have an alternative, however: Tapestry and
Wicket are component-oriented Web frameworks designed to create Web
applications. A simple example application implementing a to-do list workflow is
developed here, using Tapestry and Wicket technologies.
|
|
Articles |
|
08 Apr 2008 |
|
| |
Spice up collections with generics and concurrency
The Java Collections Framework is an important aspect of the Java platform.
Both desktop and enterprise applications typically collect items to work with. This
article shows you how to work with collections while taking advantage of
enhancements made to the framework in Java SE 6. You can go far beyond HashMap or
TreeSet by using generics and concurrency features to make your applications more
maintainable and scalable.
|
|
Articles |
|
08 Apr 2008 |
|
| |
Automation for the people: Hands-off load testing
Load testing is often relegated to late-cycle activities, but it doesn't
need to be that way. In this installment of Automation for the people, automation
expert Paul Duvall describes how you can discover and fix problems throughout the
development cycle by creating a scheduled integration build that runs JMeter tests.
|
|
Articles |
|
08 Apr 2008 |
|
| |
Ajax and Java development made simpler, Part 1: Generate JavaScript code dynamically with JSP tag files
Many Web developers complain that Java EE is too complex,
building new Web components is difficult, customizing the existing ones is not as
easy as it should be, and minor changes require application restarts. This series presents simple solutions to these problems, using code generators, conventions, scripting languages, and the latest JavaServer Pages (JSP) features. You will learn how to build reusable Ajax and Java components based on JSP tag files, which are very easy to develop and deploy. When changed, JSP tag files are recompiled automatically by the Java EE server without having to restart the application. In addition, you fully control the generated code, and you are able to easily customize these lightweight components because they use the JSP syntax.
|
|
Articles |
|
08 Apr 2008 |
|
| |
Using the SQLXML data type
If you're a Java 2 Enterprise Edition (J2EE) developer, you'll want to preview the SQLXML technology. Check out procedures to create an XML document, store an XML document in a relational database, retrieve an XML document from a database, and navigate an XML document with the SQLXML Java data type.
|
|
Articles |
|
07 Apr 2008 |
|
| |
Securing Java applications with Acegi, Part 5: Protecting JavaBeans in JSF applications
Bilal Siddiqui concludes his series by demonstrating how to use Acegi to
secure access to JavaBeans in Java Server Faces (JSF) applications. You can
configure secure beans in a variety of ways, including using Acegi-secured
inversion-of-control (IOC) beans directly in your JSF tags.
|
|
Articles |
|
01 Apr 2008 |
|
| |
Fluently Groovy
This tutorial is for Java developers unfamiliar with Groovy,
who want a quick and easy introduction to the basics. Get started with Groovy's
simplified variation of the Java syntax and learn about essential features like native
collections, built-in regular expressions, and closures. Write your first Groovy class,
and then see how easily you can use JUnit to test it. You'll walk away from this
one-hour tutorial with a fully functioning Groovy development environment and the skills to use it. Best of all, you'll have learned first-hand how to use Groovy and Java code together in your everyday Java application development.
|
|
Tutorials |
|
26 Mar 2008 |
|
| |
The busy Java developer's guide to Scala: Don't get thrown for a loop!
Scala was written specifically for the Java platform, so its syntax is
designed to make Java coders feel at ease. At the same time, Scala brings to the JVM
the inherent power of functional languages -- and those functional design concepts
take some getting used to. In this installment, Ted Neward starts introducing you to the subtle differences
between the two languages, starting with control constructs such as if, while, and
for. As you'll learn, Scala gives these constructs a power and complexity you won't
find in their Java equivalents.
|
|
Articles |
|
26 Mar 2008 |
|
| |
An introduction to RichFaces
Today's clients want and have begun to expect desktop features in
browser-based applications. RichFaces is one of a new breed of user interface
component suites available for Java Server Faces (JSF). Among other benefits,
RichFaces provides built-in JavaScript and Ajax capabilities to meet those
expectations. Joe Sam Shirah adds some new tools to your kit based on experiences
with a recent field project, including general setup for using RichFaces with
Facelets, and several specific component examples
|
|
Articles |
|
25 Mar 2008 |
|
| |
What's new in the Java Portlet Specification V2.0 (JSR 286)?
Learn all about the second version of the Java Portlet Specification (JSR 286). In Version 2.0, the specification and the APIs more than
doubled, and it allows you to implement most use cases without the need to have vendor extensions. The portlet programming model also provides events and public render parameters so that you can build
larger composite applications out of your portlets and reuse your portlets in different scenarios.
|
|
Articles |
|
18 Mar 2008 |
|
| |
Implement business logic with the Drools rules engine
Using a rules engine can lower an application's maintenance and
extensibility costs by reducing the complexity of components that implement complex
business logic. This updated article shows you how to use the open source Drools
rules engine to make a Java application more adaptive to changes. The Drools project
has introduced a new native rule expression language and an Eclipse plug-in, making
Drools easier to use than ever before.
|
|
Articles |
|
18 Mar 2008 |
|
| |
Create Ajax-style architectures with the IBM Web 2.0 Feature Pack
This article shows you how a Java(tm) 2 Platform, Enterprise Edition (J2EE)
application was enhanced with an Ajax-style architecture by using the IBM(R)
WebSphere(R) Application Server Feature Pack for Web 2.0. Learn how to combine Ajax-style architectures with an existing application without
having to rewrite the entire Web application. You'll also discover some ideas on how to apply the Web 2.0 Feature Pack to your own J2EE
applications for IBM WebSphere Application Server.
|
|
Articles |
|
18 Mar 2008 |
|
| |
Mastering Grails: Changing the view with Groovy Server Pages
Groovy Server Pages (GSP) puts the "Web" in the Grails Web
framework. In the third installment of his
Mastering Grails
series, Scott Davis shows you the ins and outs of working with GSP. See how easy it
is to use Grails TagLibs, mix together partial fragments of GSPs, and customize the
default templates for the automatically generated (scaffolded) views.
|
|
Articles |
|
11 Mar 2008 |
|
| |
Dynamic programming and sequence alignment
Molecular biology is increasingly dependent on computer science algorithms
as research tools. This article introduces you to bioinformatics -- the use of
computers to solve biological problems. Learn the basics of dynamic programming, an
advanced algorithmic technique you may find useful in many of your programming
projects.
|
|
Articles |
|
11 Mar 2008 |
|
| |
Java theory and practice: Stick a fork in it, Part 2
One of the additions to the java.util.concurrent packages coming in Java 7
is a library for fork-join-style parallel decomposition. In part one of this series,
author Brian Goetz shows how fork-join provides a natural mechanism for decomposing
many algorithms to effectively exploit hardware parallelism. In this article, he'll
cover the ParallelArray classes, which simplify parallel sorting and searching
operations on in-memory data structures.
|
|
Articles |
|
04 Mar 2008 |
|
| |
Automation for the people: Continuous Integration anti-patterns, Part 2
While Continuous Integration (CI) can be extremely effective at reducing risks on a
project, it requires a greater emphasis on your day-to-day coding activities. In this second installment of a two-part article on CI anti-patterns, automation expert and co-author of Continuous Integration: Improving Software Quality and Reducing Risk, Paul Duvall, continues laying out CI anti-patterns, and more importantly, demonstrates how to avoid them.
|
|
Articles |
|
04 Mar 2008 |
|
| |
The busy Java developer's guide to Scala: Class action
It makes sense for Java developers to use objects as a first point of
reference for understanding Scala. In this installment, Ted Neward follows a basic premise of language
measurement: that the power of a language can be measured in direct relation to its
ability to integrate new facilities -- in this case, support for complex numbers.
Along the way you'll see some interesting tidbits related to class definitions and
usage in Scala.
|
|
Articles |
|
19 Feb 2008 |
|
| |
Securing Java applications with Acegi, Part 4: Protecting JSF applications
Bilal Siddiqui continues his series by showing you how to use Acegi to
secure JavaServer Faces (JSF) applications. Configure JSF and Acegi to work together
in a servlet container, and explore how JSF and Acegi components cooperate with one
another.
|
|
Articles |
|
19 Feb 2008 |
|
| |
RESTful SOA using XML
Service Oriented Architecture usually implies heavyweight technology for large
enterprises. The advantages of the SOA architectural pattern also apply to smaller
environments. To follow SOA principles, you don't necessarily need all the overhead that
is useful in larger environments. You can use lightweight principles like REST to do so. This article describes how.
|
|
Articles |
|
12 Feb 2008 |
|
| |
Mastering Grails: GORM: Funny name, serious technology
Any good Web framework needs a solid persistence strategy. In this second
installment of his Mastering Grails series, Scott Davis introduces the Grails Object
Relational Mapping (GORM) API. See how easy it is to create relationships between
tables, enforce data validation rules, and change relational databases in your
Grails applications.
|
|
Articles |
|
12 Feb 2008 |
|
| |
Craft Ajax applications using JSF with CSS and JavaScript, Part 2: Dynamic JSF forms
In the first article of
this two-part series, author and Java developer Andrei Cioroianu showed how to use the style attributes of JavaServer Faces (JSF) components and how to set up default values for those attributes. In this second installment of the series, learn how to exercise the JavaScript-related attributes of standard JSF components. Learn several Web techniques based on the Document Object Model (DOM) APIs, JavaScript, and Cascading Style Sheets (CSS). See how to hide and display optional JSF components without refreshing a Web page, how to implement client-side validation that is executed in the Web browser, and how to develop a custom component that displays help messages for the input elements of a Web form.
|
|
Articles |
|
12 Feb 2008 |
|
| |
Ropes: Theory and practice
Systems that manipulate large quantities of string data are poorly served by the Java language's default String and StringBuilder classes. A rope data structure can be a better alternative. This article introduces Ropes for Java, a rope implementation for the Java platform; explores performance issues; and provides pointers for effective use of the library.
|
|
Articles |
|
12 Feb 2008 |
|
| |
Receive events from XMLBeans
XMLBeans is a great XML-to-Java data-binding technology, but it lacks the ability to register observers for model changes. However, you can customize generated plain old Java objects (POJOs) to include the necessary interfaces and the notification of changes. Create a Sudoku Rich Client Platform (RCP) game application in Eclipse, and learn how to use eventing to validate the user's input.
|
|
Articles |
|
29 Jan 2008 |
|
| |
Getting started with JavaServer Faces 1.2, Part 2: JSF life cycle, conversion, validation, and phase listeners
This tutorial series covers how to get started with
Java Server Faces (JSF) technology, a server-side framework that offers a
component-based approach to Web user-interface development.
Part 1 gets you started with a JSF 1.2 overview and a basic application. This sequel gives
you a firm grasp of JSF's more-advanced features: custom validators, converters, and
phase listeners. Along the way you'll gain an understanding of the JSF application
life cycle.
|
|
Tutorials |
|
29 Jan 2008 |
|
| |
Craft Ajax applications using JSF with CSS and JavaScript, Part 1: Enhance the appearance of your JSF pages
Typical Web applications require the use of Cascading Style Sheets (CSS) and
JavaScript, together with a server-side framework, such as JavaServer Faces (JSF).
CSS lets you change the visual characteristics of Web components within Ajax and
other applications so they can have a pleasant and distinctive look. In the first installment of this two-part series, find out how to use the CSS-related attributes of standard JSF components. In addition, learn how to create a custom JSF component that sets the default styles of nested components, making it very easy to ensure a consistent look for all pages of your Web application. You can also use this technique to programmatically set other component attributes, as you'll see in Part 2, which will show how to make JSF forms more dynamic using JavaScript.
|
|
Articles |
|
29 Jan 2008 |
|
| |
Develop iPhone Web applications with Eclipse
Learn to create iPhone Web sites using Eclipse, Aptana's iPhone Development
plug-in, and the iUi framework. See the development of a Javadoc viewer for the iPhone,
uncover tips for user interface design, and hear about the future of iPhone application development.
|
|
Articles |
|
29 Jan 2008 |
|
| |
Data binding with Castor, Part 3: Map between schemas
Use Castor to convert data in an unwieldy or inconvenient XML document to your
custom Java objects.
|
|
Articles |
|
29 Jan 2008 |
|
| |
The busy Java developer's guide to Scala: Functional programming for the object oriented
The Java platform has historically been the province of object-oriented
programming, but even Java language stalwarts are starting to pay attention to the
latest old-is-new trend in application development: functional programming. In this
new series, Ted Neward introduces Scala, a programming language that combines
functional and object-oriented techniques for the JVM. Along the way, Ted makes the
case for why you should take the time to learn Scala -- concurrency, for one -- and
shows you how quickly it will pay off.
|
|
Articles |
|
22 Jan 2008 |
|
| |
Create rich applications with JavaFX Script
JavaFX Script, which made its debut last spring, is a scripting
language that runs on top of Java Platform, Standard Edition 6 (Java SE) and makes it easy to code sophisticated
user interfaces. Learn the essentials of the JavaFX scripting language and gain an
understanding of some basic UI components with the help of the sample application
detailed within.
|
|
Articles |
|
15 Jan 2008 |
|
| |
Mastering Grails: Build your first Grails application
Java programmers needn't abandon their favorite language and
existing development infrastructure to adopt a modern Web development framework. In the
first installment of his new monthly series Mastering Grails, Java
expert Scott Davis introduces Grails and demonstrates how to build your first Grails
application.
|
|
Articles |
|
15 Jan 2008 |
|
| |
Generate Ajax J2EE Web applications with jpa2web
Learn about, try, and contribute to a new open source tool -- jpa2web -- which generates J2EE Ajax-based Web applications from JPA-annotated beans. Using the ZK framework, the applications generated by this tool allow your users to add, delete, search, modify, and interconnect instances of database-synchronized objects in a friendly, Ajax-based Web user interface.
|
|
Articles |
|
15 Jan 2008 |
|
| |
Automation for the people: Speed deployment with automation
Automated builds aren't just for development teams -- they can be
extended to facilitate moving software from development all the way into production. In
this installment of Automation for the people, automation expert Paul Duvall describes how to use Ant with
Java Secure Channel for remotely deploying software into multiple target environments.
|
|
Articles |
|
08 Jan 2008 |
|
| |
Write REST services
This tutorial discusses the concepts of REST and the Atom Publishing
Protocol (APP) and shows how they apply to services. It also shows how to use Java technology to implement REST/APP-based services.
|
|
Tutorials |
|
20 Dec 2007 |
|
| |
Getting started with JavaServer Faces 1.2, Part 1: Building basic applications
JavaServer Faces (JSF) technology, a server-side framework that offers a component-based approach to Web user-interface development, has come a long way. JSF 1.2 (incorporated into Java Enterprise Edition 5) has fixed some JSF pain points and added some nice features. This tutorial series covers how to get started with JSF 1.2. It's heavy on examples and light on theory -- just what you need to get started quickly.
|
|
Tutorials |
|
18 Dec 2007 |
|
| |
Web development with Eclipse Europa, Part 3: Ruby Development Toolkit and RadRails
It's a good time to be a Web developer. You've never had more choices in terms
of technologies. There are so many great open source Web servers, databases,
programming languages, and development frameworks. No matter what combination of
technologies you prefer to work with, there is a single integrated development
environment (IDE) that can increase your productivity: Eclipse. In Part 1 of this
three-part series on how to use Eclipse for Web development in Java, PHP, and Ruby, you
saw how the latest release of Eclipse -- Europa -- can be used to rapidly develop Java
Web applications. In Part 2, you saw how easy it is to develop PHP applications using
a different set of Eclipse plug-ins, collectively known as the PHP Development Toolkit
(PDT). Here in Part 3, we introduce the RDT and RadRails Eclipse plug-ins and show you
how to get these plug-ins and start using them. You will learn how to use RadRails to
do many common Ruby on Rails development tasks.
|
|
Tutorials |
|
18 Dec 2007 |
|
| |
Understanding pureQuery, Part 1: pureQuery: IBM's new paradigm for writing Java database applications
The project called pureQuery gives database application developers an easy, GUI-based means to significantly increase productivity in both the design and implementation phases. This is accomplished through user-initiated automatic transformation of relational data into Java objects for access and manipulation of data. In turn, these objects can be seamlessly utilized in a natural OO programming paradigm to write the business logic and the underlying code. pureQuery's functionality in effect eliminates traditional JDBC programming by integrating the query language with Java itself.
|
|
Articles |
|
14 Dec 2007 |
|
| |
Building EJB 3.0 applications with WebSphere Application Server
EJB 3.0 is a major step forward in simplifying application development in the enterprise. By using the WebSphere Application Server V6.1 Feature Pack for Enterprise JavaBeans 3.0, you can benefit from the simplified development experience, new persistence model, and new features such as interceptors, while still deploying to a robust WebSphere platform.
|
|
Articles |
|
12 Dec 2007 |
|
| |
Create dynamic applications with javax.tools
Many of today's applications require dynamic capabilities, such as
enabling users to supply an abstract form of computation that extends an application's
static capabilities. The javax.tools package, added to
Java Platform, Standard Edition 6 (Java SE) as a standard API for compiling
Java source, is a superb way to achieve this goal. This article provides an overview of
the major classes in the package, demonstrates how to use them to create a facade
for compiling Java source from Java Strings instead of files,
and then uses this facade to build an interactive plotting application.
|
|
Articles |
|
11 Dec 2007 |
|
| |
Tip: Make the best use of asynchronous callbacks
It takes some finesse to make the best use of asynchronous callbacks for
Ajax data sources in JavaScript applications. This tip discusses
why you should use asynchronous callbacks for Ajax data sources and
gives examples of coordinating the readiness of mutually dependent
application data sources that may become ready at undefined times
with asynchronous calls.
|
|
Articles |
|
11 Dec 2007 |
|
| |
Web development with Eclipse Europa, Part 2: The Java EE for Eclipse
No matter what combination of technologies you prefer to work with as a Web
developer, Eclipse is a single integrated development environment (IDE) that can
increase your productivity. In Part 1 of this three-part series, you saw how the latest release of Eclipse -- Europa -- can be used to rapidly develop Java Web applications. In this tutorial, Part 2, we'll see how easy it is to develop PHP applications using a different set of Eclipse plug-ins, collectively known as the PHP Development Toolkit (PDT.)
|
|
Tutorials |
|
11 Dec 2007 |
|
| |
The busy Java developer's guide to db4o: Transactions, distribution, and security
Java developers can get a lot of mileage out of storing
objects directly in an object-oriented database like db4o. Without support for
transactions or the ability to use data in a distributed environment (and keep
it secure), however, you probably won't have much use for the OODBMS. In this
final installment in The busy Java developer's guide to db4o, Ted
Neward shows you how db4o handles three concerns central to Java enterprise
development: transactions, distributed data management, and Web application
security.
|
|
Articles |
|
11 Dec 2007 |
|
| |
Data binding with Castor, Part 2: Marshall and unmarshall XML
In the last article of this series, you downloaded, installed, and set up
Castor. In this article, you'll learn how to convert your Java(TM) classes to XML and
transform that XML back into Java code, as well as how Castor works and how to design your classes to function well with the API.
|
|
Articles |
|
10 Dec 2007 |
|
| |
Kick-start your Java apps, Part 2
The combination of Eclipse, DB2 Express-C 9.5, and WebSphere Application
Server Community Edition 2.0 -- all free to download, use, and deploy -- is an excellent from-prototype-to-production suite for all of your Java and Java enterprise development needs. What might not be obvious is the relative ease with which you can use these proven tools to create, test, and deploy cutting-edge, lightweight applications as well. This tutorial guides you through the development of a small human-resources application, first using conventional JavaServer Pages (JSP) based technology, and then migrating it to a highly interactive solution using Ajax.
|
|
Tutorials |
|
05 Dec 2007 |
|
| |
Kick-start your Java apps
To create, test, and deploy a Web-based application or Web service rapidly, you need a proven relational database, a standards-compliant Web application server, and a flexible IDE. Ideally, all these software packages are production-tested, simple to obtain, easy to use, and well integrated with one another. This tutorial shows you how to use IBM-backed open source and free software to kick-start your Java Web-based application development. You'll learn exactly where to download such components, install them, and get them working for you today.
|
|
Tutorials |
|
05 Dec 2007 |
|
| |
Automation for the people: Continuous Integration anti-patterns
While Continuous Integration (CI) can be extremely effective at
reducing risks on a project, it requires a greater emphasis on your day-to-day
activities related to coding. In Part 1 of a two-part article in the Automation for the people series, automation expert and co-author of Continuous
Integration: Improving Software Quality and Reducing Risk, Paul Duvall, lays out a
series of CI anti-patterns, and more importantly, shows how to avoid them.
|
|
Articles |
|
04 Dec 2007 |
|
| |
Robots, mazes, and subsumption architecture
Robot simulators can be both serious research tools and, as IBM computer
programmer Paul Reiners shows in this article, a route to some serious fun with Java
programming. Find out how to create light-seeking and maze-navigating virtual robots in
the Java language using Simbad -- an open source robot simulator based on Java 3D technology -- to realize the robotics-design concept of subsumption architecture.
|
|
Articles |
|
04 Dec 2007 |
|
| |
Java EE 5: Power and productivity with less complexity
Momentum for organizations to adopt Java Platform, Enterprise Edition 5 (Java EE 5) is steadily increasing as the platform's container support, developer tools, educational resources, and developer-community experience all improve. Get a high-level view of the new productivity features and API enhancements in Java EE 5 and work through a Web service example that demonstrates its simplified development models.
|
|
Articles |
|
29 Nov 2007 |
|
| |
Use custom collations in XSLT 2.0
One emphasis of XSLT 2.0 is better support for internationalization, especially to sort and compare text. This article demonstrates how to write a custom collation function and invoke it from an XSLT 2.0 stylesheet.
|
|
Articles |
|
27 Nov 2007 |
|
| |
Spot defects early with Continuous Integration
Continuous Integration (or CI) is a process that consists
of continuously compiling, testing, inspecting, and deploying source code. In
many Continuous Integration environments, this means running a new build
anytime code within a source code management repository changes. The benefit
of CI is simple: assembling software often greatly increases the
likelihood that you will spot defects early, when they still are
relatively manageable. In this tutorial, a companion to his series In pursuit of code
quality, Andrew Glover introduces the fundamental aspects of Continuous Integration and steps you through how to set up a CI process using best-of-breed open source technologies.
|
|
Tutorials |
|
21 Nov 2007 |
|
| |
Web development with Eclipse Europa, Part 1: The Java EE for Eclipse
It's a good time to be a Web developer. You've never had more choices in terms
of technologies. There are so many great open source Web servers, databases,
programming languages, and development frameworks. No matter what combination of
technologies you prefer to work with, there is an integrated development
environment (IDE) that can increase your productivity: Eclipse. In this tutorial, Part
1 of a three-part "Web development with Eclipse Europa" series on how to use Eclipse
for Web development with Java technology, PHP, and
Ruby, we'll see how the latest release of Eclipse -- Europa -- can be used to rapidly
develop Java Web applications. We'll use Java Platform, Enterprise Edition 5 (Java
EE) for Eclipse to build a Web application for tracking and calculating baseball statistics.
|
|
Tutorials |
|
20 Nov 2007 |
|
| |
Data binding with Castor, Part 1: Install and set up Castor
Download, install, and configure Castor for data binding.
|
|
Articles |
|
13 Nov 2007 |
|
| |
Java theory and practice: Stick a fork in it, Part 1
One of the additions to the java.util.concurrent packages coming in Java 7 is a framework for fork-join style
parallel decomposition. The fork-join abstraction provides a natural mechanism for decomposing many algorithms to effectively exploit hardware parallelism. The next installment in this series covers the ParallelArray classes, which
simplify parallel sorting and searching operations on in-memory data structures.
|
|
Articles |
|
13 Nov 2007 |
|
| |
Automation for the people: Build Java projects with Raven
Ant is arguably the de facto build tool for the Java platform;
however, other build tools, which support a more expressive paradigm that XML lacks, are
entering the scene. In this installment of Automation for the people, automation expert Paul Duvall describes how Raven, a build platform built on top of Ruby, leverages the power of a full-featured programming language with the simplicity of a build-centric Domain Specific Language.
|
|
Articles |
|
06 Nov 2007 |
|
| |
Java EE meets Web 2.0
Web 2.0 applications developed using standard Java Platform,
Enterprise Edition 5 (Java EE)-based approaches face serious performance and scalability problems. The reason is that many principles that underlie the Java EE platform's design especially, the use of synchronous APIs don't apply to the requirements of Web 2.0 solutions. This article explains the disparity between the Java EE and Web 2.0 approaches, explores the benefits of asynchronous designs, and evaluates some solutions for developing asynchronous Web applications with the Java platform.
|
|
Articles |
|
06 Nov 2007 |
|
| |
Developing a portlet application on compliance reporting for IBM Tivoli Security Compliance Manager
This article provides an example of how to develop a portlet application on compliance reporting for IBM Tivoli Security Compliance Manager (SCM). As recent events indicate, security is a growing concern of enterprises.
Enterprises need to address security compliance with an increasing number of government and corporate security policies, standards and regulations.
|
|
Articles |
|
30 Oct 2007 |
|
| |
Make Ajax development easier with AjaxTags
Developers and users have much higher expectations for the usability and
responsiveness of Web-based applications in the Web 2.0 era. Unless you've been
living under a rock for the past two years, you've likely heard of Asynchronous
JavaScript + XML (the Ajax technique). Ajax allows you to build slick, responsive,
and highly dynamic browser-based user interfaces without requiring browser page
reloads. This article takes a look at AjaxTags, a Java/JavaScript Library that lets you easily integrate Ajax functionality into your JSP pages.
|
|
Articles |
|
23 Oct 2007 |
|
| |
Java diagnostics, IBM style, Part 4: Extending the IBM Diagnostic and Monitoring Tools for Java - Dump Analyzer with
analysis modules
In the first article in this series, you learned about the IBM Dump Analyzer
for Java, a tool that can perform analysis against a formatted system dump
and offer suggestions for problem diagnosis. One of the great advantages of this
tool is that you can extend its functionality by writing your own analysis modules.
This article wraps up this series on IBM diagnostic tooling for the Java platform by showing
you how to build analyzers that will help you plumb the depths of your system dumps
and fine-tune your Java code.
|
|
Articles |
|
23 Oct 2007 |
|
| |
The busy Java developer's guide to db4o: Structured objects and collections
Object-oriented applications make considerable use of
inheritance, and they frequently want to use that inheritance (or "is-a")
relationship to categorize and organize objects within a given system. This
can prove difficult in a relational storage scheme, which has no intrinsic
concept of inheritance, but in an OODBMS, it's a core feature. In this
installment of The busy Java developer's guide to db4o, discover the
surprising ease (and power) of using inheritance as a core feature when
creating queries in db4o.
|
|
Articles |
|
23 Oct 2007 |
|
| |
Integrate XForms with the Google Web Toolkit, Part 4: Creating interactive forms with GWT and XForms
This four-part series demonstrates how to use the Google Web Toolkit (GWT) and XForms together to create a dynamic Web application. Part 1 looks at the JavaScript
underpinnings of each technology. Part 2 shows how to use those JavaScript
underpinnings to start mixing the two technologies together to build the rock star
application. Part 3 refactors the application to use XForms and GWT together. In
this concluding part, you'll continue to refactor and improve your rock star application.
|
|
Articles |
|
16 Oct 2007 |
|
| |
Java diagnostics, IBM style, Part 3: Diagnosing synchronization and locking problems with the Lock Analyzer for Java
The IBM Lock Analyzer for Java, available from alphaWorks, provides
real-time lock monitoring on a running Java application. It highlights threads
suffering from lock contention that could be hurting application performance.
Developers can use this information to modify their applications to reduce lock
contention and thus improve performance. This article introduces the IBM Lock
Analyzer for Java, explains the architecture on which it is built, and provides some
thoughts about the tool's future direction.
|
|
Articles |
|
16 Oct 2007 |
|
| |
XML and Java technology: A return to basics
Brett McLaughlin revisits some XML basics, from document structure to the age-old attributes versus elements issue. You'll relearn how to optimize your XML and ensure it's in tip-top shape.
|
|
Articles |
|
09 Oct 2007 |
|
| |
Java diagnostics, IBM style, Part 2: Garbage collection with the IBM Monitoring and Diagnostic Tools for Java - Garbage Collection and Memory Visualizer
The IBM Monitoring and Diagnostic Tools for Java - Garbage Collection and Memory Visualizer, new tooling from IBM, is designed to
help diagnose and analyze memory-related Java performance problems. This article,
the second in a four-part series, explains how to obtain and use the toolkit and
demonstrates how you can use it to quickly diagnose some common problems.
|
|
Articles |
|
09 Oct 2007 |
|
| |
Auto-save JSF forms with Ajax: Part 3
In the first article of this series, author and Java developer Andrei
Cioroianu showed how to submit the user input of a Web form with Asynchronous
JavaScript + XML (Ajax) and how to handle the Ajax requests with JavaServer Faces
(JSF). In the second article of the series, Andrei discussed data management on the
server side and presented a data repository for keeping the auto-saved form data. In this final installment of the three-part series, you'll find out how to restore the data of a JSF form, which is trickier than you might think. You will learn interesting JSF techniques, such as using the immediate and onclick attributes of JSF components, skipping some of the phases of the JSF request processing life cycle, and using hidden form elements to trigger JSF listeners. You will also learn how to include JSP/JSF expressions within the JavaScript code, how to use JavaScript with the HTML form elements generated by the renderers of the JSF components, and how to implement a servlet context listener for serializing and deserializing application beans.
|
|
Articles |
|
09 Oct 2007 |
|
| |
Integrate XForms with the Google Web Toolkit, Part 3: Using GWT to create XForms
This four-part series demonstrates how to use the Google Web Toolkit (GWT)
and XForms together to create a dynamic Web application. Part 1 looked at the two
technologies and how both had JavaScript underpinnings. Part 2 shows how to create a
small application with two pages. One page uses GWT to show a list of artists
managed by a record company. The second page uses XForms to display the albums
recorded by a particular artist. Part 3 uses GWT and XForms on the same page. See
how to take advantage of each technology's bindings to JavaScript by using JavaScript to achieve interactivity between GWT and XForms.
|
|
Articles |
|
09 Oct 2007 |
|
| |
Java diagnostics, IBM style, Part 1: Introducing the IBM Diagnostic and Monitoring Tools for Java - Dump Analyzer
Java applications have become increasingly complex; as a
result, diagnosing problems in these applications is a non-trivial task and may
require extensive work with an external service organization. A helpful pointer in
the right direction could save both time and expense. The IBM Diagnostic and Monitoring Tools for Java - Dump Analyzer
is a tool that performs basic analysis against a formatted system dump and produces
a concise report indicating what it thinks your next course of action should be.
|
|
Articles |
|
02 Oct 2007 |
|
| |
Securing Java applications with Acegi, Part 3: Access control for Java objects
Bilal Siddiqui continues his introduction to Acegi Security
System by showing you how to secure access to instances of your Java classes. Learn
why you need to secure access to your Java classes, how Spring creates and secures
instances of your Java classes, and how to configure Acegi to incorporate class
security in your Java applications.
|
|
Articles |
|
25 Sep 2007 |
|
| |
Integrate XForms with the Google Web Toolkit, Part 2: Creating an artist and album management form
This four-part series demonstrates how to use the Google Web Toolkit (GWT) and XForms together to create a dynamic Web application. Part 1 looked at the JavaScript underpinnings of each technology. Part 2 shows you how to use those JavaScript underpinnings to start mixing the two technologies together to build the rock star application.
|
|
Articles |
|
25 Sep 2007 |
|
| |
Monitor and diagnose performance in Java SE 6
Java Platform, Standard Edition 6 (Java SE) focuses on performance, with expanded tools for managing and monitoring applications as well as diagnosing common problems. This article outlines the basis of monitoring and management in the Java SE platform and provides detailed information about the relevant enhancements in Java SE 6.
|
|
Articles |
|
25 Sep 2007 |
|
| |
Design and develop JAX-WS 2.0 Web services
Using Java API for XML Web Services (JAX-WS) technology to design and
develop Web services yields many benefits, including simplifying the construction of
Web services and Web service clients in Java, easing the development and deployment
of Web services, and speeding up Web services development. This tutorial walks you
through how to do all of this and more by developing a sample order-processing
application that exposes its functionality as Web services. After going through this
tutorial, you'll be able to apply these concepts and your newly acquired knowledge
to develop Web services for your application using JAX-WS technology.
|
|
Tutorials |
|
20 Sep 2007 |
|
| |
Auto-save JSF forms with Ajax: Part 2
In the first part of this "Auto-save JSF forms with Ajax" series, author and
Java developer Andrei Cioroianu showed you how to build Java applications that
automatically save Web forms, using Asynchronous JavaScript + XML (Ajax) and
JavaServer Faces (JSF) technologies. You learned how to obtain, encode, and submit
form data with JavaScript and XMLHttpRequest, how to adapt the JSF request
processing life cycle for handling Ajax requests, and how to get the submitted data
from the JSF component tree on the server side. In this second installment of the
three-part series, you will see how to identify anonymous users across browser
sessions, how to manage the auto-saved form data for multiple users and pages, how
to choose a data repository, and how to deal with thread-safety issues.
|
|
Articles |
|
18 Sep 2007 |
|
| |
Integrate XForms with the Google Web Toolkit, Part 1: Introducing GWT's JavaScript Native Interface
This four-part series demonstrates how to use the Google Web Toolkit (GWT) and XForms together to create a dynamic Web application. Part 1 starts with a bottom-up approach to the problem of using GWT and XForms together. It takes a look at some of the underpinnings of each technology, examining the common ground between them that will allow for their peaceful coexistence. This will lay the foundation for developing a Web application that uses both GWT and XForms together.
|
|
Articles |
|
18 Sep 2007 |
|
| |
The busy Java developer's guide to db4o: Arrays and collections
Collections and arrays introduce new levels of complexity to
the structured objects first discussed in The busy Java developer's guide to db4o: Beyond
simple objects. Fortunately, db4o isn't the least
bit fazed by handling multiplicity relationships -- and neither should you be.
|
|
Articles |
|
18 Sep 2007 |
|
| |
In pursuit of code quality: Adventures in behavior-driven development
Test-driven development (TDD) is a great idea in practice, but some developers just
can't get over the conceptual leap associated with that word test. In this
article, learn about a more natural way to integrate the momentum of TDD
into your programming practice. Get started with behavior-driven development (BDD) (via
JBehave) and see for yourself what happens when you focus on program behaviors, rather
than outcomes.
|
|
Articles |
|
18 Sep 2007 |
|
| |
Tackle WS-Security specification interoperability challenges, Part 4: Add a J2EE 1.3 provider endpoint to a J2EE 1.4 Web service
The first few installments in this article series offered workarounds for
Web Services Security (WS-Security) specification-level interoperability
problems--specifically, incompatibilities between different versions of WS-Security
preventing a Java 2 Platform, Enterprise Edition (J2EE) 1.3 client from
communicating with a J2EE 1.4 Web services provider when WS-Security is required.
Now find out how adding a new Web service provider endpoint can overcome this
interoperability problem.
|
|
Articles |
|
13 Sep 2007 |
|
| |
Manipulate XML service definitions with Java programming
A Service-Oriented Architecture (SOA) typically exports a range of services. For XML
service modelling and subsequent consumption of those services by users (people, machines,
or other services), Java technology provides powerful mechanisms to handle XML data,
which in turn provides a key foundation for using SOA concepts. Dive into the practical
aspects of SOA using XML and Java technology, and discover clear examples of why this
seemingly complex technology is so popular.
|
|
Articles |
|
11 Sep 2007 |
|
| |
Developing embedded applications with eJFace
It is safe to assume the demand for applications on mobile devices will increase
in coming years. Now is a good time to learn eJFace -- the open-standards, embedded JFace
library -- a new technology to build embedded applications. Embedded JFace (eJFace) is a component of
the embedded Rich Client Platform (eRCP), which provides an embedded environment for
developers to compose user interfaces (UIs) for embedded applications. Here, we compare
eJFace to JFace and show how to develop applications with eJFace.
|
|
Articles |
|
11 Sep 2007 |
|
| |
XML and Java technology: XML persistence in three flavors
You can do all sorts of interesting things with XML, but if you can't persist it to a file, it's all for naught. Brett McLaughlin discusses different tactics for XML persistence, and the pros and cons of each.
|
|
Articles |
|
11 Sep 2007 |
|
| |
Use HashMap for better multithreaded performance
The typical way of enabling multiple threads to share access to a
read-write map -- synchronizing on access to the map -- can
become a performance bottleneck. Learn a technique you can use in Java 1.5 and
later to minimize this bottleneck for maps that are read frequently but updated infrequently.
|
|
Articles |
|
11 Sep 2007 |
|
| |
Invoke dynamic languages dynamically, Part 2: Find, execute, and change scripts at run time
The Java scripting API added in Java SE 6 and backward
compatibility with Java SE 5 allows dozens of scripting languages to be called at run time
from a Java application in a simple, unified way. Part 1 of
this two-part article introduces the API's basic features. Part 2 exposes more of its
power, demonstrating how external scripts written in Groovy, JavaScript, and Ruby can
be executed and altered at run time to change business logic without stopping and
restarting the application.
|
|
Articles |
|
11 Sep 2007 |
|
| |
Build grid-ready apps with ObjectGrid
ObjectGrid is a part of the WebSphere Extended Development Data Grid
offering, but you can you install it as a standalone package as well. Learn the basics of installing and using this in-memory database
for your Java applications. You'll see how to set it up to use one or more machines,
and then walk through a series of sample applications that demonstrate its
capabilities.
|
|
Tutorials |
|
04 Sep 2007 |
|
| |
Invoke dynamic languages dynamically, Part 1: Introducing the Java scripting API
You don't need to compile dynamic languages into Java bytecode to use them with a Java application. Dozens of scripting languages can be
called at run time from Java code in a simple, unified way using the scripting package
added to Java Platform, Standard Edition 6 (Java SE) and backward compatible with Java SE 5. Part 1 of this two-part article introduces the Java scripting API's features. It uses a simple Hello World application to show how Java code can execute scripting code and how scripts can in turn execute Java code. Part 2 dives deeper into the power of the Java scripting API.
|
|
Articles |
|
04 Sep 2007 |
|
| |
Coordinate conversions made easy
Applications offering location-based services are all the rage, but how can a
computer identify a location in the real world? There are several ways to answer that
question, but they all involve a geographic coordinate system, and there are several
such systems in use. In this article, application architect Sami Salkosuo offers
Java code that converts location data between two popular systems: the familiar system of longitude and
latitude and the Universal Transverse Mercator system.
|
|
Articles |
|
28 Aug 2007 |
|
| |
Develop with Java and PHP technology on AIX Version 5.3, Part 5: Installing and integrating the PHP Java Bridge
It is possible to develop applications that employ both Java(TM) and PHP
technology on AIX(R). Part 5 of this six-part series teaches you how to install, set
up, and integrate the PHP Java Bridge into the Tomcat application server, making you
all set for developing a PHP Web interface.
|
|
Articles |
|
21 Aug 2007 |
|
| |
Determining performance problems with DB2 Java applications
Diagnose and isolate performance problems from the application client perspective. Learn how to troubleshoot performance problems that occur with Java applications running against IBM DB2 for Linux, UNIX, and Windows databases. Once you understand the source of your performance issues, you'll be on the path to a solution.
|
|
Articles |
|
16 Aug 2007 |
|
| |
Mylyn 2.0, Part 1: Integrated task management
Now in release 2.0, Mylyn (formerly called Mylar) enhances productivity by seamlessly integrating tasks into Eclipse and automatically managing the context of those tasks as you work. Mylyn Project Lead Mik Kersten has updated his two-part guide to using Mylyn to cover the improvements driven by the massive amounts of user feedback since Mylyn 1.0. Part 1 introduces Mylyn's task management facilities and integration with repositories such as Bugzilla, Trac, and JIRA. You'll learn how context management eases multitasking and reduces information overload in Part 2.
|
|
Articles |
|
14 Aug 2007 |
|
| |
Mylyn 2.0, Part 2: Automated context management
Now in release 2.0, Mylyn (formerly called Mylar) enhances productivity by seamlessly integrating tasks into Eclipse and automatically managing the context of those tasks as you work. Mylyn Project Lead Mik Kersten has updated his two-part guide to using Mylyn. Part 1 introduces Mylyn's task management facilities and integration with repositories such as Bugzilla. This second half explains how Mylyn's context management facilities make multitasking easy and reduce information overload when you're working on large applications in Eclipse.
|
|
Articles |
|
14 Aug 2007 |
|
| |
Auto-save JSF forms with Ajax: Part 1
In this three-part series, author and Java developer Andrei Cioroianu shows you how to automatically save form data in a Java Web application using Asynchronous JavaScript + XML (Ajax) and JavaServer Faces (JSF) technologies. You'll learn how to submit Web forms with Ajax, how to use the JSF framework to handle Ajax requests, how to control the JSF request processing life cycle, how to manage form data on the server side, and how to identify anonymous users across browser sessions. Discover several frequently occurring development mistakes, including incorrect form-data encoding and improper Ajax request management, which can lead to failed requests and memory leaks.
|
|
Articles |
|
07 Aug 2007 |
|
| |
Rich-client application performance, Part 2: Plugging memory leaks
Part 1 of this two-part article on Eclipse rich-client performance covers the basics of measuring an application's performance, applying instrumentation techniques, keeping the UI responsive, and using Jobs to avoid threading mistakes. This second part takes a look at memory usage and how to chase down memory leaks.
|
|
Articles |
|
07 Aug 2007 |
|
| |
Rich-client application performance, Part 1: Tools, techniques, and tips for analyzing performance
Significant performance issues are likely to arise even in well-planned
applications. In this two-part article, Chris Grindstaff offers techniques for analyzing
and addressing performance problems. In this first installment, you'll learn how to
measure the performance of Eclipse-based Rich Client Platform (RCP) applications,
determine if slowdowns are caused by CPU or I/O bottlenecks, and keep the UI thread idle
to maintain responsiveness. Part 2 addresses memory problems.
|
|
Articles |
|
31 Jul 2007 |
|
| |
Java Web Services: Axis2 Data Binding
The Apache Axis2 Web services framework was designed from the start to
support multiple XML data-binding approaches. The current release provides full
support for XMLBeans and JiBX data binding, as well as the custom Axis Data Binding
(ADB) approach developed specifically for Axis2. This article shows you how to use
these different data bindings with Axis2 and explains why you might prefer one over
the others for your application.
|
|
Articles |
|
26 Jul 2007 |
|
| |
Java Web Services: Axis2 Data Binding
The Apache Axis2 Web services framework was designed from the start to
support multiple XML data-binding approaches. The current release provides full
support for XMLBeans and JiBX data binding, as well as the custom Axis Data Binding
(ADB) approach developed specifically for Axis2. This article shows you how to use
these different data bindings with Axis2 and explains why you might prefer one over
the others for your application.
|
|
Articles |
|
26 Jul 2007 |
|
| |
Maximize your Mac OS X Java development experience using Eclipse
Mac OS X is a powerful platform for Java development. While the Java development
environment is fully integrated into Mac OS X, the Eclipse integrated development
environment (IDE) brings a fully
integrated Java development environment to Mac OS X that provides a consistent
cross-platform experience. Discover how to use this environment to import existing
Xcode projects into Eclipse, tweak key bindings, and integrate Eclipse with the
Mac OS X-bundled Concurrent Versions System (CVS).
|
|
Articles |
|
24 Jul 2007 |
|
| |
In pursuit of code quality: Unit testing Ajax applications
You might get a thrill
out of writing Ajax applications, but unit testing them is surely painful. In this
article, Andrew Glover takes on the downside of Ajax (one of them, anyway), which is the
inherent challenge of unit testing asynchronous Web applications. Fortunately, he finds
it easier than expected to tame this particular code quality dragon, with the help of the Google Web Toolkit.
|
|
Articles |
|
24 Jul 2007 |
|
| |
Easing configuration
Configuration can be a maintenance mess and add to a developer's burden. This article introduces a framework with which developers can define their
application's configuration in terms of high-level interfaces; the framework then
generates automatic implementations of these interfaces backed by a physical
configuration source, like a properties file or database. Because the interfaces
define the configuration fields, these fields can be accessed much more
easily; this technique also provides type safety and supports automatic
documentation by Javadoc. This approach, designed and detailed by Merlin Hughes, is intended to improve on the practices of using string constants and manual type conversion when handling configuration data, while maintaining compatibility with existing configuration tools and files.
|
|
Articles |
|
24 Jul 2007 |
|
| |
Avoid the dangers of XPath injection
With the proliferation of simple XML APIs, Web services, and Rich Internet Applications (RIAs), more organizations have adopted XML as a data format for everything from configuration files to remote procedure calls. Some people have even used XML documents instead of more traditional flat files or relational databases, but like any other application or technology that allows outside user submission of data, XML applications can be susceptible to code injection attacks, specifically XPath injection attacks.
|
|
Articles |
|
17 Jul 2007 |
|
| |
Build a custom static parser plugin for LTA-JD
The huge amount of data to analyze after system failures poses the initial difficulty
in problem determination -- this is especially true when the failures are related to
concurrent usage and stress. The Log Trace Analyzer for Java Desktop (LTA-JD) is a
powerful tool for problem determination and analysis once the text logs are properly
extracted as Common Base Events. But what's the easiest way to extract, say, Java
Virtual Machine (JVM) logs from the WebSphere Application Server (WAS) so they can be used by the LTA-JD? This
article introduces the design of a custom static parser as a plugin for LTA-JD to
construct a meaningful, common language from the plain text WebSphere Application Server JVM logs.
|
|
Articles |
|
17 Jul 2007 |
|
| |
Ajax for Java developers: Write scalable Comet applications with Jetty and Direct Web Remoting
Ajax applications driven by asynchronous server-side events can be tricky to implement and difficult to scale. Returning to his popular series, Philip McCarthy shows an effective approach: The Comet
pattern allows you to push data to clients, and Jetty 6's Continuations API lets your
Comet application scale to a large number of clients. You can conveniently take advantage
of both Comet and Continuations with the Reverse Ajax technology in Direct Web Remoting
(DWR) 2.
|
|
Articles |
|
17 Jul 2007 |
|
| |
Boost application development with Amazon Web Services, Part
3: Amazon Simple Queue Service
Using the Amazon Simple Queue Service (SQS), you can build
distributed applications that communicate using a message-based paradigm. Cell
phones and other Java Platform, Micro Edition (Java ME) devices can use
Amazon SQS easily with simple HTTP requests. In this tutorial, the third in a
series on creating applications with Amazon Web Services (AWS), discover how to
use SQS from a Java ME device.
|
|
Tutorials |
|
12 Jul 2007 |
|
| |
XML and Java technology: Sun's Java and XML APIs: Helping or hurting?
Brett McLaughlin sparks discussion on the role of Sun in wrapping, expanding, and possibly hurting the various Java and XML APIs currently available.
|
|
Articles |
|
10 Jul 2007 |
|
| |
Automation for the people: Asserting architectural soundness
Is your software architecture what you think it is? The designs we
communicate to each other aren't always what we expect when it comes to source code. Paul Duvall returns from his hiatus in this installment of Automation for the people to demonstrate how you can discover architectural deviations by writing tests using JUnit, JDepend, and Ant to discover problems proactively instead of long after the fact.
|
|
Articles |
|
10 Jul 2007 |
|
| |
Implementing Hamlets
The Hamlet framework was developed to extend Java servlets and enforce the separation of content from presentation. In this article, you'll find an additional way to provide dynamic content as Rene Pawlitzek advances the framework further and refines use of the template engine.
|
|
Articles |
|
03 Jul 2007 |
|
| |
Real-time Java, Part 6: Simplifying real-time Java development
Now that real-time Javavirtual machines support
scoped memory, defining common patterns for scoped memory usage can improve developer
productivity. These patterns reduce the need to understand or work with scopes directly
by providing scopes' core functions with less complexity. This article, the sixth and
last in the Real-time Java series, introduces the Lifecycle Memory Managed Periodic Worker Threads pattern as a model for simplifying real-time Java development. It demonstrates the pattern's feasibility through a sample implementation and simple example application.
|
|
Articles |
|
03 Jul 2007 |
|
| |
The busy Java developer's guide to db4o: Beyond simple objects
So
far, creating objects and manipulating them in db4o looks pretty easy -- maybe a
little too easy, in fact. In this article, db4o enthusiast Ted Neward shows you what
happens when simple objects become structured ones (that is, objects that reference objects) and issues like infinite recursion, cascading behavior, and referential integrity come into play.
|
|
Articles |
|
26 Jun 2007 |
|
| |
The Geronimo renegade: What's new in OpenEJB 3.0
The Java 2 Platform, Enterprise Edition (J2EE) specification made Java technology the
premier technology for enterprise application development. It has evolved over the
years to maintain that position, especially with the Java Platform, Enterprise Edition 5 (Java
EE 5) specification. OpenEJB has been an integral part of Geronimo since its
inception. Its 3.0 release is a key part of Geronimo's implementation of the Java EE
5 specification. In this installment, the renegade uncovers the driving forces
behind Enterprise JavaBeans (EJB) 3 and how OpenEJB has stepped up to provide bold new features to Geronimo.
|
|
Articles |
|
26 Jun 2007 |
|
| |
Simplify Ajax development using Cypal Studio for GWT
Using the Google Web Toolkit (GWT), a Java programmer can write rich Asynchronous JavaScript + XML (Ajax) applications completely
in the Java programming language. Cypal Studio for GWT, designed for the Eclipse IDE, provides support for managing GWT constructs.
Learn how Cypal Studio for GWT helps create new GWT modules, supports the creation of remote procedure calls, and makes it easy to view
and deploy your Web applications.
|
|
Articles |
|
19 Jun 2007 |
|
| |
Embedding Hamlets
The open source Hamlets framework can help aid your Web development and properly separate content from presentation. The OSGi framework provides an excellent tool for development on embedded devices. Together, the two frameworks work as a team to provide browser-based interactivity to the humblest gadgets -- such as the lowly coffee maker. Read on to find out how it works.
|
|
Articles |
|
19 Jun 2007 |
|
| |
Develop with Java and PHP technology on AIX Version 5.3, Part 3: Integrating the Java business application with DB2 Version 9
It is possible to develop applications that employ both Java(TM) and PHP
technology on AIX(R). You can use the Java programming language for the core logic
(or redeploy an existing Java-based application), while gaining the benefits of PHP
as a Web-based interface platform. In this article, the third of the series, find
out how to connect the core application created in the second installment to a
DB2(R) database for the storage of the survey questions and responses.
|
|
Articles |
|
19 Jun 2007 |
|
| |
Complex analytical querying with JOLAP
Shashank Tiwari offers a look at JOLAP, a promising
specification that supports creating and maintaining On Line Analytical Processing (OLAP) data and
metadata on the Java enterprise platform.
|
|
Articles |
|
19 Jun 2007 |
|
| |
Java theory and practice: Managing volatility
The Java language contains two intrinsic
synchronization mechanisms: synchronized blocks (and methods) and
volatile variables. Both are provided for the purpose of rendering
code thread-safe. Volatile variables are the weaker (but sometimes
simpler or less expensive) of the two -- but also easier to use
incorrectly. In this installment of Java theory and practice,
Brian Goetz explores some patterns for using volatile variables correctly
and offers some warnings about the limits of its
applicability.
|
|
Articles |
|
19 Jun 2007 |
|
| |
Seamless JSF, Part 3: Ajax for JSF
JSF's component-based methodology encourages abstraction,
but most Ajax implementations interfere with it by exposing the
underlying HTTP exchange. In this final article in the Seamless JSF series, Dan Allen shows you how to use the
Seam Remoting API and Ajax4jsf components to communicate with managed beans on
the server as if they were local to the browser. You'll learn how surprisingly
easy it is to leverage Ajax as a natural improvement on JSF's event-driven
architecture and how to do so without compromising the JSF component model.
|
|
Articles |
|
12 Jun 2007 |
|
| |
Real-time Java, Part 5: Writing and deploying real-time Java
applications
This article, the fifth in a six-part series about real-time Java, shows how to write and deploy real-time Java applications using the tools provided with IBM WebSphere Real Time. Using sample applications, the authors demonstrate the Metronome garbage collector for controlling garbage-collection pauses, the Ahead-of-time compiler for avoiding run-time compilation pauses, and NoHeapRealtimeThreads for meeting the most stringent timing requirements.
|
|
Articles |
|
12 Jun 2007 |
|
| |
Search smarter with Apache Solr, Part 2: Solr for the enterprise
Lucene Java committer Grant Ingersoll rounds out his introduction to Solr with a survey of its features for the enterprise, including administration interfaces, advanced configuration options, and performance features such as caching, replication, and logging.
|
|
Articles |
|
05 Jun 2007 |
|
| |
XML and Java technology: Low-level or high-level XML APIs?
Brett McLaughlin details some of the core XML APIs, and muses about whether developers are getting the most out of their Java and XML programming.
|
|
Articles |
|
29 May 2007 |
|
| |
Securing Java applications with Acegi, Part 2: Working with an LDAP directory server
With the basics out of the way, you're ready to discover the more advanced
uses of Acegi Security System. In this article, Bilal Siddiqui shows you how to
combine Acegi with an LDAP directory server for flexible, high performance Java
application security. Learn how to write an access control policy and store it in
ApacheDS, and then configure Acegi to interact with the directory server for
authentication and authorization purposes.
|
|
Articles |
|
29 May 2007 |
|
| |
Search smarter with Apache Solr, Part 1: Essential features and the Solr schema
Solr is an enterprise-ready, Lucene-based search server
that supports faceted searching, hit highlighting, and multiple output
formats. In this two-part article, Lucene Java committer Grant Ingersoll
introduces Solr and shows you how to easily incorporate its impressive full-text search functionality into your Web applications.
|
|
Articles |
|
29 May 2007 |
|
| |
Using Rational Application Developer V7 to
create and deploy JSR 168 cooperative portlets
Learn about the cooperative portlet tools available in IBM Rational Application Developer V7 while you create a simple cooperative application and deploy it onto an IBM WebSphere Portal 6.0 server. The focus is on JSR 168 JavaServer Faces portlets, but the authors also briefly discuss Basic and Struts portlets.
|
|
Articles |
|
29 May 2007 |
|
| |
Unit testing the Eclipse way
Does your legacy code demand a matching test suite of classes to run against its source code base? For such purposes, jMock qualifies
as a great testing framework. However, not all cases may suit the occasion, especially when you must construct objects in a manner that jMock
doesn't expect. To avoid the hassle of producing suites of custom mock objects to support the unit tests in an application, you can tailor RMock to
work with jMock seamlessly to achieve a positive result.
|
|
Articles |
|
29 May 2007 |
|
| |
Signing, encrypting, and decrypting Atom
Atom is a
great format for relaying information, but what about security concerns? XML Digital Signatures can ensure that data comes from a trusted party and that it is unaltered, and XML Encryption can obscure sensitive information from prying eyes. But how can you use these technologies without destroying Atom structures? This article shows you how digital signatures and encryption can easily mesh with Atom data using the Apache Abdera API.
|
|
Articles |
|
22 May 2007 |
|
| |
The busy Java developer's guide to db4o: Database refactoring with db4o
Refactoring Java code is far simpler than refactoring a relational database, but fortunately that isn't so much the case with object databases. In this installment of The busy Java developer's guide to db4o, Ted Neward introduces you to yet another advantage of his favorite object database: db4o simplifies refactoring to the point where it's almost trivial.
|
|
Articles |
|
22 May 2007 |
|
| |
Performance tuning Subversion
Subversion is one of the few version control systems that can
store binary files using a delta algorithm. Unfortunately, users have discovered that
doing so results in a significant performance hit. In this article, senior developer David
Bell explains why Subversion's performance suffers when handling binaries and suggests several ways to work around the problem.
|
|
Articles |
|
22 May 2007 |
|
| |
In pursuit of code quality: Beware the tight couple!
You know tight coupling is bad news and you really want
to avoid it in your designs -- but the question is how. This month, learn
how to recognize a tightly coupled system and then disentangle it using the
Dependency Inversion Principle.
|
|
Articles |
|
22 May 2007 |
|
| |
Building Google gadgets, Part 2: Working with the user interface
Part 2 of the "Building Google gadgets" series introduces the advanced features
of gadgets, including creating a tabbed user interface, drag and drop, and MiniMessages,
and gets you started creating your own.
|
|
Tutorials |
|
22 May 2007 |
|
| |
Report Data Analyzer: Interpret EWLM performance data
As a workload manager (and not a capacity planning tool), the IBM Enterprise
Workload Manager focuses on real-time data and, thus, only retains performance data
covering the past 24 hours. There was a customer requirement, however, to have this data
available for later analysis. And so, the Data Hardening plug-in was added. This plug-in
allows on-the-fly dumping of performance data onto the file system. But, the
dumped data can't be directly exploited: Enter EWLM Report Data Analyzer.
|
|
Articles |
|
15 May 2007 |
|
| |
Simplify Eclipse classpaths using classpath containers
Eclipse classpath containers are an organized, user-friendly way to manage Java libraries in Eclipse. Since a group of libraries can be referenced as one abstract name, they can be removed and added as a single entry easily. The view of the libraries is also simplified in the Java Perspective as a single entry that can be expanded to view the entire set. Since the set of libraries is defined by an implementation of IClasspathContainer, it can be redefined dynamically. This tutorial shows how to implement a custom IClasspathContainer with accompanying extensions of classpathContainerInitializer and classpathContainerPage.
|
|
Tutorials |
|
08 May 2007 |
|
| |
Real-time Java, Part 4: Real-time garbage collection
Nondeterministic pauses in traditional garbage collection (GC) have inhibited Java technology from being a suitable environment for real-time (RT) development. Metronome GC -- part of IBM WebSphere Real Time -- provides deterministic GC behavior that, when combined with other features, enables developers to write hard RT applications in the Java language. The authors describe the approach that Metronome uses for deterministic GC, technical issues involved in developing Metronome, and the tools and facilities available for tuning GC.
|
|
Articles |
|
02 May 2007 |
|
| |
Seamless JSF, Part 2: Conversations with Seam
Put Seam's annotations and conversation scope to the test -- use
them to build a simple, stateful CRUD application.
|
|
Articles |
|
01 May 2007 |
|
| |
Java theory and practice: The closures debate
Everyone has a favorite feature idea or two for adding
to the Java language. With the open-sourcing of the Java
platform and the rise in popularity of other languages for
server-side applications (JavaScript and Ruby, to name two), the
debate over the future of the Java language has never been more
vigorous. Should the Java language embrace major new additions,
such as closures? Or is that too much messing with a good thing? In this month's Java theory and practice, Brian Goetz reviews the concepts involved and provides details on the two competing closures proposals.
|
|
Articles |
|
24 Apr 2007 |
|
| |
Building Google gadgets, Part 1: Fundamentals of Google gadgets
In this new Web development series, learn how to develop Google gadgets. Gadgets are small applications that you can add to most any Web page as a means to offer dynamic and rich content. Google has an abundance of gadgets to choose from. However, the most intriguing aspect of gadgets is that you can write them for your own use and then publish them on Google, where other developers can integrate your work into their Web projects.
|
|
Tutorials |
|
24 Apr 2007 |
|
| |
Take a legacy path to advanced GWT controls
The Google Web Toolkit (GWT) provides libraries and tools that let you develop Ajax applications in the Java programming language. Unfortunately, GWT's standard gallery of UI controls (widgets) doesn't provide the advanced features that modern enterprise applications require. This article shows a technique that addresses this deficiency. Find out how to give GWT controls advanced functionality with relatively simple coding by integrating a popular JavaScript grid component with a GWT application.
|
|
Articles |
|
24 Apr 2007 |
|
| |
Real-time Java, Part 3: Threading and synchronization
This article, the third in a six-part series on real-time Java, examines aspects of threading and synchronization that an implementation of the Real-time Specification for Java (RTSJ) must support. You'll also learn about related threading and synchronization concerns that are essential to keep in mind when you develop and deploy real-time applications.
|
|
Articles |
|
24 Apr 2007 |
|
| |
Use IBM OmniFind Yahoo! Edition REST APIs
Learn how you can easily access a freely downloadable search engine, IBM OmniFind Yahoo! Edition, from your custom applications.
|
|
Articles |
|
19 Apr 2007 |
|
| |
Seamless JSF, Part 1: An application framework tailor-made for JSF
JavaServer Faces (JSF) is the first standardized user
interface framework for Java Web applications. Seam is a powerful
application framework that extends JSF. Discover the strong chemistry that these two frameworks share in this
first article of a new three-part series. Dan Allen introduces Seam's
enhancements to the JSF life cycle, including contextual state management,
RESTful URLs, Ajax remoting, proper exception handling, and convention over
configuration.
|
|
Articles |
|
17 Apr 2007 |
|
| |
Ruby on Rails and XML
You've very likely heard of Ruby on Rails. Maybe you've actually used it; perhaps it is your new programming mistress. Whatever the case, it looks like Rails is here to stay, and to everyone's benefit. Ruby plays very nicely with XML -- read further for the details.
|
|
Tutorials |
|
17 Apr 2007 |
|
| |
Developing with Apache Derby -- Hitting the Trifecta: Java database development with Apache Derby, Part 4
Learn about SQL cursors and how you can use them to perform dynamic data
modification in an Apache Derby database. You can use SQL cursors both explicitly by
using the ij tool or implicitly by calling the appropriate Java methods. By
mastering this functionality, you can write Java applications that can selectively
modify data for your business applications.
|
|
Articles |
|
17 Apr 2007 |
|
| |
Real-time Java, Part 2: Comparing compilation techniques
This article, the second installment in a six-part series on real-time Java, looks at some of the issues involved in native code compilation for the Java language. Neither dynamic (Just-in-time) nor static (Ahead-of-time) compilation alone can meet the requirements for all Java applications. The authors compare the two compilation technologies in various execution environments and show how they complement each other's strengths.
|
|
Articles |
|
17 Apr 2007 |
|
| |
Use XML to develop with the Google Web Toolkit
The Google Web Toolkit enables you to use Java(TM) syntax to create the JavaScript(TM) necessary for Asynchronous JavaScript + XML (Ajax) user interfaces. Most of these Ajax applications use XML to transfer information to and from the server, so your application must be able to both parse and create XML data. This tutorial shows you how to manipulate and create XML using the Google Web Toolkit.
|
|
Tutorials |
|
10 Apr 2007 |
|
| |
Crossing borders: A Rails case study
Ruby on Rails development and Java development differ in fundamental ways. In this final installment of Crossing borders, Bruce Tate outlines the major differences he's discovered by using Rails to develop a complex, scalable Web site from the ground up.
|
|
Articles |
|
10 Apr 2007 |
|
| |
Build Web apps with ThinWire and Java code, Part 5: Page switching
Part 5 of the "Build Web apps with ThinWire and Java code" series explores a methodology for separating your ThinWire and Java Web site into multiple pages, providing the ability for your clients to switch among those pages using either direct pointer links or sequential page access.
|
|
Tutorials |
|
10 Apr 2007 |
|
| |
Real-time Java, Part 1: Using Java code to program real-time systems
This article describes the key challenges to using the Java language to develop systems that meet real-time performance requirements. It presents a broad overview of what real-time application development means and how runtime systems must be engineered to meet the requirements of real-time applications. The authors introduce an implementation that addresses real-time Java challenges through a combination of standards-based technologies.
|
|
Articles |
|
10 Apr 2007 |
|
| |
Develop and deploy Apache Pluto portal applications on Apache Geronimo
Even though preintegrated portal server support is missing from Apache Geronimo's feature set, you can still use Geronimo as a testing and deployment environment for portal applications. This article takes you step by step through deployment of the Apache Pluto driver and container in Geronimo to give you a 100% open source environment for your portal applications. Then learn how to develop, deploy, and test a sample portal application in Pluto and Geronimo.
|
|
Articles |
|
10 Apr 2007 |
|
| |
Muse and WEF eases event reporting
The Web Services Distributed Management (WSDM) Event Format (WEF) is an OASIS standard that describes how to serialize events related to systems management in XML. The standard goes into detail about required values, optional values, and the semantics of both, but it offers no instruction for actually implementing the system. Fortunately, the Apache Muse project has an implementation of WEF that lets you create, send, and receive WEF events using a simple Java API. This article shows you how to handle these tasks from within an Apache Muse application.
|
|
Articles |
|
03 Apr 2007 |
|
| |
In pursuit of code quality: Programmatic testing with Selenium and TestNG
Selenium is a testing framework that makes it easy to run user acceptance tests on your Web applications. This month, Andrew Glover shows you how to run Selenium tests programmatically, using TestNG as the test driver. Once you've added TestNG's flexible testing features (including parametric fixtures) to Selenium's native toolkit, all you need is a little help from DbUnit and Cargo to write fully automated, logically repeatable acceptance tests.
|
|
Articles |
|
03 Apr 2007 |
|
| |
Securing Java applications with Acegi, Part 1: Architectural overview and security filters
This series introduces Acegi Security System, a formidable open
source security framework for Java enterprise applications. In this first article,
consultant Bilal Siddiqui introduces you to the architecture and components of Acegi
and shows you how to use it to secure a simple Java enterprise application.
|
|
Articles |
|
27 Mar 2007 |
|
| |
The busy Java developer's guide to db4o: Queries, updates, and identity
Whereas the RDBMS uses SQL as its principal mechanism for
finding and retrieving data, an OODBMS can use one of several different
mechanisms. In this second installment of his series, Ted Neward introduces a few of the options, including Query by
Example and custom mechanisms unique to the OODBMS. As he explains, some
of the alternatives can be easier to use than SQL itself.
|
|
Articles |
|
27 Mar 2007 |
|
| |
Transform Java classes into Web services using Axis2 and JiBX, Part 2: Turn your XML into a fully functional Web service
XML is powerful in that it can be used to define just about anything. What's more, it is the basis for an externally readable format for a majority of applications, most notably for the purposes of this series, Axis2 and JiBX. On top of that, as Web services become more and more ubiquitous, turning your legacy Java(TM) projects into full-fledged Web services is increasingly becoming a priority. Unlike in the past when the automatic generation of Web services was limited to a service and a single class, developers now have the option to generate a service or multiple services from the various Java classes in their existing projects. This article, the second part in a series of 2, uses Axis2 and JiBX to go from XML to a fully functional Web service from existing Java classes.
|
|
Articles |
|
22 Mar 2007 |
|
| |
Transform Java classes into Web services using Axis2 and JiBX, Part 1: Use XML to define a Web service from your Java classes
XML is powerful in that it can be used to define just about anything. What's more, it is the basis for an externally readable format for a majority of applications, most notably for the purposes of this series, Axis2 and JiBX. On top of that, as Web services become more and more ubiquitous, turning your legacy Java(TM) projects into full-fledged Web services is increasingly becoming a priority. Unlike in the past, when the automatic generation of Web services was limited to a service and a single class, developers now have the option to generate a service or multiple services from the various Java classes in their existing projects. This article, Part 1 of a two-part series, uses XML to define a Web service from existing Java classes.
|
|
Articles |
|
20 Mar 2007 |
|
| |
The busy Java developer's guide to db4o: Introduction and overview
This first article in a multipart series introduces db4o and explains why it has become an important alternative to today's relational databases.
|
|
Articles |
|
20 Mar 2007 |
|
| |
SSL on ISC, Part 1: What is SSL and why should I care?
Achieve data security over open communications channels with Secure Sockets Layer (SSL), which provides encryption, certificate-based authentication, and security negotiations. This article, part one of a three-part series, describes SSL and explains why you should implement it on your Integrated Solutions Console. In parts two and three, follow a step-by-step guide to learn how to implement SSL on the Integrated Solutions Console versions 5.1 and 6.0.1, respectively.
|
|
Articles |
|
20 Mar 2007 |
|
| |
Build Web apps with ThinWire and Java code, Part 4: Write a template class
ThinWire is an open source development framework that lets you build Web applications that look and feel like desktop applications. This five-part series explores how to develop rich Web applications using ThinWire and Java programming. In this installation, learn how to write a template class that defines one of the most commonly used Web page layouts.
|
|
Tutorials |
|
13 Mar 2007 |
|
| |
Crossing borders: Extensions in Rails
The Java programming language has long been a great melting pot, with rich and powerful capabilities for integration -- from dependency-injection containers for integrating enterprise libraries, to Enterprise JavaBeans (EJB) technology, to the component models for Eclipse. With so many ideas and architectures available, Java developers pioneer new ways to weave disparate software libraries and components into a cohesive whole. But Java developers don't have a monopoly on good integration techniques. See how Ruby on Rails plug-ins work by looking at a popular plug-in called.
|
|
Articles |
|
13 Mar 2007 |
|
| |
Automation for the people: Continuous testing
Ready to step up to the plate and hit a home run with your developer testing activities? In this installment of Automation for the people, development automation expert Paul Duvall covers some of the various types of automated developer tests you can run with every source code change. Paul provides examples of Selenium, DbUnit, and JUnitPerf tests that can help you discover application problems early -- that is, if they're run often.
|
|
Articles |
|
13 Mar 2007 |
|
| |
XML and Java technology: Data binding in 1,000 varieties
Brett McLaughlin discusses data binding APIs and the merits of several data binding approaches
|
|
Articles |
|
13 Mar 2007 |
|
| |
Finite state machines in JavaScript, Part 3: Test the widget
In this series you learn how to use a finite state machine to methodically design complex behavior for a simple Web widget -- an animated tooltip that fades into and out of view. The resulting code is compact and concise, its logic is transparent, and its animation performs smoothly even on heavily loaded processors. In this article, learn how to deal with practical issues to make the implementation work in all popular Web browsers, and wrap things up. Part 1 showed how to use a finite state machine to methodically design complex behavior for a simple Web widget. Part 2 described how to implement that behavior in JavaScript, and take full advantage of its distinctive language features, including associative arrays and function closures.
|
|
Articles |
|
13 Mar 2007 |
|
| |
The ultimate mashup -- Web services and the semantic Web, Part 4: Create an ontology
This series details the creation of a mashup application that gives control over the data displayed back to the user; to do that, you need to build in intelligence. Now that you know how to represent information in RDF, you can start to create an ontology using the XML-based Web Ontology Language (OWL), which will enable you to automatically choose between services and parts of services.
|
|
Tutorials |
|
08 Mar 2007 |
|
| |
The ultimate mashup -- Web services and the semantic Web, Part 5: Change out Web services
This series details the creation of a mashup application that gives control over the data displayed back to the user. Now that you know how to create an ontology that defines the concepts represented by a service, you can enable users to choose which service they want to use.
|
|
Tutorials |
|
08 Mar 2007 |
|
| |
Specify custom isolation levels with the Spring framework
If you're building an application that requires a custom isolation level in a global transaction during the execution of a use case, you've probably found out the hard way that the Java Transaction API doesn't support custom isolation levels. Fortunately, the Spring framework lets you design Web and enterprise applications that use custom isolation levels in global transactions. In this article, Ricardo Olivieri walks through two alternative approaches to achieving this goal.
|
|
Articles |
|
01 Mar 2007 |
|
| |
In pursuit of code quality: Automate GUI testing with TestNG-Abbot
TestNG-Abbot is a testing framework that breathes new life into testing GUI components. This month, Andrew Glover walks you through the hardest part of GUI testing with TestNG-Abbot, which is understanding how a user scenario will play out. Once you've got that down, you'll find it surprisingly easy to isolate GUI components and then verify them using the framework's handy fixture objects.
|
|
Articles |
|
27 Feb 2007 |
|
| |
Java theory and practice: Using Java 5 language features in earlier JDKs
Java 5 added a number of powerful language features: generics, enumerations, annotations, autoboxing, and the enhanced for loop. However, many shops are still tied to JDK 1.4 or earlier and may be for some time to come. But it's still be possible for those developers to take advantage of these powerful language features while continuing to deploy on earlier JVMs. Brian Goetz returns from his hiatus in this installment of Java theory and practice to demonstrate how.
|
|
Articles |
|
27 Feb 2007 |
|
| |
Jump into JUnit 4
JUnit 4 has dropped the strict naming conventions and inheritance hierarchies of old, in favor of the streamlined flexibility of Java 5 annotations. In this tutorial, a supplement to his popular series on code quality, testing fanatic Andrew Glover shows you how to leverage the new features enabled by annotations, including parametric tests, exception tests, and timed tests. He also introduces JUnit 4's flexible fixtures and shows you how to use annotations, rather than suites, to logically group tests before running them. The tutorial includes several sample tests run in Eclipse and instructions for running JUnit 4 tests in older, incompatible versions of Ant.
|
|
Tutorials |
|
20 Feb 2007 |
|
| |
XML and Java technology: What's XML really good for?
Brett McLaughlin raises questions about XML's value as a data exchange format.
|
|
Articles |
|
20 Feb 2007 |
|
| |
Implement a relaxed immutability model
Immutable objects are a great help for writing thread-safe software. In the Java language, the primary mechanism for guaranteeing immutability is the use of final fields. But final fields must be set in constructors, and in some cases, this requirement is too restrictive. This article shows an efficient way to implement a slightly more relaxed model of immutability, using normal cached fields whose values can still be accessed safely without synchronization.
|
|
Articles |
|
20 Feb 2007 |
|
| |
Develop HTML widgets with Dojo
Learn the basics of developing HTML widgets using Dojo; including how to refer an image, how to add an event handler to an HTML page, and how to handle composite widgets. Also, discover some important differences between plain old JavaScript-style coding versus Dojo, and get tips for handling complex issues inherent in Web application development.
|
|
Tutorials |
|
14 Feb 2007 |
|
| |
Zero-config object persistence with Simple Persistence for Java
Simple Persistence for Java is an open source object-relational persistence library that uses a custom query language and built-in database support to simplify object persistence in Java applications. In this article, software architect Sami Salkosuo introduces the library and walks you through its zero-admin, zero-config approach to object persistence.
|
|
Articles |
|
13 Feb 2007 |
|
| |
Crossing borders: The beauty of Lisp
Lisp has long been recognized as one of the great programming languages. The fanatical following it has inspired throughout its long history -- nearly 50 years -- tells you it's something special. At MIT, Lisp plays a foundational role in the curriculum for all programmers. Entrepreneurs like Paul Graham used Lisp's incredible productivity as the jet fuel for successful startups. But to the chagrin of its followers, Lisp never made it into the mainstream. As a Java programmer, if you spend some time with Lisp -- this lost city of gold -- you'll discover many techniques that will change the way you code, for the better.
|
|
Articles |
|
07 Feb 2007 |
|
| |
Build Web apps with ThinWire and Java code, Part 3: Styling support
With ThinWire, an open-source development framework, you can build Web applications that look and feel like desktop applications. In this five-part series, you'll learn how to develop rich Web applications using ThinWire and Java programming. Here in Part 3, you learn to use ThinWire styling support at both a global level and an individual component level.
|
|
Tutorials |
|
06 Feb 2007 |
|
| |
Web 2.0 user interface technologies
Imagine that you are tasked to create a new application that will live in the Web 2.0 world. Some of your users are perfectly happy with HTML-based user interfaces while others expect every application they use to behave like Excel. Your business sponsor expects a productivity-enhancing user experience, but your CIO won't allow you to develop anything that a user needs to manually deploy. You know HTML won't cut it, but what else is out there? This article explores a series of Web 2.0 user interface technologies that enable you to build applications with better-than-browser user experiences. As a result, you can centrally deploy and manage them just like any other Java(TM) 2 Enterprise Edition (Java EE) application.
|
|
Articles |
|
30 Jan 2007 |
|
| |
Developing with Apache Derby -- Hitting the trifecta: Java database development with Apache Derby, Part 2
Get a thorough overview on how to issue a simple database query against an Apache Derby database and how to process the selected results. Doing so requires the introduction of three new JDBC classes: Statement, ResultSet, and ResultSetMetaData. Learn how to use these classes with a JDBC database connection to quickly and easily extract data from an Apache Derby database into your own Java application.
|
|
Articles |
|
30 Jan 2007 |
|
| |
Two ways to build Apache Derby database applications in JRuby
JRuby is an implementation of the Ruby programming language that runs in the Java Virtual Machine (JVM). This tutorial demonstrates how to install and configure JRuby to connect to the Apache Derby database. As Ruby and Ruby on Rails become more popular, JRuby becomes an interesting technology to leverage the portability, security, and class libraries of the JVM while using Ruby features like simple syntax and closures. If you're writing a small application that needs a relational database, or you want to be able to ship a database with your product, then the Derby database is an excellent choice for a persistence mechanism. This tutorial shows you two methods of connecting to and building Derby database applications from JRuby.
|
|
Tutorials |
|
30 Jan 2007 |
|
| |
In pursuit of code quality: Defensive programming with AOP
While defensive programming effectively guarantees the condition of a method's input, it becomes repetitive if it is pervasive across a series of methods. This month, Andrew Glover shows you an easier way to add reusable validation constraints to your code using the power of AOP, design by contract, and a handy library called OVal.
|
|
Articles |
|
30 Jan 2007 |
|
| |
Use Inversion of Control in method signatures
The Inversion of Control (IoC) pattern is normally used for components. This article describes how to use the pattern on method signatures to decrease the coupling between components and improve performance. IBM Global Business Services consultant Andr Fachat uses two examples to show the flexibility of this approach.
|
|
Articles |
|
30 Jan 2007 |
|
| |
Build an Ajax application using Google Web Toolkit, Apache Derby, and Eclipse, Part 2: The reliable back end
In this second article in the series on using the Google Web Toolkit (GWT) to build Asynchronous JavaScript + XML (Ajax) applications, learn how to build the Apache Derby database for your Web application, and use it to drive the GWT. Part 1 of this
series introduced you to GWT and demonstrated how you can use it to create a rich-client front end
for a Web application. This time, you'll go behind the scenes and learn about setting up the
back end with your database and the code used to convert the data to a format that
GWT can use. By the end of this article, you'll be ready for the front end and back end
to talk to each other.
|
|
Articles |
|
23 Jan 2007 |
|
| |
Automation for the people: Improving code with Eclipse plugins
What if you were able to discover potential problems in your code prior to building it? Interestingly enough, there are Eclipse plugins for tools such as JDepend and CheckStyle that can help you discover problems before they are manifested in software. In this installment of Automation for the people, automation expert Paul Duvall provides examples of installing, configuring, and using these static analysis plugins in Eclipse so that you can prevent problems early
in the development life cycle.
|
|
Articles |
|
11 Jan 2007 |
|
| |
Delve into Hierarchical Inherited Rule-Interpreted XML
With the new XML technology called Hierarchical Inherited Rule-Interpreted XML, you can replace standard Java properties with dynamic versions. It allows you to define properties that you can evaluate based on the state of the application using simple expressions or even Groovy expressions, and it lets you use only one properties file for multiple instances of the application. Learn how to apply this technology in a simple, practical example as a replacement for Java properties files.
|
|
Articles |
|
09 Jan 2007 |
|
| |
Crossing borders: Closures
Closures are blocks of code that can be used as arguments to functions and methods. The programming construct has long been a staple of languages such as Lisp, Smalltalk, and Haskell. The Java community has resisted closures so far, even as competing languages such as C# add them. This article explores whether closures represent unnecessary complexity for a language for a little convenience, or something more.
|
|
Articles |
|
09 Jan 2007 |
|
| |
Build Web apps with ThinWire and Java code, Part 2: Using the SplitLayout Class
With ThinWire, an open-source development framework, you can build Web applications that look and feel like desktop applications. In this five-part series, you'll learn how to develop rich Web applications using ThinWire and Java. In Part 2, you learn to use the SplitLayout class in conjunction with your own layout management code to dynamically change the layout of a ThinWire GUI based on the current size of the Web browser window.
|
|
Tutorials |
|
03 Jan 2007 |
|
| |
Crossing borders: JavaScript's language features
JavaScript is often ridiculed as the black sheep of programming languages. The development tools, a complicated and inconsistent document object model for HTML pages, and inconsistent implementation in browsers contributes to that sentiment. But JavaScript is much more than a toy. In this article, Bruce Tate explores JavaScript's language features.
|
|
Articles |
|
19 Dec 2006 |
|
| |
Access z/OS batch jobs from Java
Java (TM) can provide a simple way to submit z/OS(R) batch jobs to run -- but that is just the beginning. You can also use Java, from any platform, to check on the status of your z/OS batch jobs. This article is a follow-on to developerWorks article, "Submit batch jobs from Java on z/OS."
|
|
Articles |
|
19 Dec 2006 |
|
| |
Hit the ground running with AIDE, Part 7: Better IT management
The IBM Autonomic Integrated Development Environment (AIDE) facilitates a model-driven approach to touchpoint development, which is a useful, factory-style, wizard-assisted pattern for producing generic touchpoints. However, at some point in the AIDE-driven workflow, the touchpoint must be made specific to a given application. You can do this either at the model design stage or manually through hard-coding. In this tutorial -- the seventh in the series -- discover techniques for creating both generic and specific touchpoints, and learn how to produce touchpoints that have the right mixture for a given management application.
|
|
Tutorials |
|
19 Dec 2006 |
|
| |
In pursuit of code quality: Discover XMLUnit
Java developers are natural problem solvers, so it makes sense that someone has come up with an easier way to validate XML documents. This month, Andrew introduces XMLUnit, a JUnit extension framework that meets all your XML validation needs.
|
|
Articles |
|
19 Dec 2006 |
|
| |
Introduction to Apache Maven 2
Modern software projects are no longer solely monolithic creations of single local project teams. With the increased availability of robust, enterprise-grade open source components, today's software projects require dynamic collaboration among project teams and often depend on a mix of globally created and maintained components. Now in its second generation, the Apache Maven build tool -- unlike legacy build tools created before the Internet-enabled era of global software development -- was designed from the ground up to take on these modern challenges. This tutorial gets you started with Maven 2.
|
|
Tutorials |
|
19 Dec 2006 |
|
| |
Managing the Java classpath (UNIX and Mac OS X)
The classpath is one of the most complex and infuriating parts of the Java platform, but mastering it is essential to becoming a professional Java programmer. In this article, Elliotte Rusty Harold lays out the intricacies of the classpath and sourcepath and shows you how to master them on UNIX and Mac OS X. If you're using Windows, see the companion article.
|
|
Articles |
|
12 Dec 2006 |
|
| |
Getting to know the Atom Publishing Protocol, Part 3: Introducing the Apache Abdera project
Earlier articles in this series provided an overview of the Atom Publishing Protocol and described the various ways it is being utilized in real world applications. This article begins to demonstrate how you can start to implement Atom-enabled applications using a new open-source project, called Abdera, currently under incubation at the Apache Software Foundation.
|
|
Articles |
|
12 Dec 2006 |
|
| |
StAX'ing up XML, Part 3: Using custom events and writing XML
In addition to a low-level cursor-based API, StAX provides a powerful iterator-based method to process XML that uses event objects to communicate information about the parsed stream. Part 2 explored this API in detail and provided some examples of its use. In this article, you'll examine customization techniques that use application-defined events. In particular, you'll see how to create custom event classes and use them to process XML with the event iterator-based API. Last but not least, you'll review the serialization API provided by StAX for writing XML as a stream of tokens as well as event objects.
|
|
Articles |
|
12 Dec 2006 |
|
| |
Managing the Java classpath (Windows)
The classpath is one of the most complex and infuriating
parts of the Java platform, but mastering it is essential to becoming a
professional Java programmer. In this article, Elliotte Rusty Harold lays out
the intricacies of the classpath and sourcepath and shows you how to master them
on Windows. If you use UNIX or Mac OS X, see the companion article.
|
|
Articles |
|
12 Dec 2006 |
|
| |
The EJB Advocate: Practical uses for stateful session beans
Just when you think that you have no use for a given component, like a stateful session EJB, a scenario comes along where it is just the right thing to use. In this last column in the series, the EJB Advocate explores some tricky situations that sometimes come up with long running services.
|
|
Articles |
|
06 Dec 2006 |
|
| |
StAX'ing up XML, Part 2: Pull parsing and events
The event iterator-based API provided by Streaming API for XML (StAX) offers a unique blend of advantages over other XML processing methods in terms of both performance and usability. Part 1 introduced StAX and described in detail its cursor-based API. In this article, delve deeper into the event iterator-based API and explore its benefits to Java(TM) developers.
|
|
Articles |
|
05 Dec 2006 |
|
| |
Crossing borders: Ajax on Rails
The hype for Ajax, a technique for making Web pages more interactive, is in overdrive. The Ruby on Rails framework is also flourishing, partly on the strength of its excellent Ajax integration. Find out what makes Ajax on Rails such a powerful combination.
|
|
Articles |
|
05 Dec 2006 |
|
| |
Build Web apps with ThinWire and Java code, Part 1: Manage Web app layout
With ThinWire, an open source development framework, you can build Web applications that look and feel like desktop applications. In this five-part series of tutorials, you'll learn how to develop rich Web applications using ThinWire and Java(TM) programming. In Part 1, you begin the process and learn how to deal with user interface layout issues in ThinWire. You will discover in this tutorial that providing dynamic layout management using the ThinWire framework is a relatively easy thing to do.
|
|
Tutorials |
|
05 Dec 2006 |
|
| |
Java Web services: Digging into Axis2: AXIOM
The Apache Axis2 Web services framework builds on the new AXIOM XML document model for efficient SOAP message processing. Unlike conventional document models, AXIOM builds the document representation in memory only as it's being accessed. Learn why this on-demand construction is a great approach for SOAP processing, and how XOP/MTOM attachments, data binding, and performance fit into the picture.
|
|
Articles |
|
30 Nov 2006 |
|
| |
Java Web services: Digging into Axis2: AXIOM
The Apache Axis2 Web services framework builds on the new AXIOM XML document model for efficient SOAP message processing. Unlike conventional document models, AXIOM builds the document representation in memory only as it's being accessed. Learn why this on-demand construction is a great approach for SOAP processing, and how XOP/MTOM attachments, data binding, and performance fit into the picture.
|
|
Articles |
|
30 Nov 2006 |
|
| |
StAX'ing up XML, Part 1: An introduction to Streaming API for XML (StAX)
The Streaming API for XML (StAX) is the latest standard for processing XML in the Java (TM) language. As a stream-oriented approach, it often proves a better alternative to other methods, such as DOM and SAX, both in terms of performance and usability. This article, the first in a three part series, provides an overview of StAX and describes its cursor-based API for processing XML.
|
|
Articles |
|
29 Nov 2006 |
|
| |
In pursuit of code quality: Performance testing with JUnitPerf
Performance testing is usually left for last in the application development cycle -- not because it's unimportant, but because it's hard to test effectively with so many unknown variables. In this month's In pursuit of code quality, Andrew Glover makes the case for performance testing as part of the development cycle and shows you two easy ways to do it.
|
|
Articles |
|
29 Nov 2006 |
|
| |
Adapt Web applications to work with multiple browsers
Web pages perform differently on different browsers or on browsers with different settings. Learn some useful tips to help you make your Web applications more adaptable to all environments.
|
|
Articles |
|
21 Nov 2006 |
|
| |
Build multiserving Java applications, Part 2
In this tutorial series, learn how to build multiserving Web applications. The first tutorial in the series explained how to use Wireless Universal Resource File (WURFL) for multiserving. This follow-up tutorial demonstrates how to incorporate multiserving features into JavaServer Faces (JSF) applications. JSF is a Java API to build user interface components. By incorporating multiserving features into JSF, you are able to build JSF tag libraries and applications capable of serving a variety of wireless clients.
|
|
Tutorials |
|
21 Nov 2006 |
|
| |
Job scheduling with Quartz
Quartz is an open source project that offers an extensive set of job scheduling features. In this article, software engineer Michael Lipton and IT architect Soobaek Jang introduce the Quartz API, starting with a general overview of the framework and concluding with a series of code examples that illustrate its fundamental features. After reading this article and following the code examples, you should feel capable of incorporating the basic features of Quartz into any Java application.
|
|
Articles |
|
21 Nov 2006 |
|
| |
Architectural manifesto: Wireless messaging with Java ME
Learn about Java Micro Edition (Java ME) Wireless Messaging API. This column starts with a few simple coding examples, then discusses the opportunities it opens up for enterprising developers.
|
|
Articles |
|
15 Nov 2006 |
|
| |
Ajax and REST, Part 2
Ajax has begun to explode in popularity. Old Web frameworks are retrofitting themselves to support Ajax, new pure-Ajax frameworks are under development, and many organizations are considering Ajax adoption or are already building Ajax applications. But for all the excitement, relatively few organizations have deployed Ajax applications successfully. This article, the second in a two-part series, will help you decide if you should use Ajax in real IT applications, and it aims to improve your chances of success with Ajax development.
|
|
Articles |
|
14 Nov 2006 |
|
| |
Automation for the people: Continuous feedback
Feedback is vital for the practice of Continuous Integration (CI) -- in fact, it's the life blood of a CI system. Rapid feedback enables speedy responses to build events that require attention. Without feedback mediums like e-mail or RSS, builds in a broken state have the tendency to stay broken, which defeats the purpose of CI in the first place! In this installment of Automation for the people, automation expert Paul Duvall examines various feedback mechanisms that you can incorporate into CI systems.
|
|
Articles |
|
14 Nov 2006 |
|
| |
Hit the ground running with AIDE, Part 6: Build an autonomic computing system
This tutorial -- the sixth in the series -- introduces two key elements of the IBM Autonomic Integrated Development Environment (AIDE): Apache Tomcat and Axis. Discover tooling-related gaps that the AIDE online help doesn't cover so that you can become more comfortable with the way the toolkit uses the standard open source components.
|
|
Tutorials |
|
14 Nov 2006 |
|
| |
Internationalize your MIDlets
Globalization is more than just a trend -- it has become an essential requirement for application development. JSR-238 is designed to help Java Platform, Micro Edition (Java ME) developers minimize their internationalization efforts using Mobile Information Device Profile (MIDP)/Connected Limited Device Configuration (CLDC). In this article, discover a faster and easier way to internationalize your MIDlets.
|
|
Articles |
|
14 Nov 2006 |
|
| |
Simple Xalan extension functions
The Xalan XSLT processor can invoke almost any method in almost any Java(TM) class in the classpath. Doing so can improve performance, provide features like trigonometric functions that aren't available in XSLT, perform file I/O, talk to databases and network servers, or implement algorithms that are easy to write in the Java language but hard to write in XSLT. Learn the basics of invoking Java code from Xalan.
|
|
Articles |
|
07 Nov 2006 |
|
| |
Build multiserving Java applications, Part 1
In this tutorial series, you'll learn how to build Web applications that can serve wireless clients according to client capabilities. This concept is called multiserving, and it's useful in pervasive computing applications. Wireless Universal Resource File (WURFL), an open source project at SourceForge.net, uses XML to describe the capabilities of wireless devices. This tutorial focuses on exploring and using WURFL, beginning with the concept of multiserving and seeing how WURFL enables multiserving by providing an XML format to express the capabilities of wireless devices.
|
|
Tutorials |
|
07 Nov 2006 |
|
| |
Crossing borders: Delayed binding
Statically typed languages, such as the Java language and C, bind a method call to their implementation at compile time. This strategy lets these languages perform a wide variety of syntax and type checks, giving them more stability -- and often better performance -- than dynamically typed languages that have no such compile-time checks. But static typing comes with a serious limitation: early binding. Some dynamic languages -- such as Ruby, Smalltalk, and Self -- allow delayed binding, which enables another level of programming features.
|
|
Articles |
|
07 Nov 2006 |
|
| |
Cache in with JSON
Data validation is one of the most challenging and ever-changing parts of any enterprise Web application. Quite often validation metadata leaves JavaScript modules littered with server-side code. In this article, you'll learn an elegant way to cache metadata on the client side with the help of server code, which provides JSON-formatted (JavaScript Object Notation) stringified metadata. This approach also enables you to handle multivalue and multigroup attributes in a manner similar to Ajax.
|
|
Articles |
|
01 Nov 2006 |
|
| |
In pursuit of code quality: Use test categorization for agile builds
Everyone agrees that developer testing is important,
but why is it so darn time consuming to run tests? This month, Andrew
Glover reveals the three categories of testing needed to ensure
end-to-end system soundness and then shows you how to automatically sort and
run tests by category. The result is a dramatically reduced
built time, even with today's massive test suites.
|
|
Articles |
|
31 Oct 2006 |
|
| |
Integrate Crystal Reports in Web applications using Rational Application Developer, Part 2: Embed Crystal Reports in Web applications using JDBC Connection at design time and JNDI Connection at run time
Learn how to embed Crysal Reports in Web appliations, using JDBC connection at design time and switching to JNDI connection at run time.
|
|
Articles |
|
17 Oct 2006 |
|
| |
Resolving NumberFormat's parsing issues
The Java Standard Edition (SE) API's NumberFormat class lets a program parse formatted text that represents numeric values. It provides out-of-the-box localization with little effort and is a useful tool for every Java programmer. Unfortunately, the underlying DecimalFormat class can cause unexpected loss of signs and data without notification. In this article, Joe Sam Shirah explains the issues and provides code to handle them properly.
|
|
Articles |
|
17 Oct 2006 |
|
| |
Develop a location-based service application using JSR 179
Walk through the steps required to successfully build and test a location-based Java Platform, Micro Edition (Java ME) application using the Eclipse SDK, the Java Specification Request (JSR) 179 Location API, and the Sun Java Wireless Toolkit.
|
|
Tutorials |
|
10 Oct 2006 |
|
| |
Automation for the people: Remove the smell from your build scripts
How much time do you spend maintaining project build scripts? Probably much more than you'd expect or would like to admit. It doesn't have to be such a painful experience. Development automation expert Paul Duvall uses this installment of Automation for the people to demonstrate how to improve a number of common build practices that prevent teams from creating consistent, repeatable, and maintainable builds.
|
|
Articles |
|
10 Oct 2006 |
|
| |
XForms tip: Accepting XForms data in Java
Much has been made about the ability of XForms to provide interactivity, and to submit information in XML. But none of that will do you any good unless you have a way to analyze the data once you send it to the server. This tip shows you how to access the submitted XML data using a Java servlet.
|
|
Articles |
|
03 Oct 2006 |
|
| |
z/OS concepts for Java developers
Get an overview of the z/OS(R) world for Java(TM) developers and learn how to deploy a Java application on z/OS.
|
|
Articles |
|
03 Oct 2006 |
|
| |
Crossing borders: Streamlined, Part 2
Part 1 of this two-article series introduced Streamlined, a Rails-based open source framework that combines the power of Ajax, metaprogramming, and code generation to take Rails productivity to a new level. Part 2 explores how the metamodel behind Streamlined enables customizations.
|
|
Articles |
|
03 Oct 2006 |
|
| |
Ajax and REST, Part 1
The more that server-side Web applications become immersive by following rich-application models and delivering personalized content, the more their architectures violate Representational State Transfer (REST), the Web's architectural style. These violations can decrease application scalability and increase system complexity. By achieving harmony with REST, Ajax architecture lets immersive Web applications eliminate these negative effects and enjoy REST's desirable properties.
|
|
Articles |
|
02 Oct 2006 |
|
| |
Fuzz testing
Fuzz testing is a simple technique that can have a
profound effect on your code quality. In this article, Elliotte Rusty
Harold shows what happens when he deliberately injects random bad data
into an application to see what breaks. He also explains how to use
defensive coding techniques such as checksums, XML data storage, and
code verification to harden your programs against random data. He
concludes with an exercise in thinking like a code cracker -- a crucial
technique for defending your code.
|
|
Articles |
|
26 Sep 2006 |
|
| |
New to Java technology
The developerWorks Java technology zone contains hundreds of articles, tutorials, and tips to help software developers make the most of the Java platform and related technologies. But when you're looking for a place to get started, sifting through the volume of resources available on the Web today can be overwhelming. developerWorks offers this page to provide an overview of Java technology basics within the overall context of the language. It includes starting points for further investigation in the form of links to relevant introductory developerWorks content, other educational resources, and IBM downloads and products.
|
|
|
|
26 Sep 2006 |
|
| |
In pursuit of code quality: Repeatable system tests
Writing logically repeatable tests is especially tricky when testing Web applications that incorporate a servlet container. In his continued quest to improve code quality, Andrew Glover introduces Cargo, an open source framework that automates container management in a generic fashion, so you can write logically repeatable system tests every time.
|
|
Articles |
|
26 Sep 2006 |
|
| |
The EJB Advocate: SOA represents the next step in the evolution of component-based applications
Somehow the tables got turned! This month, the EJB Advocate finds himself in the position of advocating SOA-related specifications, such as Service Component Architecture (SCA), as much as those associated with Enterprise JavaBeans.
|
|
Articles |
|
20 Sep 2006 |
|
| |
Practically Groovy: Reduce code noise with Groovy
Groovy's concise syntax frees developers from typical Java constructs that are required for code compilation but don't facilitate expressing what a program is really trying to accomplish. In this revival of the Practically Groovy series, Groovy developer and guest columnist J. Scott Hickey walks you through a series of comparisons between normal Java code and the same Groovy code to show you how this exciting language frees you to focus on the important aspects of coding.
|
|
Articles |
|
19 Sep 2006 |
|
| |
Java theory and practice: Instrumenting applications with JMX
Debuggers and profilers can provide insight into an application's behavior, but we usually only break out these tools when there's a serious problem. Building monitoring hooks into an application can make it easier to understand what your programs are doing without breaking out the debugger. Now that Java Management Extensions (JMX) is built into the Java SE platform, and the jconsole viewer provides a universal monitoring GUI, using JMX to provide a window into your application is easier and more effective than ever.
|
|
Articles |
|
19 Sep 2006 |
|
| |
Merge XML and Java with XMLBeans in commerce
Learn how and why Service-Oriented Architectures (SOAs), XML, and XMLBeans can play an important role in addressing real business problems, using the entertainment industry as a case study. This article isn't about code; rather, you'll learn how and why to use XMLBeans in any situation requiring XML.
|
|
Articles |
|
05 Sep 2006 |
|
| |
Hit the ground running with AIDE, Part 5: Build an autonomic computing system
This tutorial -- the fifth in the series -- illustrates the management of Apache
Derby databases using touchpoint technology. Learn how to use a touchpoint that contains a
working instance of Derby, and work through a management interface to a Derby database
instance as a Web service-based managed object. You interact with this touchpoint using
the IBM Autonomic Integrated Development Environment (AIDE) resource browser and
a Derby Java client program.
|
|
Tutorials |
|
05 Sep 2006 |
|
| |
Automation for the people: Choosing a Continuous Integration server
With so many Continuous Integration (CI) servers to choose from, it can be difficult to decide which one is right for you. In the second article of the series Automation for the people, development automation expert Paul Duvall looks at a handful of open source CI servers, including Continuum, CruiseControl, and Luntbuild, using a consistent evaluation criteria and
illustrative examples.
|
|
Articles |
|
05 Sep 2006 |
|
| |
Crossing borders: Streamlined, Part 1
Ruby on Rails is a radically productive Web development environment based on the Ruby programming language. Streamlined is a rapidly growing new open source framework based on Ruby on Rails. Streamlined combines the power of Ajax, metaprogramming, code generation, and Ruby on Rails to take Rails productivity to a new level.
|
|
Articles |
|
05 Sep 2006 |
|
| |
XML and Related Technologies certification prep, Part 1: Architecture
A software system's architecture and performance requirements affect your decision of which XML technologies are most appropriate for your application's needs. This tutorial on architecture teaches you how to discern where and when to use XML in system design. It is the first tutorial in a series of five tutorials that you can use to help prepare for the IBM certification Test 142, XML and Related Technologies.
|
|
Tutorials |
|
29 Aug 2006 |
|
| |
In pursuit of code quality: JUnit 4 vs. TestNG
With its new, annotations-based framework, JUnit 4 has embraced some of the best features of TestNG, but does that mean it's rendered TestNG obsolete? Andrew Glover considers what's unique about each framework and reveals three high-level testing features you'll still find only in TestNG.
|
|
Articles |
|
29 Aug 2006 |
|
| |
Introdução a Programação Java
A zona de tecnologia Java do developerWorks contém centenas de artigos, tutoriais, dicas e recursos de comunidade para ajudar os desenvolvedores de software a tirarem o máximo proveito da plataforma Java e de tecnologias relacionadas. Mas, quando quando você está procurando um lugar para iniciar, examinar cuidadosamente o volume de recursos disponíveis na Web atualmente pode ser cansativo. O developerWorks oferece esta página para fornecer uma visão geral de noções básicas de tecnologia Java com o texto geral da linguagem. Ela inclui pontos de partida para investigação adicional em forma de links para o conteúdo de introdução relevante do developerWorks, outros recursos educacionais e downloads e produtos IBM.
|
|
|
|
28 Aug 2006 |
|
| |
New to Java programming
The developerWorks Java technology zone contains hundreds of articles, tutorials, tips, and community resources to help software developers make the most of the Java platform and related technologies. But when you're looking for a place to get started, sifting through the volume of resources available on the Web today can be overwhelming. developerWorks offers this page to provide an overview of Java technology basics within the overall context of the language. It includes starting points for further investigation in the form of links to relevant introductory developerWorks content, other educational resources, and IBM downloads and products.
|
|
|
|
28 Aug 2006 |
|
| |
Java theory and practice: Testing with leverage, Part 3
The first two installments in this series showed how static analysis tools like FindBugs can provide greater leverage in managing software quality by focusing on entire categories of bugs rather than on specific bug instances. In this final installment on testing, Brian Goetz examines another technique for smoking out bugs that violate design rules: aspects.
|
|
Articles |
|
22 Aug 2006 |
|
| |
Crossing borders: Rails migrations
Ruby on Rails is a progressive Web development framework that implements radical ideas such as convention over configuration, heavy metaprogramming, domain-specific languages, and database wrapping instead of object-relational mapping. This article examines Rails schema migrations, a philosophy of separating each database schema change from the base object model.
|
|
Articles |
|
15 Aug 2006 |
|
| |
Easy database queries with JSTL SQL actions
Author Meenakshi G. Khanna shows you how to use the JSTL 1.1 SQL tag library to incorporate database operations into your JSPs.
|
|
Articles |
|
10 Aug 2006 |
|
| |
The Java XML Validation API
Validation reports whether a document adheres to the rules specified by the schema. Different parsers and tools support different schema languages such as DTDs, the W3C XML Schema Language, RELAX NG, and Schematron. Java 5(TM) adds a uniform validation Application Programming Interface (API) that can compare documents to schemas written in these and other languages. Learn about this XML validation API.
|
|
Articles |
|
08 Aug 2006 |
|
| |
Seven simple reasons to use AppFuse
Getting started with open source tools for the Java platform such as Spring, Hibernate, or MySQL can be difficult. Throw in Ant or Maven, a little Ajax with DWR, and a Web framework -- say, JSF -- and you're up to your eyeballs just trying to configure your application. AppFuse removes the pain of integrating open source projects. It also makes testing a first-class citizen, allows you to generate your entire UI from database tables, and supports Web services with XFire. Furthermore, AppFuse's community is healthy and happy -- and one of the few places where users of different Web frameworks actually get along.
|
|
Articles |
|
08 Aug 2006 |
|
| |
Beef up Web search applications with Lucene
Lucene is a full-text information retrieval (IR) library written in the Java(TM) programming language. Now it's an open source project in the popular Apache Jakarta Project family. Discover how to implement advanced searching capabilities, and learn how to create a robust Web search application using Lucene.
|
|
Articles |
|
08 Aug 2006 |
|
| |
Create more -- better -- code in Eclipse with JET
The ability to create templates to codify best practices (that generate artifacts) is a powerful concept that can save you countless hours and reduce tedious coding. Get an introduction to the code generation framework, JET, which is an Eclipse technology project.
|
|
Articles |
|
08 Aug 2006 |
|
| |
Introduction to Spring 2 and JPA
Java server applications need not be difficult and tedious to create. Now in its second generation, the lightweight Spring framework adds a large suite of features that make it simple for even new server application developers to use. One key enhancement is Spring 2's integration with the Java Persistence API (JPA), a cornerstone of the Enterprise JavaBeans (EJB) 3.0 specification. In this tutorial, learn how to create server applications from scratch using the Spring 2 framework.
|
|
Tutorials |
|
08 Aug 2006 |
|
| |
Automation for the people: Continuous Inspection
Enhance your software development process by employing source code analysis tools to automatically obtain the latest information on code complexity, duplication, and coding standards adherence.
|
|
Articles |
|
01 Aug 2006 |
|
| |
Crossing borders: REST on Rails
Earlier articles in the Crossing borders series introduced Ruby on Rails as an explosively popular framework that's serving as a catalyst for the Ruby programming language. As Ruby experiences increasing success, developers are seeking to integrate their Ruby applications with applications written in other languages. Rails provides excellent support for Web services. This article introduces Web services in Rails and focuses on a strategy known as Representational State Transfer (REST).
|
|
Articles |
|
01 Aug 2006 |
|
| |
Deploying Java Web Services
Deploying Java Web services over multiple containers can pose problems to the developer. Learn several deployment descriptor implementations as part of your Java strategy, and learn how the Java community is beginning to address this problem.
|
|
Articles |
|
28 Jul 2006 |
|
| |
In pursuit of code quality: Testing Struts legacy apps
Even as Struts does a slow fade into the Web Framework Hall of Fame, its legacy lives on, mostly in the form of applications that need to be tested and maintained. This month, Andrew Glover shows you how to put the quality-centered approach to the test (so to speak) on Struts, using JUnit's StrutsTestCase, DbUnit, and some of what you've learned so far in this series.
|
|
Articles |
|
28 Jul 2006 |
|
| |
Ease the integration of Ajax and Java EE
With the rise of Ajax comes the need to dispel the myths of this hot property and pointedly deal with the issues that arise during its use. Senior IT Specialist Patrick Gan takes this opportunity to examine the potential impacts throughout the full development life cycle of introducing Ajax technology into Java EE Web applications. Being aware of the issues involved in accommodating Ajax's asynchronous communication based pattern will help put you on the road to effective Ajax integration.
|
|
Articles |
|
25 Jul 2006 |
|
| |
Partition management with EWLM, Part 1: The basic rules
You've gathered performance data with the help of the IBM Enterprise Workload Manager (EWLM) -- now you're ready to exploit this data by enabling intelligent partition management of your AIX and Linux partitions running on IBM System p5 servers. In this first part of a two-part series, you get an introduction to logical partitioning. You're guided through the steps to set up your environment for EWLM partition management, and learn how to configure partitions.
|
|
Articles |
|
25 Jul 2006 |
|
| |
Technology options for Rich Internet Applications
Web applications are ready to go to the next level, and Rich Internet Applications (RIAs) can greatly enhance user interaction. In this overview of RIAs, you'll learn how to adapt them in the user interface (UI) layer. Web developers and architects might be particularly interested in the discussion of Laszlo, XUL, XForms, Macromedia Flex, and Dojo -- the common technologies currently available in this area. Links to other technologies are also included. A fair understanding of traditional UI tools, such as HTML and XML, is assumed.
|
|
Articles |
|
25 Jul 2006 |
|
| |
Java theory and practice: Testing with leverage, Part 2
June's Java theory and practice column demonstrated how static analysis tools like FindBugs can bring greater leverage to bear on managing software quality by focusing on entire categories of bugs rather than on specific bug instances. In this month's installment, resident exterminator Brian Goetz details the process of constructing and tuning a nontrivial bug pattern detector.
|
|
Articles |
|
25 Jul 2006 |
|
| |
Configure FTP servers for IPv6
The next-generation protocol, Internet Protocol version 6 (IPv6), is becoming widely accepted as the future of the Internet and networking world. This acceptance has encouraged various IT companies to develop applications that support and talk with each other through the IPv6 address format. In this article, learn to configure the File Transfer Protocol (FTP) server for IPv6, and to communicate with FTP servers through a simple Java program that uses the IPv6 address.
|
|
Articles |
|
18 Jul 2006 |
|
| |
Partition management with EWLM, Part 2: Partition management in action
You've gathered performance data with the help of the IBM Enterprise Workload Manager -- now you're ready to exploit this data by enabling intelligent partition management of your AIX and Linux partitions running on IBM System p5 servers. Jump into the action by examining the topology of this test environment and the workload used, looking at the domain policy. Then, run the workload and observe the partition management actions taken by EWLM.
|
|
Articles |
|
18 Jul 2006 |
|
| |
Crossing borders: Explore functional programming with Haskell
Structured programming and object-oriented programming both revolutionized the way business applications are built. But other programming models exist, and some visionaries argue that those paradigms are more productive than object-oriented programming. This article explores the basics of functional programming using Haskell. Learning a functional language can reshape ways you think about Java programming.
|
|
Articles |
|
18 Jul 2006 |
|
| |
Develop mobile apps with Personal Information Management
This tutorial takes you through the steps required to successfully build a Personal Information Management (PIM) Mobile Information Device Profile 2.0 (MIDP 2.0) application using well-known products, such as Eclipse, the J9 Java Virtual Machine, and the JSR-75 PIM implementation.
|
|
Tutorials |
|
18 Jul 2006 |
|
| |
Hit the ground running with AIDE, Part 4: Touchpoint notifications and a simple manager
This tutorial, the fourth in the series, describes how to create a touchpoint that maps instrumented notifications into their touchpoint equivalent. The previous tutorial in this series described how to implement simple GET and SET operations in the touchpoint. This tutorial completes the picture by adding notification handling and paves the way for more complete interaction between your touchpoints and the underlying managed resources. You also learn how to programmatically manipulate a set of touchpoints which lays the foundation for creating a simple autonomic manager.
|
|
Tutorials |
|
18 Jul 2006 |
|
| |
DWR makes interportlet messaging with Ajax easy
Many developers are looking to use Ajax technologies to improve the user experience of Web-based applications, but Ajax programming can be a tricky task. The open source Direct Web Remoting (DWR) library can make Ajax development easier for Java developers by automatically transforming Java classes into JavaScript classes. In this article, you'll learn how how to use DWR and JSR-168-compliant portlets to build an Ajax application quickly and easily.
|
|
Articles |
|
14 Jul 2006 |
|
| |
Create VoiceXML pages within a Java Web developer framework, Part 4: Creating VoiceXML libraries in Java
With the basics of Java-based VoiceXML applications down pat, you're ready to start coding smarter applications than ever before. Through clever uses of JavaBeans components, servlets, JavaServer Pages (JSPs) technology, and plain old Java objects (POJOs), you can make your application development faster and more streamlined than ever before.
|
|
Articles |
|
11 Jul 2006 |
|
| |
Configuring and troubleshooting Tomcat 3.2.4 on IBM System i5/OS
The Tomcat application server is a lightweight, easy-to-use, open source alternative to commercial products. Learn how it to use it with IBM System i5 computers.
|
|
Articles |
|
11 Jul 2006 |
|
| |
Crossing borders: Web development strategies in dynamically typed languages
The Java community has used JavaServer Pages (JSP) technology through most of the last decade, but signs of rust are starting to show. Longstanding conventions inhibit Java programmers from using Java code within Web pages now, and extending even simple components is a chore. Frameworks that take Java Web development beyond JSP programming have emerged, but they fall short of dynamic languages' capabilities. This article shows you Ruby's Web page development strategy and touches on Seaside's radical approach.
|
|
Articles |
|
05 Jul 2006 |
|
| |
In pursuit of code quality: Tame the chatterbox
Just seeing a sprawling code block from a distance
gives some developers the willies -- and it should! Loquacious code is
often the hallmark of complexity, which results in code that is hard to
test and maintain. This month, learn three important ways to measure
code complexity, based on method length, class length, and intra-class
coupling. In this installment of In pursuit of code quality, quality expert Andrew Glover starts out with tips for eyeballing code excess, then
shows you how to use tools like PMD and JavaNCSS for more precision when
you need it.
|
|
Articles |
|
30 Jun 2006 |
|
| |
Memory leak detection and analysis in WebSphere Application Server: Part 1: Overview of memory leaks
This article provides a high level overview of the techniques available in IBM WebSphere Application Server to address Java heap memory leaks.
|
|
Articles |
|
28 Jun 2006 |
|
| |
Introducing the Java Content Repository API
With the growing popularity of content management applications, the need for a common, standardized API for content repositories has become apparent. The Content Repository for Java Technology API (JSR-170) aims to provide such an interface. In this article, you'll use the open source Apache Jackrabbit implementation of JSR-170 to explore the features offered by this promising framework by designing a simple Wikipedia-like encyclopedia back end.
|
|
Articles |
|
27 Jun 2006 |
|
| |
Integrated Development Environment: C/C++ development with the Eclipse Platform
Learn how to use the C/C++ Development Toolkit (CDT), the best integrated
development environment C/C++ toolkit available for Eclipse. And get an overview
of how to use the Eclipse Platform, an integrated development environment for C and
C++ development projects.
|
|
Articles |
|
27 Jun 2006 |
|
| |
Delve inside the Lucene indexing mechanism
Discover Lucene, a full-text information retrieval (IR) library written in the Java(TM) language. You can embed Lucene easily into your applications and implement indexing and searching functionality. Now it's an open source project in the popular Apache Jakarta Project family. Learn about Lucene's indexing mechanism, as well as its index file structure.
|
|
Articles |
|
27 Jun 2006 |
|
| |
Create an Eclipse-based application using the Graphical Editing Framework
This article describes the initial steps involved in creating an Eclipse-based application using the Graphical Editing Framework (GEF). GEF has been used to build a variety of applications for Eclipse, including state diagrams, activity diagrams, class diagrams, GUI builders for AWT, Swing and SWT, and process flow editors. Eclipse and GEF are both open source technologies. They are also included in IBM's WebSphere Studio Workbench.
|
|
Articles |
|
27 Jun 2006 |
|
| |
Ajax for Java developers: Exploring the Google Web Toolkit
The recently released Google Web Toolkit (GWT) is a comprehensive set of APIs and tools that lets you create dynamic Web applications almost entirely in Java code. Philip McCarthy returns to his popular Ajax for Java developers series to show you what GWT can do and help you decide whether it's right for you.
|
|
Articles |
|
27 Jun 2006 |
|
| |
Hit the ground running with AIDE, Part 3: Touchpoint and managed resource integration
This tutorial, the third in a series on the IBM Autonomic Integrated Development Environment (AIDE), describes a basic touchpoint interface for a managed resource. Discover how Eclipse supports the workflows for such development with TODO items and learn how to provide a touchpoint-based platform for arbitrary managed resource management -- a topic that has dogged the telecom and enterprise management arenas for decades.
|
|
Tutorials |
|
27 Jun 2006 |
|
| |
Virtualize this: Using Java API to exploit virtualization capabilities of the IBM POWER5 hardware
Learn about the Management Dynamic Logical Partitioning Extensions API introduced in the IBM(R) Software Developer Kit (IBM(R) SDK) for Java(TM) 5.0 and how and why software applications can benefit from exploiting the capabilities of the IBM Virtualization Engine technologies.
|
|
Articles |
|
27 Jun 2006 |
|
| |
Using Eclipse as a development environment with Jakarta Tomcat
Using Eclipse as a development environment for Java technology is great. Using an Eclipse Tomcat plug-in can help to better organize and integrate your Java and Web development projects. This article will guide you step by step through the installation of Eclipse, Jakarta Tomcat, and an Eclipse Tomcat launcher plug-in that will integrate them.
|
|
Articles |
|
26 Jun 2006 |
|
| |
Java theory and practice: Testing with leverage, Part 1
Back in June 2004, veteran exterminator Brian Goetz introduced the FindBugs static code analysis tool, which
can detect bugs even in well-tested software. This month, he revisits that topic and looks at how static analysis tools can change the way you manage software quality by aiming development resources at entire classes of bugs rather than specific instances.
|
|
Articles |
|
20 Jun 2006 |
|
| |
Crossing borders: Testing in integrated frameworks, Part 2
Part 1 of this two-article series introduced the Ruby on Rails approach to unit testing and showed how adopting aspects of that approach can improve your Java unit tests. Java developers' options for higher-level testing are more limited. In this article, again looking at Rails, you'll gain an appreciation of the advantages of integrated frameworks for functional and integration testing.
|
|
Articles |
|
20 Jun 2006 |
|
| |
Building a secure SOAP client for J2ME, Part 1: Exploring Web services APIs (WSA) for J2ME
This three-part tutorial series demonstrates how to build a secure Web services client based on J2ME. This first part introduces application scenarios which allow wireless access to your Web services. Part 1 also discusses the architecture of a secure Web service application and explains the way different technology components collaborate with each other in a J2ME application to provide security features. We also explore Web Services APIs (WSA) for J2ME in detail by digging deep inside a couple of WSA applications. Later parts of this tutorial will expand upon these concepts to incorporate security into WSA applications.
|
|
Tutorials |
|
16 Jun 2006 |
|
| |
Testing object serialization
Even great developers sometimes forget to test object
serialization, but that doesn't excuse you from making the same mistake.
In this article, Elliotte Rusty Harold explains the importance of unit testing
object serialization and leaves you with some tests to remember.
|
|
Articles |
|
13 Jun 2006 |
|
| |
Use functional programming techniques to write elegant JavaScript
Functional, or declarative, programming is a very powerful programming method and is gaining popularity in the software industry. This article introduces some of the relevant functional programming concepts, and provides examples to use those concepts effectively. The author explains how to write elegant code with JavaScript(TM), which can import constructs and features from functional programming.
|
|
Articles |
|
13 Jun 2006 |
|
| |
Java technology, IBM Style: Monitoring and problem determination
The IBM implementation of Java technology, Version 5.0 contains a number of useful tools that help you diagnose and solve Java development problems. In this final installment in our Java technology, IBM style series, you learn about the information available from the IBM trace and dump engines. You also get an introduction to the Diagnostic Toolkit and Framework for Java (DTFJ) API, with which you can write code that queries and analyzes diagnostic data.
|
|
Articles |
|
13 Jun 2006 |
|
| |
Crossing borders: Testing in integrated frameworks, Part 1
The Java community has done a fantastic job of advancing automated unit testing. An increasing number of open source frameworks let you build automated test suites along with your projects. The Spring framework, JUnit, TestNG, and several other frameworks owe some or all of their inspiration to the idea of automated testing. Still, some non-Java languages and frameworks have more motivation to test, more suitable testing tools, and a more unified view of testing. By looking at how other frameworks test, you can improve the way you test in the Java language, or even use a more appropriate language to test your Java code. This article, the first of two on testing in Ruby on Rails, covers the Rails approach to unit testing.
|
|
Articles |
|
06 Jun 2006 |
|
| |
The Ajax transport method
Discover three Ajax data transport mechanisms (XMLHttp, script tags, and frames or iframes) and their relative strengths and weaknesses. This tutorial provides code for both the server side and the client side and explains it in detail to provide the techniques you need to put efficient Ajax controls anywhere you need them.
|
|
Tutorials |
|
06 Jun 2006 |
|
| |
Java SCA invocation styles
This article offers an overview of Java usage within the Service Component Architecture's (SCA) Plain Old Java Object (POJO) component and the data flow in and out of POJO components. You will see the effects of different invocation styles when they are used within a POJO component.
|
|
Articles |
|
06 Jun 2006 |
|
| |
Best practices for location-aware services
This tutorial gets you started with IBM Enterprise LAS middleware. Learn the concepts behind the middleware and write a simple location-tracking Web application with the help of Asynchronous JavaScript and XML (Ajax) and Scalable Vector Graphics (SVG) technologies. With these best practices in mind, you'll be on your way to building faster location-tracking systems that can easily integrate with positioning/sensoring technologies, such as RFID and Zigbee.
|
|
Tutorials |
|
06 Jun 2006 |
|
| |
Understanding how Eclipse plug-ins work with OSGi
The core of the Eclipse integrated development environment (IDE) and Eclipse Rich Client Platform (RCP) applications is driven by an implementation of the Open Services Gateway Initiative (OSGi) specification. This article illustrates Eclipse's relationship with OSGi by describing what a plug-in is in terms of the Eclipse platform and traces the evolution of plug-ins from Eclipse V2.1 through today's OSGi-based implementation. It also explains the OSGi manifest.mf file options, along with the additions provided through Eclipse.
|
|
Articles |
|
06 Jun 2006 |
|
| |
Introducing Subversion
Elliotte Rusty Harold introduces Subversion, an open
source, multiuser version control system that supports non-ASCII text
and binary data. Follow along as Elliotte shows you how to configure
Subversion support in Eclipse (via the Subclipse plug-in), check out a
project, synchronize with your repository, and then run common operations
such as merge, patch, diff, and delete.
|
|
Articles |
|
06 Jun 2006 |
|
| |
In pursuit of code quality: Refactoring with code metrics
In earlier installments of In pursuit of code quality, you learned how to use code metrics to objectively measure code quality. This month, Andrew Glover shows you how to use those same metrics and the Extract Method pattern for targeted refactoring.
|
|
Articles |
|
30 May 2006 |
|
| |
Java technology, IBM style: Class sharing
The new Shared Classes feature in the IBM implementation of version 5.0 of the Java platform offers a completely transparent and dynamic means of sharing all loaded classes that places no restrictions on the JVMs that are sharing the class data. This feature offers a straightforward and flexible solution for reducing virtual memory footprint and improving startup time, and there are few applications that will not benefit from it. This article explores how the feature works, how to use it, and when to use it, along with some of the features it provides.
|
|
Articles |
|
30 May 2006 |
|
| |
Stick to the ECMAscript
To entice developers to create sites that render best in their specific browsers, vendors have fueled a compatibility war using scripting languages as their weapons of choice while users get caught in the middle with slow-loading Web pages and potential security holes. As the market drives such (unhealthy) competition, it's clear that it's time for better standardization. See what you can do to stay on neutral territory until that day comes.
|
|
Articles |
|
30 May 2006 |
|
| |
Java theory and practice: Dealing with InterruptedException
Many Java language methods, such as Thread.sleep() and Object.wait(), throw InterruptedException. You can't ignore it because it's a checked exception, but what should you do with it? In this month's Java theory and practice, concurrency expert Brian
Goetz explains what InterruptedException means, why it is thrown, and what you should do when you catch one.
|
|
Articles |
|
23 May 2006 |
|
| |
SIMless confidentiality
Author Tea Vui Huang shows you how to use the Java 2 Platform, Micro Edition (J2ME) Security and Trust Services API (SATSA) to implement wireless symmetric key-based transaction security without using a Subscriber Identity Module (SIM), WIM, or PKI-MMC. The end result is a token-free approach to securing J2ME transactions by using familiar methods deployed in smartcard projects around the world.
|
|
Articles |
|
23 May 2006 |
|
| |
Hit the ground running with AIDE, Part 2: Build a real-world touchpoint
This tutorial -- the second in series on AIDE -- moves beyond the basics of building touchpoints using the IBM Autonomic Integrated Development Environment (AIDE) toolkit and covers the use of events and IT management technologies (specifically the Java Management Extensions) and demonstrates how to connect external value-added Java tools to autonomic computing touchpoints. I'll focus on how to tackle the problem of linking autonomic computing touchpoints with external JMX-instrumented software.
|
|
Tutorials |
|
23 May 2006 |
|
| |
Crossing borders: Typing strategies beyond the Java model
The Java community is split when it comes to the language's approach to typing. Some love the compile-time error checking, better security, and improved tools -- all features enabled by static typing. Others would prefer a more dynamically typed experience. This time in Crossing borders, you'll look at the dramatically different typing strategies used by two highly productive non-Java languages and at ways you can achieve some typing flexibility in your Java programming.
|
|
Articles |
|
23 May 2006 |
|
| |
Java technology, IBM style: Garbage collection policies, Part 2
The previous installment in this series introduced the different garbage collection (GC) policies available in the IBM implementation of version 5.0 of the Java runtime and discussed their general characteristics. In this article, series contributor Mattias Persson is joined by Holly Cummins to present a quantitative approach to choosing a policy with some examples. They describe what you should consider in making a choice, how to get guidance on a choice from the verbose GC logs, and present two case studies.
|
|
Articles |
|
16 May 2006 |
|
| |
All Hail Shale: Anatomy of a Shale application
Brett McLaughlin continues his introduction to Shale with an in-depth look at the framework's application directory structure. Using the Shale starter application introduced in the first article in this series, Brett walks you through the core directories, from src/ to dist/. He shows you how Shale stores its libraries, where custom files go, and where you can insert specialized behaviors into your Shale applications. Along the way, he gives you some important tips about managing the Shale directories and gets you started with an example application (based on the Shale starter application) that serves as the basis of his discussion for the remainder of the series.
|
|
Articles |
|
12 May 2006 |
|
| |
Don't repeat the DAO!
With the adoption of Java 5 generics, the idea of a
generic typesafe Data Access Object (DAO) implementation has become feasible. In this
article, system architect Per Mellqvist presents a generic DAO
implementation class based on Hibernate. He then shows you how to use
Spring AOP introductions to add a typesafe interface to the class for
query execution.
|
|
Articles |
|
12 May 2006 |
|
| |
Advanced XML validation
XSLT stylesheets are designed to transform XML documents. Coupled with Java extensions, stylesheets can also be a powerful complement to XML Schema when grammar-based validation cannot cover all the constraints required. In this article, Peter Heneback presents the case for validating documents using XSLT with Java extensions and provides practical guidance and code samples.
|
|
Articles |
|
09 May 2006 |
|
| |
Java technology, IBM style: Garbage collection policies, Part 1
One of the great benefits of the Java platform is that it takes care of much of the work of garbage collection for you, but there are occasions when you still want to tweak the way garbage collection takes place. With the latest Java technology implementation from IBM, you can choose among several garbage collection policies to help you get the most out of your application. In this second article in the series Java technology, IBM style, Java developer Mattias Persson explores the available options and details the situations in which each might be appropriate.
|
|
Articles |
|
09 May 2006 |
|
| |
Crossing borders: What's the secret sauce in Ruby on Rails?
Ruby on Rails seems to be a lightning rod for controversy. At the heart of most of the controversy lies amazing productivity claims. Crossing Borders author Bruce Tate has come to understand that Rails isn't a better hammer; it's a different kind of tool. This article explores the compromises and design decisions that went into making Rails so productive within its niche. Then it looks at Rails-inspired ideas that should get more attention within the Java community.
|
|
Articles |
|
09 May 2006 |
|
| |
Advanced Facelets programming
If you think internationalization is hard, think again! In this article, Richard Hightower follows up his immensely popular introduction to Facelets with more advanced ways to bridge the gap between Java Server Faces (JSF) and EL. Follow along as Rick shows you how to internationalize your Web pages easily, add custom logic tags to a composition component, and incorporate metaprogramming into your Facelets development.
|
|
Articles |
|
09 May 2006 |
|
| |
Web services integration patterns for Java applications using open source frameworks, Part 1: Implementing invoke patterns
There are four primary patterns for integrating Web services. In this first of a two-part series, we suggest ways to develop a service and client to invoke Web services for all four service end-point patterns, using popular open source frameworks. We discuss two of the patterns, request-response and one-way end-point, covering both document-style and RPC Web services invocation styles. The next article in the series will describe the other two integration patterns, solicit-response and notification.
|
|
Articles |
|
05 May 2006 |
|
| |
Storing Java objects in Apache Directory Server, Part 1
This two-part article walks you through all the steps of storing Java objects in Apache Directory Server (ApacheDS). In this first half, author Bilal Siddiqui introduces you to ApacheDS and provides an overview of its core architecture. Because you primarily use ApacheDS as an LDAP server for storing Java objects, Bilal offers a quick overview of LDAP concepts and terminology. He also shows you how to use JXplorer to view LDAP schema components, such as attribute types and object classes, and how to enter a data object in ApacheDS. The article wraps up with an overview of Java object serialization and Remote Method Invocation as they apply to storing Java objects in ApacheDS, in preparation for the more hands-on approach in Part 2.
|
|
Articles |
|
02 May 2006 |
|
| |
Java technology, IBM style: Introduction to the IBM Developer Kit
With the advent of Java 5.0 comes advances from IBM in its Java technology implementation. This article opens a six-part series on changes in the latest version of the IBM Developer Kit. Author Chris Bailey begins with a brief description of the improvements to the Java 5.0 platform and moves on to a whistle-stop tour of the changes in SDKs from IBM.
|
|
Articles |
|
02 May 2006 |
|
| |
Storing Java objects in Apache Directory Server, Part 2
In this second half of his introduction to storing Java objects in Apache Directory Server (ApacheDS), Bilal Siddiqui presents nine
example applications to demonstrate the concepts you learned in Part 1. In addition to walking you through all the steps to store, search, retrieve, and modify Java objects using ApacheDS, Bilal concludes the article with a reusable Java class that combines these functions using LDAP schema components in ApacheDS.
|
|
Articles |
|
02 May 2006 |
|
| |
Moving forward with Web services backward compatibility
Managing change to an SOA-based system is an important part of any governance scheme. Learn some techniques for SOA change management here.
|
|
Articles |
|
01 May 2006 |
|
| |
XML Matters: Pipestreaming microformats
An increasingly common use of XML is to move small snippets of content through an arbitrary processing workflow, much like text through UNIX pipes. The snippets can be from one document or many, whole documents or fragments, or synthesized on demand from other data sources, thus streaming is an appropriate metaphor. The microformat approach of using well-defined snippets of XML or XHTML lends itself well to this approach. You'll look at some examples of this using existing Python and Java(TM) tools and the hCard and hCalendar microformats.
|
|
Articles |
|
25 Apr 2006 |
|
| |
Build and test JSR 168-compliant portlets with Apache Pluto
With Apache Pluto, Java developers have a freely available tool for testing whether their portlets comply with the JSR 168 Portlet Specification. Developers Mark Talbot and Kulvir Singh Bhogal take you on a guided tour of portlet testing. You'll install Pluto and build, compile, package, and deploy a simple portlet to Pluto to test it for JSR 168 compliance. You'll also get a hint of what's in store for the next version of the Portlet Specification.
|
|
Articles |
|
25 Apr 2006 |
|
| |
Dynamic interface design with Swing
The Swing UI toolkit makes it possible, though not always easy, to update user interfaces dynamically in response to events or user actions. This article reviews some of the common ways you can build UIs that update dynamically, a few pitfalls you might encounter along the way, and some principles to help you decide when this is the right approach for the job.
|
|
Articles |
|
25 Apr 2006 |
|
| |
In pursuit of code quality: Code quality for software architects
Most well-designed software architectures are intended to support a system's extensibility, maintainability, and reliability. Unfortunately, inattention to quality issues can easily undermine a software architect's best effort. In this installment of in pursuit of code quality, quality expert Andrew Glover explains how to continuously monitor and correct quality aspects of code that can affect the long-term viability of your software architecture.
|
|
Articles |
|
25 Apr 2006 |
|
| |
Use Apache Derby in your OpenLaszlo applications, Part 2: Storing and embedding data
Since OpenLaszlo's open source announcement, many developers have been using OpenLaszlo to create user-friendly rich Internet applications. Many of these applications require a database solution to have dynamic data fed to them. Because OpenLaszlo runs on Apache Tomcat by default, which supports JavaServer Pages (JSP) and servlets (Java), Apache Derby is an excellent database to use because it can be embedded in such applications and because Derby is written in pure Java code. In this tutorial, you'll build a management interface to the online shopping console created in Part 1. You'll also allow orders to be written to the database and enable management to edit, delete, and add new items to the database via the OpenLaszlo user interface (UI).
|
|
Tutorials |
|
25 Apr 2006 |
|
| |
Create VoiceXML pages within a Java Web developer framework, Part 3: Simplifying VoiceXML development in the Java language
At this point in this series, you should be comfortable using Java servlets to create multipage VoiceXML applications. However, a servlet is simply a Java class file, and must be recompiled every time even a simple change is made. By moving to JavaServer Pages (JSP) technology for much of your VXML, you'll find it easier to make changes, and also reduce the need to recompile servlets every time you make a small change to your VXML.
|
|
Articles |
|
25 Apr 2006 |
|
| |
Eclipse Test & Performance Tools Platform, Part 2: Monitor applications
In this "Eclipse Test & Performance Tools Platform" tutorial series, learn how to use the capabilities of the Eclipse Test a& Performance Tools Platform (TPTP) to convert application log files into a structured format. Then, using TPTP and other specialized tools designed to process and analyze log files, you can quickly discern usage patterns, performance profiles, and errors.
|
|
Tutorials |
|
25 Apr 2006 |
|
| |
Comment lines: Roland Barcia: How useful are annotated named queries in the Java Persistence API, really?
Annotations do make things easier for a developer, but simplicity comes with trade-offs. The Java Persistence API (JPA) makes use of annotations as a mechanism to map Java objects to the underlying database, but developers often use annotations even when it doesn't make sense. Find out some of the other ways to access data through JPA, and when and why these alternatives are the better options.
|
|
Articles |
|
19 Apr 2006 |
|
| |
Apache SOAP type mapping, Part 1: Exploring Apache's serialization APIs
SOAP defines a simple wire protocol for transferring application-level data. This protocol can easily carry arbitrary Java types as serialized XML, thanks to its rich and extensible type system. In this article, the first of a two-part series on the type system support found in the Apache SOAP toolkit, Gavin Bong will introduce you to the theoretical underpinnings of SOAP's type system. You'll also learn more about SOAP's programmatic support for serialization and deserialization and conclude with an exploration into the toolkit's internals. A better understanding of how these processes work will help you build your own distributed systems.
|
|
Articles |
|
18 Apr 2006 |
|
| |
Crossing borders: Concurrent programming with Erlang
The Java programming language made starting a new thread easier than ever before. But freeing your concurrent programs of obscure bugs is a different matter, and Java's programming model might not be the best available. A language called Erlang is getting some good press now in the areas of concurrency, distributed systems, and soft real-time systems.
|
|
Articles |
|
18 Apr 2006 |
|
| |
Java theory and practice: Introduction to nonblocking algorithms
Java 5.0 makes it possible for the first time to develop nonblocking algorithms in the Java language, and the java.util.concurrent package uses this capability extensively. Nonblocking algorithms are concurrent algorithms that derive their thread safety not from locks, but from low-level atomic hardware primitives such as compare-and-swap. Nonblocking algorithms can be extremely difficult to design and implement, but they can offer better throughput and greater resistance to liveness problems such as deadlock and priority inversion. In this installment of Java theory and practice, concurrency guru Brian Goetz illustrates how several of the simpler nonblocking algorithms work.
|
|
Articles |
|
18 Apr 2006 |
|
| |
Hit the ground running with AIDE, Part 1: Building a touchpoint
This tutorial, the first in a series on the IBM Autonomic Integrated Development Environment (AIDE), shows how you can get up and running quickly with the IBM AIDE toolkit. Discover touchpoint creation, modification, and deployment and learn about the internals of the touchpoint in relation to the underlying model.
|
|
Tutorials |
|
18 Apr 2006 |
|
| |
Make Ant easy with Eclipse
Eclipse can make working with Apache Ant easier. Discover the Ant integration features in the Eclipse integrated development environment (IDE), and learn how to write, build, and debug code in Eclipse through the Ant editor.
|
|
Tutorials |
|
18 Apr 2006 |
|
| |
Deploy MIDlets on J2ME-enabled devices
Learn the various ways you can deploy MIDlets on J2ME-enabled devices. In this tutorial, you'll see how to deploy the MIDlets remotely and locally as well as how to download MIDlets referenced by URLs over the air and on J2ME-enabled devices.
|
|
Tutorials |
|
11 Apr 2006 |
|
| |
Mastering Ajax, Part 5: Manipulate the DOM
Last month Brett introduced the Document Object Model, whose elements work behind the scenes to define your Web pages. This month he dives even deeper into the DOM. Learn how to create, remove, and change the parts of a DOM tree, and take the next step toward updating your Web pages on the fly!
|
|
Articles |
|
11 Apr 2006 |
|
| |
Using Java platform management beans
The latest release of the Java platform includes a number of new system monitoring and management features. In this article, three developers from the IBM Java Technology Centre team up to get you started using this API. After a quick overview of the java.lang.management package, they guide you through a number of short practical scenarios to probe the performance of a running JVM.
|
|
Articles |
|
11 Apr 2006 |
|
| |
AOP@Work: Component design with Contract4J
Design by Contract is a proven technique for clarifying component design details, documenting proper usage for clients, and testing usage compliance programmatically. In this final article in the AOP@Work series, Dean Wampler introduces Contract4J, a Design by Contract tool that specifies contracts using Java 5 annotations and evaluates them at run time using AspectJ aspects. Along with being a strong addition to your AOP toolkit, Contract4J offers insight into emerging trends in aspect-oriented design.
|
|
Articles |
|
11 Apr 2006 |
|
| |
Multithreaded unit testing with ConTest
Concurrent programming is notoriously bug-prone. Worse, concurrent bugs tend to be detected late in the development process when they cause considerable damage and are hard to debug. Even when they are done thoroughly, conventional unit-testing practices are likely to miss concurrent bugs. In this article, concurrency experts Shmuel Ur and Yarden Nir-Buchbinder explain why concurrent bugs are so hard to catch and present a new solution from IBM Research.
|
|
Articles |
|
04 Apr 2006 |
|
| |
Crossing borders: Domain-specific languages in Active Record and Java programming
The Java programming world is full of domain-specific languages (DSLs), but options in the Java language for building DSLs are limited. Not so with Ruby. In this article, you'll learn some nifty ways Ruby lets you integrate clean DSLs, giving you a new frame of reference for examining your Java options with open eyes.
|
|
Articles |
|
04 Apr 2006 |
|
| |
Testing legacy code
Test-first programming is the most effective coding
practice since object-oriented programming, but it assumes you're
starting from a blank screen. What do you do when the code already
exists? Using a popular open source Java tool as his example, author
Elliotte Rusty Harold shows you how to develop a test suite for legacy
code that's never been tested.
|
|
Articles |
|
04 Apr 2006 |
|
| |
Design enterprise applications with the EJB 3.0 Java Persistence API
This article presents a Java EE 5 design approach that leverages EJB 3.0's new Java Persistence API. JPA provides a standard object-relational mapping solution that bypasses the need to rely on third-party frameworks such as Hibernate. You'll see details of a sample application that validates this approach and illustrates key design decisions.
|
|
Articles |
|
28 Mar 2006 |
|
| |
Create VoiceXML pages within a Java Web developer framework, Part 2: Expanding Java-driven VoiceXML applications
In the previous article on VoiceXML, you saw how Java servlets could easily power a VoiceXML application. In this follow-up article, you'll learn how to use servlets to go beyond single-page applications, as well as how to add navigation to your VoiceXML application. Throughout, attention is paid to ensuring that your VoiceXML content is supported and optimized for wireless devices like phones and handhelds.
|
|
Articles |
|
28 Mar 2006 |
|
| |
WSDM for J2EE provides next-generation management
Can the standards for Java 2 Platform, Enterprise Edition (J2EE) management (JSR 077) and general IT management (WS-Distributed Management) work together to create robust manageability interfaces? In this article, you'll learn how the IBM Autonomic Integrated Development Environment (AIDE) component, the IBM Manageability Endpoint Builder, and the JSR 077 API can be used to build a Web Services Distributed Management (WSDM)-compliant manageability endpoint for Java application servers. The final product is a Web application that you can deploy on any J2EE-compliant application server.
|
|
Articles |
|
28 Mar 2006 |
|
| |
In pursuit of code quality: Monitoring cyclomatic complexity
If complexity has been shown to correlate to
defects, doesn't it make sense to monitor your code base's complexity
values? Andrew Glover shows you how to use simple code metrics and
Java-based tools to monitor cyclomatic complexity.
|
|
Articles |
|
28 Mar 2006 |
|
| |
Classworking toolkit: Analyzing generics data structures
|
|
Articles |
|
28 Mar 2006 |
|
| |
Add a Bluetooth text protocol to J2ME apps
With the continuing boom of mobile devices in the communications and gaming industries, as well as the software trend toward ad hoc and peer-to-peer networks, the ability to target heterogeneous devices for networked applications (whether gaming, productivity, or information sharing) is a big advantage. In this article, learn how to use and integrate the Bluetooth API (which was introduced into Java 2 Platform, Micro Edition [J2ME] through JSR 82) into your own applications. Here, you'll find a complete Bluetooth device discovery, pairing, and messaging implementation.
|
|
Articles |
|
21 Mar 2006 |
|
| |
Java theory and practice: Good housekeeping practices
Garbage collection is nearly everyone's favorite feature of the Java platform; it simplifies development and eliminates entire categories of potential code errors. But while garbage collection generally allows you to ignore resource management, sometimes you have to do some housekeeping on your own. In this month's Java theory and practice, Brian Goetz discusses the limitations of garbage collection and identifies situations when you have to do your own housecleaning.
|
|
Articles |
|
21 Mar 2006 |
|
| |
Crossing borders: Continuations, Web development, and Java programming
The Crossing borders series looks at how non-Java languages solve major problems and what those solutions mean to Java developers today. This article explores continuations, the technique behind frameworks like Smalltalk's Seaside. Continuation servers make it much easier to build Web applications by offering a stateful programming model without giving up the scalability inherent in statelessness.
|
|
Articles |
|
21 Mar 2006 |
|
| |
AOP@Work: Next steps with aspects
Once you've taken the first plunge into aspects,
you'll want to keep going and going, but it's never a good idea to
travel without a map. In this article, esteemed aspect developer Ron
Bodkin gives you a guided tour of the four stages of successful aspect
adoption, from first experiments with tracing and testing all the way to
building your own reusable aspect libraries.
|
|
Articles |
|
16 Mar 2006 |
|
| |
Getting started with the Eclipse Communication Framework
The Eclipse Communication Framework (ECF) is a new Eclipse project devoted to providing an open source framework supporting the creation of communications-based applications on the Eclipse platform. Find out about the ECF, its basic capabilities, and its future direction.
|
|
Articles |
|
14 Mar 2006 |
|
| |
Build your own profiling tool
Profiling is a technique for measuring where software programs consume resources, including CPU time and memory. In this article, software architect Andrew Wilcox explains the benefits of profiling and some current profiling options and their shortcomings. He then shows you how to use the new Java 5 agent interface and simple aspect-oriented programming techniques to build your own profiler.
|
|
Articles |
|
14 Mar 2006 |
|
| |
Build GUIs with the Eclipse Visual Editor project
Like many Eclipse.org projects, the goal of the Visual Editor project is to
build a tool for building tools, in this case, tools for building graphical user
interfaces (GUIs). The Visual Editor project has released a reference implementation.
The Visual Editor release 0.5 is a GUI builder for AWT/Swing applications, a
long-awaited Eclipse feature. Release 1.0 includes support for SWT. Get an overview of
Visual Editor and the technology behind it, along with a short demonstration of Visual
Editor V0.5's features for building AWT/Swing applications and a preview of the SWT
support in Visual Editor V1.0.
|
|
Articles |
|
14 Mar 2006 |
|
| |
Mastering Ajax, Part 4: Exploiting DOM for Web response
The great divide between programmers (who work with back-end applications) and Web programmers (who spend their time writing HTML, CSS, and JavaScript) is long standing. However, the Document Object Model (DOM) bridges the chasm and makes working with both XML on the back end and HTML on the front end possible and an effective tool. In this article, Brett McLaughlin introduces the Document Object Model, explains its use in Web pages, and starts to explore its usage from JavaScript.
|
|
Articles |
|
14 Mar 2006 |
|
| |
Improve persistence with Apache Derby and iBATIS, Part 3: Transactions, caching, and dynamic SQL
This tutorial series has been demonstrating how you can improve persistence in your database-driven Java applications by combining Apache Derby's power as a small-footprint embeddable database with the iBATIS object-relational (OR) mapping framework. In Part 3, the final in the series, learn how iBATIS handles three advanced features of database-driven applications: transactions, caching, and dynamic SQL. Plus, find out how the Data Access Objects (DAO) framework can operate on its own without the Data Mapper framework.
|
|
Tutorials |
|
07 Mar 2006 |
|
| |
Crossing borders: Exploring Active Record
The Java programming language has had an unprecedented run of success for vendors, customers, and the industry at large. But no programming language is a perfect fit for every job. This article launches a new series by Bruce Tate that looks at ways other languages solve major problems and what those solutions mean to Java developers. He first explores Active Record, the persistence engine behind Ruby on Rails. Active Record bucks many Java conventions, from the typical configuration mechanisms to fundamental architectural choices. The result is a framework that embraces radical compromises and fosters radical productivity.
|
|
Articles |
|
07 Mar 2006 |
|
| |
Create an Eclipse game plug-in, Part 1: Getting started
Although most users think of Eclipse as an Integrated Development Environment (IDE) for building Java applications, it is really something much more basic. Eclipse is a framework for building plug-ins, allowing any developer to extend its functionality to solve nearly any problem, just by leveraging a set of APIs and readily available libraries. In this four-part "Create an Eclipse game plug-in" tutorial series, you will solve a pressing problem most programmers encounter daily: how to break away to play a quick video game without switching applications and making it obvious. You will also learn the Eclipse plug-in architecture and learn how to define your own plug-in, develop an interface using SWT, and create code that interacts with other Eclipse resources.
|
|
Tutorials |
|
07 Mar 2006 |
|
| |
In pursuit of code quality: Resolve to get FIT
Find out how the Framework for Integrated Tests facilitates
communication between the business clients who write requirements and
the developers who implement them.
|
|
Articles |
|
28 Feb 2006 |
|
| |
All Hail Shale: Shale isn't Struts
What Shale isn't is a shrink-wrapped, well-documented, well-tested product complete with an automated installer and a polished management interface. Now find out what it is, as Brett McLaughlin unveils this mighty -- and rightful -- heir to the legacy of Struts. In this first article of the series, Brett explains what Shale is, how it's different from the Struts framework, and how to install and set it up in your development environment.
|
|
Articles |
|
28 Feb 2006 |
|
| |
Building a Java applet
In this hands-on tutorial, Tiles master Rick Hightower guides you through more advanced uses of the Tiles framework, including compartmentalizing your presentation tier to better reuse layouts, HTML, and other visual components. You will build these visual componentswith JSP (JavaServer Pages) technology using custom tags and Java scriptlets.
|
|
Tutorials |
|
27 Feb 2006 |
|
| |
Getting to know MCS
Explore the concepts behind the Mail and Calendar Services (MCS), a component of the Intelligent Notification Services used to access mail files, monitor for new e-mail messages, and to provide events based on these new e-mails to users' preferred delivery channels.
|
|
Articles |
|
24 Feb 2006 |
|
| |
Get started with an open source CMS, Part 5: Build a PHP WebDAV client for Jakarta Slide
In this tutorial, the fifth in the series, learn how to create a PHP Web-based Distributed Authoring and Versioning (WebDAV) Client for Jakarta Slide that you can use to build PHP applications for content management. With this knowledge, you can then go on to build other PHP applications on a system that can manage numerous users and documents.
|
|
Tutorials |
|
24 Feb 2006 |
|
| |
The EJB Advocate: Is EJB 2.x dead yet?
The EJB Advocate responds to a reader who declares that EJB 3.0 makes EJB 2.0 obsolete, and explores some of the new features of the EJB 3 specification, including the Java Persistence API (JPA). This exchange shows that while the benefits of these new specifications are good, they require you to make some simplifying assumptions that may not work for everyone. Since nearly all of these benefits can be provided as implementations of the EJB 2.x specification with the proper tooling, it is likely that EJB 2.x will be around for a while.
|
|
Articles |
|
22 Feb 2006 |
|
| |
Java theory and practice: The pseudo-typedef antipattern
The addition of generics to the Java language
complicated the type system and increased the verbosity of many
variable and method declarations. Because no "typedef" facility
was provided for defining short names for types, some developers
have turned to extension as a "poor man's typedef," with less than
good results. In this month's Java theory and practice, Java expert
Brian Goetz explains the limitations of this "antipattern."
|
|
Articles |
|
21 Feb 2006 |
|
| |
SWT, Swing or AWT: Which is right for you?
By providing a comparison of Eclipse's SWT with the Java Swing and Abstract Windows Toolkit (AWT) GUI tool kits, this article helps developers of new applications decide which to choose. Read descriptions of each tool kit's basic features, and the pros and cons of using each.
|
|
Articles |
|
21 Feb 2006 |
|
| |
Explore the new features of Eclipse V3.1
This tutorial demonstrates many of the new features found in the most recent release of Eclipse V3.1. You will find this tutorial useful if you're considering upgrading to V3.1 from a previous release, or if you're considering switching to Eclipse from another integrated development environment. You may also find it useful if you want to revise your code to take advantage of the latest iteration of the Java programming language, Java 2 Standard Edition V1.5, which adds a number of powerful constructs and conveniences to Java technology.
|
|
Tutorials |
|
21 Feb 2006 |
|
| |
An introduction to the Eclipse Web Tools Platform V1.0
The Eclipse Web Tools Platform (WTP) extends the Eclipse IDE to enable easy development of Java 2 Enterprise Edition (J2EE)-based applications. Learn how to install WTP, configure it for use with an application server, and use the tools it provides to create a J2EE application.
|
|
Tutorials |
|
21 Feb 2006 |
|
| |
Secure XML messaging with JMS, Part 2: Using XSS4J to implement XML Security
Java Message Service (JMS) is a Java language-based messaging API. XML provides a simple, human-readable data format for information exchange, and is a popular syntax for the formating of enterprise data. Therefore, integrating XML into JMS applications can provide significant advantages in enterprise applications. This tutorial demonstrates the use of XML Security Suite for Java (XSS4J) to achieve secure XML messaging over an existing JMS network.
|
|
Tutorials |
|
21 Feb 2006 |
|
| |
Facelets fits JSF like a glove
Trying to combine JSF and JSP is like trying to shoehorn a foot into a glove: it's possible, but it's really just a stopgap measure until something better comes along. In this article, JSF enthusiast Rick Hightower introduces you to what he likes best about Facelets: easy HTML-style templating and reusable composition components.
|
|
Articles |
|
21 Feb 2006 |
|
| |
Mastering Ajax, Part 3: Advanced requests and responses in Ajax
For many Web developers, making simple requests and receiving simple responses is all they'll ever need, but for developers who want to master Ajax, a complete understanding of HTTP status codes, ready states, and the XMLHttpRequest object is required. In this article, Brett McLaughlin will show you the different status codes and demonstrate how browsers handle each and he will showcase the lesser-used HTTP requests that you can make with Ajax.
|
|
Articles |
|
14 Feb 2006 |
|
| |
Introduction: Eclipse Test and Performance Tools Platform
Learn how to use the Eclipse Test and Performance Tools Platform (TPTP) to profile a Java application, and discover how to quantify memory usage, identify memory leaks, and isolate performance bottlenecks.
|
|
Tutorials |
|
14 Feb 2006 |
|
| |
Developing with Apache Derby -- Hitting the Trifecta: Introduction to Apache Derby
At some point, almost every application developer confronts the need to save data. With the growth of Internet- or Web-enabled applications, this need has become even more acute. This installment of the regular column "Developing with Apache Derby -- Hitting the Trifecta" introduces Apache Derby -- an open source, standards-based, small-footprint Java database system -- compares it to other database systems, and discusses issues related to downloading and installing it. By the end of this article, you'll be ready to start developing database applications using Derby.
|
|
Articles |
|
14 Feb 2006 |
|
| |
AOP@Work: AOP myths and realities
What's keeping you from trying out AOP? Whether you
think it's only good for low-level functions like tracing and logging,
worry that it'll get in the way of unit testing, or would simply rather
stick with the object-oriented alternatives, Ramnivas Laddad gives you
good reason to reconsider. Follow along as this popular author and
speaker digs beneath the surface of 15 myths that hinder the adoption of
AOP.
|
|
Articles |
|
14 Feb 2006 |
|
| |
Eclipse Test & Performance Tools Platform, Part 1: Test, profile, and monitor applications
Learn how to use the Eclipse Test & Performance Tools Platform (TPTP) to profile a Java application, and discover how to quantify memory usage, identify memory leaks, and isolate performance bottlenecks.
|
|
Tutorials |
|
14 Feb 2006 |
|
| |
Java Web services: The year ahead in Java Web services
The coming year is bringing dramatic changes to the Web services landscape. For Java developers, these changes will include both new Web services frameworks and new layers of functionality built on top of Web services. In this first part of his "Java Web Services" series, Dennis Sosnoski looks at the coming changes and plots a course for readers.
|
|
Articles |
|
09 Feb 2006 |
|
| |
Java Web services: The year ahead in Java Web services
The coming year is bringing dramatic changes to the Web services landscape. For Java developers, these changes will include both new Web services frameworks and new layers of functionality built on top of Web services. In this first part of his "Java Web Services" series, Dennis Sosnoski looks at the coming changes and plots a course for readers.
|
|
Articles |
|
09 Feb 2006 |
|
| |
Classworking toolkit: Generics with ASM
Java 5 generics provide information that's useful for many
classworking applications. Although Java reflection can be used to get generics
information for loaded classes, the requirement that classes be loaded into the
JVM can be a major drawback. In this article, classworking guru Dennis Sosnoski
shows how the ASM Java bytecode manipulation framework offers flexible access to
generics information without going through the Java classloading process. Along
the way, he looks deeper into the representation of generics in the binary
class format.
|
|
Articles |
|
07 Feb 2006 |
|
| |
FastSOA: Accelerate SOA with XML, XQuery, and native XML database technology
Many SOA implementations rely on message formats defined with XML. The resulting message schemas can become complex, incompatible, and difficult to maintain, and can cause serious scalability and performance problems. In this article, Frank Cohen describes a new strategy and techniques for accelerating SOA performance through the use of XML, XQuery, and native XML database technology in the SOA mid-tier.
|
|
Articles |
|
07 Feb 2006 |
|
| |
Run PHP applications in Apache Geronimo
PHP has been a popular scripting language for some time. However, with the growing buzz over Java technology and Apache Geronimo, a J2EE-certified application server, many experienced developers shy away from using PHP with Geronimo, because only JavaServer Pages (JSP) is supported out of the box. The PHP Java Bridge solves this problem by providing full support for PHP on Geronimo and for sharing sessions across both PHP and JSP scripts.
|
|
Tutorials |
|
07 Feb 2006 |
|
| |
Mobile video: Get started with the QuickTime for Java API
The newest generation of iPod media players has opened up a world of opportunity in mobile video programming, but how do you get started? This article introduces you to the QuickTime for Java library, which is required to programmatically create video content for the iPod media player.
|
|
Articles |
|
07 Feb 2006 |
|
| |
Validate localized data with regular expressions
Data validation is a common chore in programming any user interface. The Java language's regular-expression support can make data validation easier. You can define a regular expression that describes valid data and then let the Java runtime see if it matches. But certain types of data have different formats in different locales. The ResourceBundle class lets you work with locale-specific data in an elegant way. This article shows how to combine the two techniques to solve a common data-entry problem. This article was updated on February 1, 2006.
|
|
Articles |
|
01 Feb 2006 |
|
| |
Globalize your embedded apps
This article covers the two aspects of a globalization solution -- internationalization and localization -- on embedded devices. For internationalization, learn how to design your code structure to support multiple languages. For localization, learn how to customize the number, date, time, and currency format.
|
|
Articles |
|
31 Jan 2006 |
|
| |
In pursuit of code quality: Don't be fooled by the coverage report
Test coverage tools bring valuable depth to unit testing, but they're often misused. This month, Andrew Glover brings his considerable expertise in this area to his new series, In pursuit of code quality. This first installment takes a closer look at what the numbers on the coverage report really mean, as well as what they don't. He then suggests three ways you can use your coverage to ensure code quality early and often.
|
|
Articles |
|
31 Jan 2006 |
|
| |
In pursuit of code quality: Don't be fooled by the coverage report
Test coverage tools bring valuable depth to unit testing, but they're often misused. This month, Andrew Glover brings his considerable expertise in this area to his new series, In pursuit of code quality. This first installment takes a closer look at what the numbers on the coverage report really mean, as well as what they don't. He then suggests three ways you can use your coverage to ensure code quality early and often.
|
|
Articles |
|
31 Jan 2006 |
|
| |
User annotations in Ajax
The ability to add notes and comments to your Web site can be a powerful and attractive feature for users. This tutorial demonstrates how to implement an Asynchronous JavaScript and XML (AJAX)-based user annotation system in the form of yellow sticky notes that sit on top of regular Web page content. The only additional, required configuration is a back-end Perl script that stores the annotations
|
|
Tutorials |
|
31 Jan 2006 |
|
| |
Persist arbitrary data to Apache Derby
You can quickly and easily persist simple data to Apache Derby by taking advantage of Java dynamic proxies. In this tutorial, write a persistence API that you can integrate into any database-powered Java application. You use the API to store an application's configuration information and to notify the application when configuration items change.
|
|
Tutorials |
|
31 Jan 2006 |
|
| |
Generate PDF files from Java applications dynamically
If your application needs to generate PDF documents dynamically, you need the iText library. The open source iText library makes PDF creation a snap. This article introduces iText and gives a step-by-step guide to using it to generate PDF documents from Java technology applications. We create a sample application to better understand iText.
|
|
Articles |
|
24 Jan 2006 |
|
| |
Java theory and practice: Plugging memory leaks with soft references
In the previous installment of Java theory and practice, Java sanitation engineer Brian Goetz examined weak references, which let you put the garbage collector on notice that you want to maintain a reference to an object without preventing it from being garbage collected. This month, he explains another form of Reference object, soft references, which can also enlist the aid of the garbage collector in managing memory usage and eliminating potential memory leaks.
|
|
Articles |
|
24 Jan 2006 |
|
| |
Configuring and using XA transactions with WebSphere MQ V6 Classes for Java
This article shows you how to configure and use XA distributed transactions with WebSphere MQ Classes for Java,
and how to resolve common problems you may encounter.
|
|
Articles |
|
18 Jan 2006 |
|
| |
Create VoiceXML pages within a Java Web developer framework
Brett McLaughlin shows you how to output VoiceXML from server-side Java code, allowing your Java applications to interact with telephony.
|
|
Articles |
|
17 Jan 2006 |
|
| |
AOP@Work: Check out library aspects with AspectJ 5
AspectJ 5's new language and deployment features make
library aspects easy, and library aspects in turn promise to put AOP in
the hands of mere mortals. Miraculously simple to use, they can be
devilishly difficult to write. In this installment of AOP@Work series, Wes Isberg weaves a
tale about 30 serious contenders in a world not too far from your
own; along the way, you'll learn how to use and write library aspects
and how to deliver solutions to believers and nonbelievers alike.
|
|
Articles |
|
17 Jan 2006 |
|
| |
Mastering Ajax, Part 2: Make asynchronous requests with JavaScript and Ajax
Most Web applications use a request/response model that gets an entire HTML page from the server. The result is a back-and-forth that usually involves clicking a button, waiting for the server, clicking another button, and then waiting some more. With Ajax and the XMLHttpRequest object, you can use a request/response model that never leaves users waiting for a server to respond. In this article, Brett McLaughlin shows you how to create XMLHttpRequest instances in a cross-browser way, construct and send requests, and respond to the server.
|
|
Articles |
|
17 Jan 2006 |
|
| |
Implement MVC in custom SWT components
Eclipse SWT (Standard Widget Toolkit) offers an extensive set of APIs to implement your custom-made widgets. In this article, the author briefly outlines the MVC (Model-View-Controller) architecture, explains the current implementation of MVC in the form of structured viewers, and shows an implementation using a custom SWT widget.
|
|
Articles |
|
11 Jan 2006 |
|
| |
In tune with Tapestry, Part 2
The Tapestry framework allows Java and Web developers
to develop servlet-based Web applications that are dynamic, lightweight,
and responsive. Continue getting to know Tapestry this month, as Brett
McLaughlin shows you how to plan the development of a Tapestry application
and create useful, robust Tapestry components.
|
|
Articles |
|
10 Jan 2006 |
|
| |
Call SOAP Web services with Ajax, Part 2: Extend the Web services client
Implement a Web Browser-based SOAP Web services client using the Asynchronous JavaScript and XML (Ajax) design pattern. In the Part 1 of this series, "Call SOAP Web Services with Ajax, Part 1," the author introduced a simple Web browser-based JavaScript library for invoking SOAP Web services. In the discussion that follows, the author expands on functions of that JavaScript library by implementing basic support for the Web Services Addressing Language and the Web Services Resource Framework specifications.
|
|
Articles |
|
10 Jan 2006 |
|
| |
Secure Java apps on Linux using MD5 crypt
UNIX/Linux PAM-compatible systems use authentication based on the GNU MD5 extensions to the crypt() system call. This article explains these extensions and shows you a Java implementation of MD5 crypt that is compatible with UNIX/Linux systems.
|
|
Articles |
|
10 Jan 2006 |
|
| |
Practical data binding: XPath as data binding tool, Part 2
Once you understand XPath syntax and location paths, accessing XML without the overhead of DOM and SAX is possible and even easy. Fortunately for Java developers, the Java API for XML Processing (JAXP) provides a native Java solution for creating XPath requests and using the results in your applications. In this article, the second in a two-part series, you'll learn how to create an XPath request, execute that request, and work with the resulting node set -- all within a comfortable Java environment.
|
|
Articles |
|
04 Jan 2006 |
|
| |
In tune with Tapestry, Part 1
In this first half of a two-part article, author and frequent developerWorks contributor Brett McLaughlin shows you around Tapestry, from installation to file structure. See for yourself how Tapestry facilitates servlet-based Web application development using HTML and template tags.
|
|
Articles |
|
04 Jan 2006 |
|
| |
Deploy J2EE applications on Apache Geronimo
Learn how to deploy JavaServer Pages (JSPs), servlets, and different Enterprise JavaBeans (EJBs) on Apache Geronimo. This article includes the deployment steps required for Apache Geronimo, which are different from other Java 2 Platform, Enterprise Edition (J2EE) containers.
|
|
Articles |
|
03 Jan 2006 |
|
| |
Designing mobile Web services
From when to choose mobile Web services to the overall design guidelines to the value types to use in mobile Web services, this article addresses many of the design considerations you need to ponder when developing Web services for mobile devices. It also covers many of the best practices for designing mobile Web services. Learn how to decide when to use Web services, what things to consider when you design Web services, and what to keep in mind when planning mobile Web services.
|
|
Articles |
|
03 Jan 2006 |
|
| |
Understand the DB2 UDB JDBC Universal Driver
Discover the latest step in the evolution of Java application development using DB2 UDB. Get an inside view of the JDBC Universal Driver and examine common debugging techniques that will help you get to the heart of any problem.
|
|
Articles |
|
22 Dec 2005 |
|
| |
A gentle introduction to SWT and JFace, Part 4: How to use ToolBars and SashForms
This installment of A gentle introduction to SWT and JFace expands on what you've learned about creating applications using Java technology, Eclipse, and the SWT and JFace libraries. This installment shows you how to use ToolBars, CoolBars, Trays, SashForms, Links, and other controls, as well as several dialog types.
|
|
Articles |
|
20 Dec 2005 |
|
| |
Introduction to Apache Derby
Get the basic skills you need to use Apache Derby in Java 2 Platform, Enterprise Edition (J2EE) environments where Derby is embedded as a database, such as in Apache Geronimo. This tutorial demonstrates how to embed Derby within Geronimo and how to use Derby and Geronimo to deploy a Web-based e-commerce application. It also helps you become familiar with Derby's system tools, a set of utilities that make application development with Derby easy and straightforward.
|
|
Tutorials |
|
20 Dec 2005 |
|
| |
Automate acceptance tests with Selenium
Acceptance, or functional, testing is designed to put manual tasks through their paces, but testing these tasks by hand can be time consuming and prone to human error. In this article, the author shows architects, developers, and testers how to use the Selenium testing tools to automate acceptance tests; automating the tests saves times and helps eliminate tester mistakes. You also are provided with an example of how to apply Selenium in a real-world project using Ruby on Rails and Ajax.
|
|
Articles |
|
20 Dec 2005 |
|
| |
3D graphics for Java mobile devices, Part 2: M3G's retained mode
The Mobile 3D Graphics API retained mode lets you work with a scene graph representation of your 3D world. This article, the second of a two-part series, describes just that -- an easy way to manage your 3D objects.
|
|
Articles |
|
20 Dec 2005 |
|
| |
Ruby off the Rails
Ruby on Rails is just one facet of what makes Ruby great, just like EJB is only part of the Java enterprise platform. Andrew Glover digs beneath the hype for a look at what Java developers can do with Ruby, all by itself.
|
|
Articles |
|
20 Dec 2005 |
|
| |
Demystifying class loading problems, Part 4: Deadlocks and constraints
This four-part article series examines Java class loading, in an effort to help application developers understand and debug problems they may encounter. In this final installment, authors Lakshmi Shankar and Simon Burns from the IBM Hursley Labs build on the first three articles and look at two of the most interesting and complex problems you will encounter in this arena: deadlocks and constraints.
|
|
Articles |
|
20 Dec 2005 |
|
| |
Submit batch jobs from Java on z/OS
Learn how to reuse programs while still accessing them from Web. Historically, the mainframe has had a huge capacity of processing high volumes of data in batch by running Job Control Language (JCL) statements that control the execution of programs. In this article, Nagesh Subrahmanyam provides step-by-step instructions on how to use a Java(TM) program to submit batch jobs from a z/OS(R) mainframe -- the missing link between the traditional batch processing capability of a mainframe and the flexibility of the Web.
|
|
Articles |
|
15 Dec 2005 |
|
| |
AOP@Work: Dependency injection with AspectJ and Spring
Dependency injection and aspect-oriented programming
are complementary techniques, so it's natural to want to use them
together. Follow along as Adrian Colyer explores the relationship
between the two and shows you how you can combine them to facilitate
advanced dependency injection scenarios.
|
|
Articles |
|
13 Dec 2005 |
|
| |
Securing Java Card applications, Part 2: Integrating Java Card into J2ME applications
Get up to date using the Java Card API to bring Kerberos-based security to mobile applications. Learn the pros and cons of the current cryptographic support for the Java Card API, then get a demonstration of a roll-your-own cryptography solution.
|
|
Articles |
|
13 Dec 2005 |
|
| |
Demystifying class loading problems, Part 3: Tackling more unusual class loading problems
This four-part article series examines Java class loading, in an effort to help application developers understand and debug problems they may encounter. In Part 3, authors Lakshmi Shankar and Simon Burns from the IBM Hursley Labs build on the first two parts of the series and detail different kinds of class loading problems, including those related to classpaths, class visibility, and garbage collection.
|
|
Articles |
|
13 Dec 2005 |
|
| |
Demystifying class loading problems, Part 2: Basic class loading exceptions
This four-part article series examines Java class loading to help application developers understand and debug problems they may encounter. In Part 2, authors Lakshmi Shankar and Simon Burns from the IBM Hursley Labs tackle some exceptions that, while fairly simple, often puzzle novice and experienced Java developers alike.
|
|
Articles |
|
06 Dec 2005 |
|
| |
Create a UIMA component Web service, Part 1: Create a UIMA application using Eclipse
Search word processing documents, emails, video, and other unstructured information for specific text or even for concepts using the Unstructured Information Management Architecture (UIMA). Part 1 of this tutorial explains how to install and use the UIMA Eclipse plug-ins to create a simple UIMA application.
|
|
Tutorials |
|
06 Dec 2005 |
|
| |
Mastering Ajax, Part 1: Introduction to Ajax
Ajax, which consists of HTML, JavaScript, DHTML, and DOM, is an outstanding approach that helps you transform clunky Web interfaces into interactive Ajax applications. The author, an Ajax expert, demonstrates how these technologies work together -- from an overview to a detailed look -- to make extremely efficient Web development an easy reality. He also unveils the central concepts of Ajax, including the XMLHttpRequest object.
|
|
Articles |
|
06 Dec 2005 |
|
| |
Build culturally aware apps with GBO
This article gives an introduction to Global Business Object (GBO), an IBM alphaWorks technology that offers a set of Java libraries of culturally sensitive GUI elements for global applications. Shu Bei and Zhu Xiao Hui walk you through GBO's architecture and globalization features. They also describe one GBO component in detail, illustrating how GBO can integrate with your Web-based apps.
|
|
Articles |
|
06 Dec 2005 |
|
| |
Design with the JSF architecture
In this article, author Anand Joshi explains the JavaServer Faces (JSF) architecture using design patterns in the JSF framework. He discusses Gang of Four design patterns employed in the JSF architecture, and how they work within the JSF framework. Anyone with a general knowledge of design patterns and JSF architecture will learn from Anand's detailed guide. *Readers should have a good knowledge of Gang of Four design patterns and JSF technology.
|
|
Articles |
|
02 Dec 2005 |
|
| |
Create multimedia-rich MIDlets
This tutorial demonstrates the Mobile Media API (MMAPI), which extends the functions of Java 2 Platform, Micro Edition (J2ME) by providing audio, video, and other time-based multimedia support to resource-constrained devices.
|
|
Tutorials |
|
29 Nov 2005 |
|
| |
Secrets of lightweight development success, Part 9: Continuations-based frameworks
By letting you look at Web requests as a single application instead of multiple requests, continuations can make it easier to manage state, improve the way components fit together, and simplify vexing problems, such as the Back button and threading. This article explores the continuations server approach.
|
|
Articles |
|
29 Nov 2005 |
|
| |
Demystifying class loading problems, Part 1: An introduction to class loading and debugging tools
The class loading component is fundamental to the Java virtual machine. Though developers generally have a good grasp of the basics of class loading, when a problem occurs, they may have a hard time diagnosing and determining a solution. In this four-part article series, Lakshmi Shankar and Simon Burns discuss the various class loading problems that you may encounter in your Java development and illustrate why they occur and how to resolve them. The insights they provide should help you understand and resolve common Java exceptions, such as NoClassDefFoundError and ClassNotFoundException, in addition to more challenging problems, such as class loader constraint violations and deadlocks. In this first article, they describe in detail how Java class loading works and discuss the tools available in the JVM to help you diagnose class loading problems.
|
|
Articles |
|
29 Nov 2005 |
|
| |
Practical data binding: XPath as data binding tool, Part 1
XPath is not traditionally considered a data binding API. It doesn't even get much attention in the XML world, except in passing as part of other specifications. But once you fully understand what XPath is and how to use it -- particularly in a Java programming environment -- it becomes a powerful data binding tool that's often preferable to traditional data binding APIs such as JAXB or JaxMe. Brett McLaughlin's Practical data binding column returns with the first in a two-article series that examines XPath as a data binding tool.
|
|
Articles |
|
29 Nov 2005 |
|
| |
Java theory and practice: Plugging memory leaks with weak references
While programs in the Java language are theoretically
immune from "memory leaks," there are situations in which objects are not
garbage collected even though they are no longer part of the program's
logical state. This month, sanitation engineer Brian Goetz explores a
common cause of unintentional object retention and shows how to plug
the leak with weak references.
|
|
Articles |
|
22 Nov 2005 |
|
| |
Secure XML messaging with JMS: Secure XML messaging with JMS, Part 1: Extending JMS to support XML authoring and processing
Java Message Service (JMS) is a Java language-based messaging API. XML provides a simple, human-readable data format for information exchange, and is a popular syntax for the formatting of enterprise data. Therefore, integrating XML into JMS applications can provide significant advantages in enterprise applications. This tutorial teaches you how to include support for secure XML messaging over an existing JMS network.
|
|
Tutorials |
|
22 Nov 2005 |
|
| |
Using multiple Struts configuration files
Breaking a large configuration file into smaller, more manageable parts makes Struts applications easier to organize and maintain. In this tutorial, Brett McLaughlin shows how to set up Apache Struts to use multiple configuration files. The tutorial reviews Struts configuration, takes you step-by-step through execution of a divide-and-conquer configuration strategy, and guides you through some additional configuration cleanup options.
|
|
Tutorials |
|
22 Nov 2005 |
|
| |
Dynamic radio buttons with Struts
Follow along as Struts Recipes co-author Danilo Gurovich walks you through five easy steps for creating radio buttons with dynamically selected elements.
|
|
Articles |
|
15 Nov 2005 |
|
| |
Build apps using Asynchronous JavaScript with XML (AJAX)
AJAX (Asynchronous JavaScript with XML) enables a dynamic, asynchronous Web experience without the need for page refreshes. In this tutorial, you will learn to build AJAX-based Web applications -- complete with real time validation and without page refreshes -- by following the construction of a sample book order application.
|
|
Tutorials |
|
15 Nov 2005 |
|
| |
Make your Eclipse applications richer with view linking
Views in a rich GUI enhance the user experience by displaying information in a variety of ways. By their very nature, UI views depend on other views and need to interact. Eclipse makes it easy to link the UI views and provides ways to adapt view linking to non-UI scenarios.
|
|
Articles |
|
15 Nov 2005 |
|
| |
AOP@Work: Performance monitoring with AspectJ, Part 2
Ron Bodkin shows you how to add more advanced monitoring features to the Glassbox Inspector, a finely tuned monitoring infrastructure that combines AspectJ and JMX.
|
|
Articles |
|
15 Nov 2005 |
|
| |
Effective database testing with IBM Rational Functional Tester 6.1
This article is for developers or testers interested in testing a database directly from their IBM Rational Functional Tester scripts. The information is explained using examples and detailed instructions.
|
|
Articles |
|
10 Nov 2005 |
|
| |
Secrets of lightweight development success, Part 8: Seaside
Continuations, or high-level programming abstractions, are often seen as academic toys, but a new breed of Web server can make the average developer much more productive. Continuation servers let you support the Back button in Web browsers and code with a more consistent programming style. Developers the world over recognize Seaside as the top existing continuation server, but Seaside does much more than continuations.
|
|
Articles |
|
08 Nov 2005 |
|
| |
Classworking toolkit: Reflecting generics
Java 5 extended the Java language type system to support parameterized
types for classes, methods, and values. Parameterized types provide important
compile-time advantages by enforcing proper type usage and eliminating casts
from source code. Beyond these compile-time benefits, the type information can
also be useful for classworking tools manipulating Java code. In this article,
JiBX lead developer Dennis Sosnoski looks at how to use reflection to dig
beneath the surface of parameterized types and reveal the full glory of Java 5
application data structures.
|
|
Articles |
|
08 Nov 2005 |
|
| |
Ajax for Java developers: Ajax with Direct Web Remoting
Exciting as it is, adding Ajax functionality to your
applications can mean a lot of hard work. In this third article in the
Ajax for Java developers series, Philip McCarthy shows you how to
use Direct Web Remoting (DWR) to expose JavaBeans methods directly to your
JavaScript code and automate the heavy-lifting of Ajax.
|
|
Articles |
|
08 Nov 2005 |
|
| |
AOP@Work: Unit test your aspects
AOP makes it easier than it's ever been to write tests
specific to your application's crosscutting concerns. Find out why and
how to do it, as Nicholas Lesiecki introduces you to the benefits of
testing aspect-oriented code and presents a catalog of patterns for
testing crosscutting behavior in AspectJ.
|
|
Articles |
|
01 Nov 2005 |
|
| |
Bluetooth boogies, Part 2: Creating the Bluetooth Music Store
Object Exchange (OBEX) is a preferred method to send and receive files between two Bluetooth devices. Part 1 of this series introduced the semantics of OBEX and explained how to create a simple OBEX server application, FileServer.java. In this article, you'll learn how to create a simple OBEX client, FileClient.java, that can transfer a file to the server application. You'll also learn how to modify your OBEX client application to make it into a Bluetooth Music Store.
|
|
Articles |
|
01 Nov 2005 |
|
| |
Extending Spring JMX support
The Spring framework minimizes architectural
dependencies and externalizes composition in your applications, but
applications also need to be managed. Fortunately, Spring 1.2 includes
sophisticated JMX integration support -- and JMX delivers a practical
management infrastructure for your applications. In this article,
Claude Duguay takes Spring JMX a step further, showing you how to add
notification events to methods and attributes transparently. The
resulting code lets you monitor state changes without cluttering up
your Java objects.
|
|
Articles |
|
01 Nov 2005 |
|
| |
Practically Groovy: Smooth operators
The Java language has banned operator overloading, but upstart Groovy says "bring it on!" Find out what you've been missing all these years, as Andrew Glover walks you through everyday uses of Groovy's three categories of overloadable operators in this final, regular installment of Practically Groovy.
|
|
Articles |
|
25 Oct 2005 |
|
| |
Developing embedded apps with eSWT
See how the embedded Standardb Widget Toolkit (eSWT) differs from the usual Standard Widget Toolkit (SWT) and get some best tips and practices for using it as you develop your own eSWT application based on the Model-View-Controller (MVC) framework. The article also discusses how to develop, deploy, and test a Service Management Framework (SMF) bundle using eSWT.
|
|
Articles |
|
25 Oct 2005 |
|
| |
Dynamic checkboxes with Struts
Struts Recipes co-author Danilo Gurovich
picks up where George Franciscus left off with an easy-to-follow Struts
recipe for creating dynamically selected checkboxes.
|
|
Articles |
|
25 Oct 2005 |
|
| |
Tomcat for beginning Web developers
The Apache Tomcat application server is no longer the exclusive domain of advanced Web system developers. In this tutorial, Sing Li shows beginning Web developers how to leverage their current Java development skills to program server-side JSPs, servlets, and Web services using Tomcat.
|
|
Tutorials |
|
20 Oct 2005 |
|
| |
Greenlight your RFID systems
Incorporate a Radio Frequency Identification (RFID) framework and connect to various interface types. Learn how to integrate the framework with back-end applications and implement business logic. This article provides the answers to getting it all done.
|
|
Articles |
|
18 Oct 2005 |
|
| |
Java generics support in Eclipse V3.1
Java 5 offers generics support, a feature developers requested for years. It represents a significant upgrade to the Java language. With something as complex as generics also comes challenges, both for tool vendors and developers. This article highlights how Eclipse has responded and the changes wrought by generics to the Java programming language. It shows how to take full advantage of generics within Eclipse, including support in Quick Assist, Quick Fix, refactoring, and project preferences. It also shows some subtle and important aspects of a fully generic language.
|
|
Articles |
|
18 Oct 2005 |
|
| |
Java theory and practice: Synchronization optimizations in Mustang
In the September installment of Java theory and
practice, columnist Brian Goetz examined escape analysis, an
optimization that has been on the "to-do" list for many JVMs for quite
some time and which is expected in HotSpot in the Mustang (Java SE
6) release. Escape analysis can be used to convert heap-based object
allocation into the less-expensive, stack-based allocations, but it can
also be used to make other optimization decisions as well, including
optimizing the use of synchronization. This month Brian introduces some of the synchronization
optimizations slated for Mustang. Note: This column describes features of a future version of
Sun's HotSpot JVM implementation. Specific features discussed herein
may or may not appear in Java SE 6 ("Mustang"); some may be delayed
until Java SE 7 ("Dolphin").
|
|
Articles |
|
18 Oct 2005 |
|
| |
Best performance practices for Service Data Objects and the JDBC Data Mediator Service, Part 2: Optimize your SDO and JDBC DMS applications for performance
Study several techniques and coding best practices that you can use to improve the performance of your Service Data Objects (SDO) and Java(TM) DataBase Connectivity (JDBC) Data Mediator Service (DMS) application.
|
|
Articles |
|
14 Oct 2005 |
|
| |
3D graphics for Java mobile devices, Part 1: M3G's immediate mode
This article, the first in a two-part series, describes the Mobile 3D Graphics API (JSR 184). The author introduces you to 3D programming for Java mobile devices and shows how you can work with lights, cameras, and materials.
|
|
Articles |
|
11 Oct 2005 |
|
| |
JAXP validation
The latest version of the Java programming language -- Java 5.0 -- includes an improved, expanded version of the Java API for XML Processing (JAXP). A major addition to JAXP is the new validation API, which allows greater interactivity, support for XML Schema and RELAX NG, and the ability to make on-the-fly changes while validating. All of these improvements finally give Java developers an industrial-strength solution for XML validation. This article details the new API, from its basics to the more advanced features.
|
|
Articles |
|
11 Oct 2005 |
|
| |
Automate your team's build and unit-testing process
Extreme programming and agile methods recommend that the development process include continuous integration and unit testing. A pragmatic way to support these practices is to set up an automated system to build and test the latest version of your source code every time it changes. This article guides you through the practical issues involved in setting up your own Linux-based build server for Java projects.
|
|
Articles |
|
11 Oct 2005 |
|
| |
Get a better handle on Struts actions, with Spring
Struts Recipes co-author George Franciscus is
back with another great Struts integration recipe -- this time
for importing Struts applications into the Spring framework. Follow along
as George shows you how to revamp Struts actions so they can be managed
just like Spring beans. The result is a boosted Web framework that easily reaps the benefits of Spring AOP.
|
|
Articles |
|
11 Oct 2005 |
|
| |
ITFIM Scripting Cookbook: Scripted Configuration of IBM Tivoli Federated Identity Manager, Part 1
Discusses how to use Jython to Script ITFIM configuration for federated single sign-on
|
|
Articles |
|
07 Oct 2005 |
|
| |
The Spring series, Part 4: 1-2-3 messaging with Spring JMS
Quick-step through the basics of JMS messaging, with the Spring JMS framework and IBM WebSphere MQ 5.3.
|
|
Articles |
|
04 Oct 2005 |
|
| |
Build a dynamic Derby application
This tutorial shows you how to build a dynamic Java analysis application that connects to Apache Derby. Explore the dynamic way the database stores new application logic, changing the logic of the database without touching the core client program. And learn about Java archive (JAR) signing and how to provide security for the application that uses hot-swappable .jar files.
|
|
Tutorials |
|
04 Oct 2005 |
|
| |
Ajax for Java developers: Java object serialization for Ajax
If you're doing JavaWeb development using Asynchronous JavaScript and XML (Ajax), then delivering data from the server to the client is probably your top concern. In this second article in the Ajax for Java developers series, Philip McCarthy
walks you through five approaches to Java object serialization and gives you all the information you need to choose the data format and technology best suited to your application.
|
|
Articles |
|
04 Oct 2005 |
|
| |
Classworking toolkit: Combining source and bytecode generation
JiBX 1.0 uses classworking techniques to enhance the bytecode for compiled classes and directly generate new classes. Bytecode generation has some major advantages over working at the source code level, but it can sometimes get in the way of building and debugging your application. Even aside from issues of convenience, some developers just don't trust anything but "The Source." For JiBX 2.0, lead developer Dennis Sosnoski wants to support both source and bytecode generation techniques. In this article, he discusses some of the differences between source code and bytecode generation techniques and gives his take on how to reconcile the two.
|
|
Articles |
|
04 Oct 2005 |
|
| |
Taming Tiger: Are you SCJP 5 certified?
In April 2005, Sun updated its certification for J2SE 5. If you're interested in getting certified, or updating your current certification, this article provides a quick-and-dirty overview of the skills you'll need.
|
|
Articles |
|
30 Sep 2005 |
|
| |
A gentle introduction to SWT and JFace, Part 3: How to use TabFolder, Canvas, and StyledText
This installment of A gentle introduction to SWT and JFace expands on what you've learned about creating applications using Java technology, Eclipse, and the SWT and JFace libraries. Find out how to use tabular tree, canvas, styled text, slider, spinner, scale and other controls, as well as stack layouts.
|
|
Articles |
|
27 Sep 2005 |
|
| |
JDNC simplifies Java UI development
JDNC is an open source project that aims to make Java UI development easier. It offers a number of prebuilt components that provide functionality that many developers have to laboriously add to their Swing widgets. But perhaps more interestingly, it also provides data binding features that might change the way you link your data to your interfaces. In this hands-on tutorial, Java UI developer Jack Li Guojie guides you through using JDNC Swing Extensions to improve your Java UI without changing much of your existing code. You'll also see how to simplify your data-centric Java UI development by taking advantage of JDNC data binding and the DataSet API.
|
|
Tutorials |
|
27 Sep 2005 |
|
| |
Java theory and practice: Urban performance legends, revisited
The Java language is the target of a lot of abuse for
performance. And while some of it may well be deserved, a tour of message board and newsgroup postings on the
subject shows that there is a great deal of misunderstanding about
how a Java Virtual Machine (JVM) actually works. In this month's Java
theory and practice, Brian Goetz pokes some holes in the
oft-repeated performance myth of slow allocation in JVMs.
|
|
Articles |
|
27 Sep 2005 |
|
| |
Bluetooth boogies, Part 1: File transfer with JSR-82 and OBEX
Become familiar with the Java language library used to control a Bluetooth device and learn how JSR-82 API and Object Exchange can be used to transfer files between the client and server.
|
|
Articles |
|
27 Sep 2005 |
|
| |
Build a Derby calendar, Part 2: Embedding options
Continue learning how to build a calendar and reminder application using the Java language and the Apache Derby database. In Part 2 of this three-part series, you'll turn the classes -- which you created to access the database in Part 1 -- into three different applications using Derby's single-user embedded mode, its multiuser network mode, and a combination of the two from within a Web environment.
|
|
Tutorials |
|
20 Sep 2005 |
|
| |
Secrets of lightweight development success, Part 7: Java alternatives
The Java programming language is powerful, but it has significant limitations for lightweight development. For certain problems, other programming languages such as Ruby may lead to better productivity. Find out what's important for productivity in an application's language.
|
|
Articles |
|
20 Sep 2005 |
|
| |
Struts-Velocity integration
Struts master George Franciscus shows you how to integrate the Velocity Template Engine into your Struts applications.
|
|
Articles |
|
20 Sep 2005 |
|
| |
Practically Groovy: Of MOPs and mini-languages
Put your ear to the ground and listen closely -- MOP is on the move! Get a primer on the Meta Object Protocol, an old-is-new approach to building applications, languages, and applications as languages.
|
|
Articles |
|
20 Sep 2005 |
|
| |
Ajax for Java developers: Build dynamic Java applications
The page-reload cycle presents one of the biggest usability obstacles in Web application development and is a serious challenge for Java developers. In this series, author Philip McCarthy introduces a groundbreaking approach to creating dynamic Web application experiences. Ajax (Asynchronous JavaScript and XML) is a programming technique that lets you combine Java technologies, XML, and JavaScript for Java-based Web applications that break the page-reload paradigm.
|
|
Articles |
|
20 Sep 2005 |
|
| |
AOP@Work: Performance monitoring with AspectJ, Part 1
Say goodbye to scattered and tangled monitoring code,
as Ron Bodkin shows you how to combine AspectJ and JMX for a flexible,
modular approach to performance monitoring. In this first of two parts, Ron uses source code and
ideas from the Glassbox Inspector open source project to help you build
a monitoring system that provides correlated information to identify
specific problems, but with low enough overhead to be used in production
environments.
|
|
Articles |
|
13 Sep 2005 |
|
| |
Simplify and unify data with a Service Data Objects architecture
Discover the key concepts of the Service Data Objects (SDO) architecture and the power and flexibility it provides. SDO architecture is gaining wide popularity among the Java(TM) 2 Platform, Enterprise Edition (J2EE) community and architecting Service-Oriented Architecture (SOA) environments. It addresses the need for heterogeneous data integration in a world where IT solutions are becoming more complex and distributed.
|
|
Articles |
|
13 Sep 2005 |
|
| |
Build a Derby calendar, Part 1: Understanding JDBC
Build a calendar and reminder application using the Java language and the Apache Derby database in Part 1 of this three-part tutorial series. This tutorial starts by showing you how to install the database and exploring interactions with it through Java Database Connectivity (JDBC). Parts 2 and 3 will examine different options for including Derby in your application and Derby's transactional capabilities as we move from a single-user to a multiuser system. Finally, we'll move to a multimode system that includes a Web interface.
|
|
Tutorials |
|
13 Sep 2005 |
|
| |
An early look at JUnit 4
JUnit is the de facto standard unit testing library for the Java language. JUnit 4 is the first significant release of this library in almost three years. It promises to simplify testing by exploiting Java 5's annotation feature to identify tests rather than relying on subclassing, reflection, and naming conventions. In this article, obsessive code tester Elliotte Harold takes JUnit 4 out for a spin and details how to use the new framework in your own work. Note that this article assumes prior experience with JUnit.
|
|
Articles |
|
13 Sep 2005 |
|
| |
The Spring series, Part 3: Swing into Spring MVC
Learn how to develop MVC-based applications using the Spring framework, in this third installment of Naveen Balani's popular Spring series.
|
|
Articles |
|
06 Sep 2005 |
|
| |
Secrets of lightweight development success, Part 6: Persistence strategies
Persistence frameworks are an extremely important part of any Java technology application. The choices are daunting. So, too often, developers make the popular choice, whether it's Enterprise JavaBeans or Hibernate. Often, you don't need a full object relational mapping layer. Even if you do, other persistence solutions have much to offer. Hibernate is free and rich. Kodo JDO has excellent management and mapping support. iBATIS is a hybrid solution that maps objects to the result of SQL queries, rather than tables. Even JDO has its place. This article discusses each solution and gives you some ways to choose the best one.
|
|
Articles |
|
06 Sep 2005 |
|
| |
Classworking toolkit: Inside JiBX code generation
The JiBX framework builds on classworking techniques for fast and flexible conversions between Java objects and XML. But generating correct and verifiable bytecode isn't always easy, and lead developer Dennis Sosnoski has gone through some painful classworking experiences along the way to the 1.0 production release. He shares his insights in this article, discussing the internal structures used for code generation and the steps he's gone through to make sure that the generated code follows JVM rules.
|
|
Articles |
|
06 Sep 2005 |
|
| |
Java theory and practice: Decorating with dynamic proxies
The dynamic proxy facility, part of the java.lang.reflect package and added to the JDK in version 1.3, allows programs to create proxy objects, which can implement one or more known interfaces and dispatch calls to interface methods programmatically using reflection instead of using
the built-in virtual method dispatch. This process allows implementations to "intercept" method calls and reroute them or add functionality dynamically. This month, Brian Goetz explores several applications for dynamic proxies.
|
|
Articles |
|
30 Aug 2005 |
|
| |
An introduction to AOP
Follow along with Sing Li as he guides you through the basic concepts of aspect-oriented programming (AOP). AOP tools give you a way to separate the code for essential crosscutting concerns, such as logging and security, from your Java programs' core application logic cleanly. AOP can make your code more readable, less error-prone, and easier to maintain.
|
|
Tutorials |
|
30 Aug 2005 |
|
| |
Best performance practices for Service Data Objects and the JDBC Data Mediator Service, Part 1: Create an application with the JDBC DMS and SDOs
Write your Java DataBase Connectivity (JDBC) Data Mediator Service (DMS) code to perform a number of JDBC queries ranging from simple select statements to more advanced queries involving multiple tables. The authors introduce to you the basic principles behind Service Data Objects (SDOs) and the JDBC DMS that WebSphere Application Server V6.x provides. They use a basic hardware reservation data model as an example to demonstrate how to write your JDBC DMS code.
|
|
Articles |
|
30 Aug 2005 |
|
| |
Secrets of lightweight development success, Part 5: Agile development at conservative companies
Lightweight development works best with a lightweight process, but it can be tough to get a conservative company to adopt agile methodologies. Learn how you can propose and promote lightweight processes in your organization.
|
|
Articles |
|
30 Aug 2005 |
|
| |
Finding unresolved Plug-in dependencies in Eclipse
Trying to locate an unresolved plug-in dependency can be strenuous and time-consuming. Almost every plug-in depends on a bunch of other plug-ins, and those plug-ins, in turn, may depend on many more. If Eclipse does not load any single plug-in in this long chain, manually pinpointing that plug-in may take more time and effort than originally planned. If you wish there was a way to automate this plug-in check, read on.
|
|
Articles |
|
23 Aug 2005 |
|
| |
Define a custom tag for table display
Create more manageable Web apps and update code in one place. When you define a custom tag for tables that display in multiple places, the Tag class reflects any changes across all JSP pages. Learn to create just such a flexible tag -- with various HTML controls, including href, checkbox, radio button, text field, and combo box.
|
|
Articles |
|
23 Aug 2005 |
|
| |
The Eclipse Voice Tools Project
The Eclipse Voice Tools Project is a new effort that brings together companies and individuals from the voice industry to create a common set of standards-based, open source, voice-development tools. But how do you go about extending or contributing to the project's tools? This article explains how to set up and customize the Voice Tools Project environment. It also shows you the process involved in adding new functions.
|
|
Articles |
|
23 Aug 2005 |
|
| |
Practically Groovy: Functional programming with curried closures
Spice up your standard closures with the curry method, invented by Haskell Curry and found in the Groovy language since before the JSR compliant releases.
|
|
Articles |
|
23 Aug 2005 |
|
| |
The EJB Advocate: Which type of EJB component should assemble the data returned by a service?
The EJB Advocate takes a top-down view of service-oriented architectures in order to get to the bottom of whether a session or entity EJB component should assemble the data transfer objects returned by the service.
|
|
Articles |
|
17 Aug 2005 |
|
| |
Comment lines: Scott Johnson: Take a lifetime to be a good (and happy) programmer
A happy programmer knows what they're good at and what is really involved in that pie-in-the-sky job he or she desires. Inspired by an article on the average programmer's big rush to learn the practice of programming, the author shares his views on the topic.
|
|
Articles |
|
17 Aug 2005 |
|
| |
Embedded database development using Cloudscape and Java
This demonstration shows the benefits of embedded database development using Cloudscape and Java.
|
|
Demos |
|
16 Aug 2005 |
|
| |
Securing Java Card applications, Part 1: Building a Kerberos-enabled J2ME application
Smart cards take the functions you've come to expect in magnetic swipe cards to a whole new level: they can contain a large amount of data and even executable programs. The Java Card spec brings the power of the Java language to smart cards. In this series, Faheem Kahn shows you how to use the Java Card's power to build Kerberos-based security to a mobile application.
|
|
Articles |
|
16 Aug 2005 |
|
| |
Internationalization road hazards
Support in the Java language for multilingual and multicountry environments is strong, but it's not foolproof. If you're not careful, mistaken assumptions in three key areas can make their way into your code and cause it to be U.S.-centric. This article identifies these internationalization gotchas and gives you some techniques to help your applications become more usable across the globe.
|
|
Articles |
|
16 Aug 2005 |
|
| |
Using the Struts Validator
Follow along as Web development expert Brett McLaughlin guides you through the process of installing and configuring the Struts Validator component. The Validator, originally developed separately from and on top of Struts, is now an integral component of any professional Struts application programming. With the Validator, you can validate input in your Struts ActionForms. In this tutorial, you will learn to perform this validation declaratively, without touching your existing Java code.
|
|
Tutorials |
|
16 Aug 2005 |
|
| |
DB2 UDB performance tuning scenarios: Part 1, Use a Java program to tune DB2 UDB
This article explains step-by-step techniques that can be followed to monitor and tune a DB2 UDB database server. Using the supplied sample Java program "PERFORMER," you can learn these hands-on techniques, and experiment with various scenarios on your own system, using the Java program to simulate a workload executing SQL against a database. Many factors can affect the performance of a database server. This article focuses on how to tune some of the important DB2 UDB configuration parameters, as well as steps to capture and fix "bad queries."
|
|
Articles |
|
11 Aug 2005 |
|
| |
AOP@Work: New AJDT releases ease AOP development
AJDT Eclipse technology project leader Matt Chapman walks you through AJDT 1.2 and 1.3, the latest releases of the AspectJ development tools for Eclipse 3.0 and 3.1, respectively. The major focus of these releases is to more closely integrate AspectJ with the Eclipse platform and to offer AspectJ developers more of the advanced tooling support available to Java developers using Eclipse.
|
|
Articles |
|
09 Aug 2005 |
|
| |
SOA programming model for implementing Web services, Part 5: Service-oriented user interfaces
A service-oriented programming model can simplify the development of program-to-human interactions by abstracting interfaces, standardizing messages, and aggregating independent information sources at the presentation layer under the control of a user or administrator. This fifth article in the series on the programming model for IBM's SOA covers services that are user facing and, as well as services provided by users through the Human Task Manager. Previous articles in this series introduced a language-neutral data access and programming model for Web services based on service-oriented architecture (SOA) concepts.
|
|
Articles |
|
09 Aug 2005 |
|
| |
Introducing the JDesktop Integration Components
This article introduces the JDesktop Integration Components (JDIC), an open source project that's building components that bridge the gap between native applications and their Java counterparts. JDIC's single Java API lets your applications tap into native OS features while maintaining cross-platform support. It currently offers native Web browser (Internet Explorer or Mozilla) support, system tray support, file-extension integration, and other desktop features.
|
|
Articles |
|
09 Aug 2005 |
|
| |
Effective logging practices ease enterprise development
Bumps along the road are almost inevitable in enterprise development, and if you want to effectively tackle bugs in the late stages of the development process, you're going to need an effective logging strategy. But logging effectively in an enterprise application requires planning and discipline. In this article, consultant Charles Chan guides you through some best practices to help you write useful logging code from the beginning of your project.
|
|
Articles |
|
09 Aug 2005 |
|
| |
Classworking toolkit: Annotations vs. configuration files
Annotations let you specify metadata as part of your source code. With this feature, you can embed tool instructions in your code rather than creating separate configuration files that you then need to maintain in parallel to the source code. But, as Java consultant Dennis Sosnoski explains, configuration files still have their uses, especially for aspect-like functions that cut across the source code structure of an application.
|
|
Articles |
|
02 Aug 2005 |
|
| |
JSF for nonbelievers: JSF component development
In this final installment in his four-part JSF for nonbelievers series, Rick Hightower shows you the time-saving moves that will convince you, for once and for all, that JSF component development is easier than you think. Editor's note: Since publication, Sun has open sourced JSF 1.2 under their CDDL license. See Resources for a link to the new project page. For details on getting started with JSF 1.2, now integrated in JEE 5, see Richard Hightower's
tutorial series.
|
|
Articles |
|
26 Jul 2005 |
|
| |
Java theory and practice: Be a good (event) listener
The Observer pattern, most often seen in Swing development, is also very useful for decoupling components in situations other than GUI applications. However, some common pitfalls with registering or invoking listeners exist. In this installment of Java theory and practice, Java therapist Brian Goetz offers some feel-good advice on how to be a good listener -- and how to be nice to your listeners, too.
|
|
Articles |
|
26 Jul 2005 |
|
| |
A gentle introduction to SWT and JFace, Part 2: How to use combo, list, table, and tree controls
This installment of A gentle introduction to SWT and JFace expands on what you've learned about creating simple Standard Widget Toolkit (SWT) applications using Java technology, Eclipse, and the SWT and JFace libraries. This installment shows you how to use combo, list, table, and tree controls, as well as form layouts and reusable helper methods.
|
|
Articles |
|
19 Jul 2005 |
|
| |
SWT and JFace, Part 2: A gentle introduction
Part 2 of the SWT and JFace series expands on what you've learned about creating simple Standard Widget Toolkit (SWT) applications using Java technology, Eclipse, and the SWT and JFace libraries. This installment shows you how to use combo, list, table, and tree controls, as well as form layouts and reusable helper methods.
|
|
Articles |
|
19 Jul 2005 |
|
| |
Taming Tiger: The Collections Framework
You're probably quite familiar with the new Java 5 language support for generics, the concurrent utility libraries, and their effect on the Collections Framework, but those aren't the only changes to the Collections Framework libraries in Tiger. This month, John Zukowski covers several other enhancements, including the new collection types and the additional features of existing classes and interfaces.
|
|
Articles |
|
19 Jul 2005 |
|
| |
Practically Groovy: Groovy's growth spurt
With the release (and subsequent releases) of a JSR-241 compliant
parser, the changes to Groovy's syntax have been formalized -- which
means if you weren't paying attention before, now's the time to start. This month, resident Groovy practitioner Andrew Glover walks through most important changes to Groovy's syntax and shows you a handy feature you won't find in classic Groovy.
|
|
Articles |
|
19 Jul 2005 |
|
| |
Ruby on Rails and J2EE: Is there room for both?
Ruby on Rails is a relatively new Web application framework built on the Ruby language. It is billed as an alternative to existing enterprise frameworks, and its goal, in a nutshell, is to make your life -- or at least the Web development aspects of it -- easier. In this article, Aaron Rustad compares and contrasts some of the key architectural features of Rails and traditional J2EE frameworks.
|
|
Articles |
|
12 Jul 2005 |
|
| |
AOP@Work: Introducing AspectJ 5
Now in its second milestone build, AspectJ 5 is a big leap forward for aspect-oriented programming on the Java platform. A major focus of AspectJ 5 is on providing support for the new Java language features introduced in Java 5, including annotations and generics. In addition, the language contains new features not tied to Java 5, such as an annotation-based style for writing aspects, improved load-time weaving, and a new aspect instantiation model. Get a first look at AspectJ 5 from Adrian Colyer, lead developer on the project, as he introduces you to both the AspectJ 5 language and the release containing the AspectJ compiler and associated tools.
|
|
Articles |
|
12 Jul 2005 |
|
| |
Eclipse and design patterns
This demo guides you through installation of the PatternBox design pattern plugin for Eclipse. You will also learn how to create a Facade pattern using the new plugin.
|
|
Demos |
|
11 Jul 2005 |
|
| |
Build a Web service Client using JSF and SDO
This demo shows how to easily find a Web service from a registry on the Internet, and create a simple client based on Service Data Objects (SDO) and JavaServer Faces (JSF). It's all done without writing one line of code.
|
|
Demos |
|
11 Jul 2005 |
|
| |
Adding Security to your Web Services Digital Signatures, Part 2
This demo shows how to expose a simple Java class as a Web service that requires digitally signed requests. You'll see how a generated client is tested and how the signed SOAP request is examined. And it's all done without writing one line of code.
|
|
Demos |
|
11 Jul 2005 |
|
| |
Using the Java JoinRowSet implementation with DB2 UDB
The efforts of JSR114 bring you the offering of serializable disconnected objects in Java 1.5. With these objects, you can connect to a DB2 UDB database and grab data locally. You can then release your database connection and manipulate the data offline. At a later time, you can reconnect to your database and synchronize changes made to the disconnected objects. In this article, I will show you how you can perform offline JOIN operations on your DB2 Universal Database data using the JoinRowSet interface. Sample code included.
|
|
Articles |
|
07 Jul 2005 |
|
| |
Classworking toolkit: Use J2SE 5.0 features on older JVMs
Many of the J2SE 5.0 language features would be just as useful for older JVMs, but the compiler that implements these features generates code that requires JDK 5.0 or later. Fortunately, there's an open source project that bridges the gap between J2SE 5.0 and older JVMs -- Retroweaver. Retroweaver converts your class files to eliminate the JDK 5.0 dependency while adding its own library of support functions to make most 5.0 features fully usable in older JVMs. If you like J2SE 5.0 language features but can't make the jump to using JDK 5.0 at run time, Retroweaver may be just what you need.
|
|
Articles |
|
06 Jul 2005 |
|
| |
Integrate a secured Web service into a J2EE project
Integrate a secured Web service into an IBM(R) WebSphere(R) Studio Application Developer J2EE project. This tutorial shows you how with a step-by-step Enterprise JavaBeans (EJB) project sample application.
|
|
Tutorials |
|
06 Jul 2005 |
|
| |
Introduction to Swing
This hands-on introduction to Swing, the first in a two-part series on Swing programming, walks through the essential components in the Swing library. Java developer and Swing enthusiast Michael Abernethy guides you through the basic building blocks and then assists as you build basic but functional Swing application. Along the way you'll learn how to use models to ease the process of dealing with the data.
|
|
Tutorials |
|
29 Jun 2005 |
|
| |
Intermediate Swing
This tutorial builds on Introduction to Swing, which introduced the basics of Swing programming and the flight reservation system application. In this hands-on tutorial, Swing programmer Michael Abernethy walks you through more advanced Swing techniques like writing thread-safe code, building custom components, and customizing the look and feel to create a more polished and powerful UI.
|
|
Tutorials |
|
29 Jun 2005 |
|
| |
Simplify XML processing with XJ
Extend Java technology with first-class support for XML, XPath, and XML Schema to make XML processing programs easier to write, more robust, and more efficient. This article provides a gentle introduction to XML Enhancements for Java (XJ), a set of language extensions that adds direct support for XML in the Java programming language. The authors are part of the team that developed XJ.
|
|
Articles |
|
28 Jun 2005 |
|
| |
CSP for Java programmers, Part 1
While the constructs of multithreaded application programming in the Java language aren't difficult to learn, many developers struggle with applying them correctly. As a result, multithreaded programs are often far more prone to subtle errors than we would like them to be, leading some developers to avoid them at all costs, even when concurrency and parallelism would clearly yield the most elegant design. In this three-part article, regular developerWorks contributor Abhijit Belapurkar sets you on the path to overcoming your fear of multithreaded programming for good, starting here with an overview of the most common issues involved: race hazards, deadlocks, livelocks, resource starvation, and more.
|
|
Articles |
|
21 Jun 2005 |
|
| |
Centralizing help in Eclipse
This article demonstrates how to take advantage of the dynamic nature of Eclipse's help and plug-in architecture to allow you to create a centralized help repository. It focuses on how to create an Eclipse plug-in with a help table of contents, how to use the Infocenter to externalize your help files, and how to create a new menu item that allows you to access the centralized help repository right from the Eclipse main menu.
|
|
Articles |
|
21 Jun 2005 |
|
| |
CSP for Java programmers, Part 2
In this second installment of his three-part introduction to Communicating Sequential Processes (CSP) for Java programmers, Abhijit Belapurkar shows you how to use the Java-based JCSP library to write multithreaded Java applications that are guaranteed to be free of concurrency issues such as race hazards, deadlocks, livelocks, and resource starvation.
|
|
Articles |
|
21 Jun 2005 |
|
| |
CSP for Java programmers, Part 3
Abhijit Belapurkar concludes his three-part introduction to CSP for Java developers with an inquiry into advanced topics in JCSP development, including parallels to AOP, JCSP compared to java.util.concurrent, and advanced synchronization with JCSP.
|
|
Articles |
|
21 Jun 2005 |
|
| |
Create i-mode content with DoJa
Most people have heard of i-mode. Less well known is its Java environment, DoJa, which provides a platform for highly interactive, graphical, and networked applications. This article introduces DoJa and its different versions, and explains how it relates to its mobile Java cousin, the Mobile Information Device Profile (MIDP).
|
|
Articles |
|
21 Jun 2005 |
|
| |
AOP@Work: Design with pointcuts to avoid pattern density
In "JUnit: A Cook's Tour," authors Erich Gamma and Kent Beck discuss the design of JUnit. They point out that TestCase, like key abstractions in many mature frameworks, has a high pattern density, making it easy to use but hard to change. In this fourth installment of the AOP@Work series, Wes Isberg revisits the Cook's Tour and shows you how using AOP pointcuts rather than object-oriented designs can help you avoid some of the pattern density that makes mature designs hard to change.
|
|
Articles |
|
14 Jun 2005 |
|
| |
DB2 application development: Tracing with the DB2 Universal JDBC Driver
Identify program errors and optimize database access to your Java apps by using the JDBC trace facilities. This article first looks at the CLI-based trace facilities of the DB2 Legacy JDBC driver, then describes the trace facilities of the new DB2 Universal JDBC Driver and demonstrates how to use these trace facilities by example.
|
|
Articles |
|
09 Jun 2005 |
|
| |
When Maven encounters Eclipse
Maven is a powerful tool, but you need to integrate it into one of the popular integrated development environments (IDEs) to bring its power closer to hand and make your work easier, thus increasing your productivity and project quality. This tutorial provides a concrete example of how to make Maven and Eclipse collaborate.
|
|
Tutorials |
|
07 Jun 2005 |
|
| |
Secrets of lightweight development success, Part 2: How to lighten up your containers
Businesses need the enterprise services that heavyweight architectures, such as Enterprise JavaBeans (EJB) technology, provide, but such architectures can be overkill for everyday problems. This article introduces lightweight containers and explains how they can provide the services your business needs without tying you to a given programming model.
|
|
Articles |
|
07 Jun 2005 |
|
| |
JCA 1.5, Part 3: Message inflow
In this final installment of his three-part series on the latest version of the J2EE Connector Architecture (JCA), David Currie introduces the new message-inflow contract. This enhancement enables a resource adapter to invoke an application asynchronously through a message-driven bean. This article is essential reading if you want use this functionality in an existing resource adapter or are considering writing a new JCA 1.5 resource adapter. It should also be of interest if you write applications that use resource adapters and want to know more about what goes on behind the scenes.
|
|
Articles |
|
07 Jun 2005 |
|
| |
Classworking toolkit: Annotations with ASM
Are you tired of building and maintaining toString() methods for all your data classes? In this edition of Classworking toolkit, consultant Dennis Sosnoski shows how you can automate the process using J2SE 5.0 annotations and the ASM bytecode manipulation framework. He takes advantage of the new J2SE 5.0 instrumentation API to invoke ASM as classes are loaded into the JVM, providing on-the-fly class modification at run time.
|
|
Articles |
|
07 Jun 2005 |
|
| |
Eclipse for Visual Studio developers
This tutorial steps a new user of Eclipse through his first Eclipse project. It is geared toward an existing Visual Studio developer, and will present Eclipse concepts, terminology, and workflow in the context of Visual Studio. The tutorial will draw parallels between the two IDEs and, where appropriate, point out key differences.
|
|
Tutorials |
|
31 May 2005 |
|
| |
All about JAXP, Part 2
Part 1 of this two-part series introduced the Java API for XML Processing (JAXP) and its parsing and validation features. JAXP also offers Java programmers the ability to transform XML documents using Extensible Stylesheet Language (XSL). Through both direct programmatic access and XSL templating, JAXP makes conversion from one XML format to another an easy task. This article shows you how to use JAXP to transform XML documents and how to cache XSL stylesheets for the best performance possible.
|
|
Articles |
|
31 May 2005 |
|
| |
Java theory and practice: Make database queries without the database
When you have a hammer, everything looks like a nail (as the old saying goes). But what if you don't have a hammer? Well, sometimes, you can borrow a hammer. Then, hammer in hand, you can bang the virtual nails with the borrowed hammer, return it, and no one is the wiser. In this month's Java theory and practice, Brian Goetz demonstrates how data manipulation hammers such as SQL or XQuery can be applied to ad-hoc data.
|
|
Articles |
|
31 May 2005 |
|
| |
Implementing and troubleshooting Java on AIX: Quick reference
Get a complete set of instructions for downloading, installing, configuring, and troubleshooting Java(TM) for the IBM AIX(R) operating system.
|
|
Articles |
|
26 May 2005 |
|
| |
Exploiting Maven in Eclipse
Maven is gaining recognition as a general build system and is beginning to outrun Java technology. This article isn't intended to be a Maven tutorial. It compares Maven to other technologies and gives you insight to where Maven and Eclipse meet, and how you can make these tools collaborate.
|
|
Articles |
|
24 May 2005 |
|
| |
Building smart J2ME mobile applications, Part 2
This tutorial shows you how to synchronize order information stored in the J2ME Record Management System with a remote, open source Cloudscape database. You'll build your own two-way synchronization logic. The mobile application supplies all the information necessary for a remote sever-based application to act upon, ship the ordered product, and update the product information in a remote Cloudscape database. The mobile user can track the status of the order by synchronizing with this database.
|
|
Tutorials |
|
24 May 2005 |
|
| |
Taming Tiger: AWT grows up
The Abstract Window Toolkit is the basis of the Swing component set. Follow along with John Zukowski as he discusses the aspects of AWT that changed with the 5.0 release of the Java 2 platform. These include PointerInfo and MouseInfo for recovering pointer position and z-order management for screens with overlaid components.
|
|
Articles |
|
24 May 2005 |
|
| |
Plotting with Draw2D and SWT with the Java platform
Plotting charts or graphs with the Java platform has always captured developers' interest. Traditionally, Java language developers have plotted charts with java.awt.Graphics or Java 2D API. Some may have even explored ready-made open source kits like JSci to draw charts. Many available options restrict you to AWT or Swing, however. To minimize dependency on third-party tool kits or simplify the basics of drawing charts, consider using Draw2D and writing your own code for charting or plotting.
|
|
Articles |
|
24 May 2005 |
|
| |
Practically Groovy: Stir some Groovy into your Java apps
Ever thought about embedding Groovy's simple, easy-to-write scripts in your more complex Java programs? In this installment of Practically Groovy, Andrew Glover shows you the many ways to incorporate Groovy into your Java code and explains where and when it's appropriate to do so.
|
|
Articles |
|
24 May 2005 |
|
| |
Geronimo! Part 2: Tame this J2EE 1.4 bronco
Geronimo, the Apache Software Foundation's J2EE 1.4 server project, is integrating a large suite of existing open source services to achieve J2EE 1.4 compliance. Part 1 of this two-part series explored the reason for Geronimo, its design goals and architecture, and some core concepts and terminology. In this final part, Sing Li cuts to the chase and gets hands-on with Geronimo. Using the latest Geronimo distribution, you'll test and deploy a Web application, an enterprise application, Enterprise JavaBeans (EJBs), and more.
|
|
Articles |
|
24 May 2005 |
|
| |
Accessing IBM Tivoli Directory Server through Handheld Devices
This article focuses on creating generic client API's using KSOAP (i.e. SOAP implementation on handheld devices) which are portable with the IBM Tivoli DSML server using which the IBM Tivoli Directory Server can be accessed.
|
|
Articles |
|
20 May 2005 |
|
| |
Java certification success, Part 4: SCEA
This hands-on tutorial helps SCEA certification aspirants clear the first part of the SCEA certification exam, a knowledge-based, multiple-choice exam. The tutorial introduces the main concepts and then builds upon them to provide readers with a solid foundation of the exam goals. Each section of the tutorial reinforces the readers' understanding through examples and practice questions.
|
|
Tutorials |
|
20 May 2005 |
|
| |
Geronimo! Part 1: The J2EE 1.4 engine that could
Java-based open source development has come a long way since the early days of developers sharing GUI libraries. Geronimo is a large-scale project attempting to create a certified J2EE 1.4 server based on existing open source components. Take a tour through the Geronimo maze with Sing Li as your guide. In this first part of a two-part series, you'll discover Geronimo's elegant design and bold architecture.
|
|
Articles |
|
17 May 2005 |
|
| |
All about JAXP, Part 1
The Java API for XML Processing (JAXP) lets you validate, parse, and transform XML using several different APIs. JAXP provides both ease of use and vendor neutrality. This article, the first of a two-part series introducing JAXP, shows you how to take advantage of the API's parsing and validation features. Part 2 will cover XSL transformations using JAXP.
|
|
Articles |
|
17 May 2005 |
|
| |
Better MIDlets by design
MIDP promised to both standardize and simplify application development for mobile environments, but it hasn't. In this article, regular Wireless zone contributor Mikko Kontio reveals the limitations of MIDP, then shows you how smart design decisions can help you build robust, easy-to-use MIDlets anyway.
|
|
Articles |
|
17 May 2005 |
|
| |
AOP@Work: Enhance design patterns with AspectJ, Part 2
Nicholas Lesiecki continues his discussion of the benefits of implementing design patterns with aspect-oriented techniques with this in-depth study of the Observer pattern. In this article of the AOP@Work series, he illustrates how AspectJ allows complex patterns to be converted into reusable base aspects, thus enabling framework authors to supply prebuilt libraries of patterns for developers to exploit.
|
|
Articles |
|
17 May 2005 |
|
| |
AOP@Work: Enhance design patterns with AspectJ, Part 1
Design patterns have long been part of the experienced developer's tool chest. Unfortunately, because patterns can affect multiple classes, they can also be invasive and hard to (re)use. In this two-part article, the third in the AOP@Work series, Nicholas Lesiecki shows you how AOP solves this problem by fundamentally transforming pattern implementation. He examines three classic Gang of Four (GoF) design patterns (Adapter, Decorator, and Observer) and discusses the practical and design benefits of implementing them with aspect-oriented techniques.
|
|
Articles |
|
17 May 2005 |
|
| |
Classworking toolkit: ASM classworking
In this edition of Classworking toolkit, consultant Dennis Sosnoski compares the ASM bytecode manipulation framework to the Byte Code Engineering Library (BCEL) and Javassist frameworks he previously discussed in his Java programming dynamics series. ASM claims to be small and fast -- but how does it match up with the other frameworks? Dennis uses an example from his earlier series to evaluate both usability and performance.
|
|
Articles |
|
12 May 2005 |
|
| |
Search RDF data with SPARQL
As more data is being stored in RDF formats like RSS, a need has arisen for a simple way to locate specific information. SPARQL, a powerful new query language fills that space, making it easy to find the data you need in the RDF haystack. Take a tour of SPARQL's features and learn how to use SPARQL queries from your own Java applications with the Jena Semantic Web Toolkit.
|
|
Articles |
|
10 May 2005 |
|
| |
Create, deploy, and debug Apache Geronimo applications
The Eclipse project has been providing a high-quality and extensible integrated development environment to the open source community for several years now. Get a head start in using the new Eclipse plug-in to develop and deploy Web applications to the Apache Geromimo server. IBM Senior Technical Staff Member Tim Francis walks you through the details.
|
|
Articles |
|
10 May 2005 |
|
| |
Building a better J2EE server, the open source way
Gluecode Software is among the growing number of companies that are successfully commercializing open source software, and it has incorporated several up-and-coming open source middleware components -- including Apache Geronimo and Apache Derby, among others -- into a J2EE application server stack. After the recent announcement of IBM's acquisition of Gluecode, we sat down with one of Geronimo's main contributors and CTO of Gluecode, Jeremy Boynes, to hear his perspectives on Geronimo, Java directions, and the state of open source.
|
|
Articles |
|
10 May 2005 |
|
| |
Navigate the file system on a mobile device
The Java 2 Platform, Micro Edition (J2ME) Mobile Device Information Profile (MIDP) does not provide out-of-the-box support for accessing a file system. The optional package that provides this capability is defined by Java Specification Request (JSR) 75. Two packages are included in JSR 75: the Personal Information Management (PIM) package and the FileConnection package. This tutorial focuses on the FileConnection package, with an emphasis on learning how to navigate a directory tree and access files. The tutorial takes you through the steps to build a simple file and directory explorer application. It includes moving through a directory hierarchy, viewing file permissions, and opening and reading a file's contents.
|
|
Tutorials |
|
09 May 2005 |
|
| |
JCA 1.5, Part 2: Work management and transaction inflow
David Currie continues his three-part series on enhancements and changes in the latest version of the J2EE Connector Architecture (JCA). In this article, he introduces the new JCA 1.5 work-management contract, which lets a resource adapter utilize an application server's capabilities for scheduling and processing work. With the help of another JCA enhancement -- transaction-inflow support -- an enterprise information system can perform that work under its own transaction.
|
|
Articles |
|
04 May 2005 |
|
| |
Measure test coverage with Cobertura
Cobertura is an open source tool that measures test coverage by instrumenting a code base and watching which lines of code are and are not executed as the test suite runs. In addition to identifying untested code and locating bugs, Cobertura can optimize code by flagging dead, unreachable code and can provide insights into how an API operates in practice. Elliotte Rusty Harold shares how you can take advantage of Cobertura using code-coverage best practices.
|
|
Articles |
|
03 May 2005 |
|
| |
Java theory and practice: Enable initialization atomicity
Decisions made during API design can have an effect on the API's usability. In designing an API, you need to put yourself in your user's shoes, imagining how the API might be used, and try and make the common use cases convenient for the user. This month, columnist Brian Goetz discusses an API design technique, the self-return idiom, that can make life easier for users of your API in certain circumstances. Share your thoughts on this article with the author and other readers in the accompanying discussion forum.
|
|
Articles |
|
27 Apr 2005 |
|
| |
Troubleshooting headless Ant builds with Rational Application Developer
This article describes common pitfalls when using the headless Ant feature with WebSphere Studio Application Developer or Rational Application Developer. ("Headless" means running builds from the command line without using the WebSphere Studio or Rational Application Developer GUI.)
The headless Ant feature lets you run a series of unattended tasks, such as build and deploy.
|
|
Articles |
|
27 Apr 2005 |
|
| |
The essential Java language library
Wouldn't it be nice if there were a list of the books and Web sites that you must have as a professional? This article is that list. It contains the most important books and Web sites every professional Java language programmer needs on the bookshelf or bookmarked in the browser.
|
|
Articles |
|
26 Apr 2005 |
|
| |
JSF for nonbelievers: JSF conversion and validation
JavaServer Faces (JSF) provides a standard conversion, validation, and messaging framework that accommodates most form-processing needs while ensuring data-model integrity. In this third article in the JSF for nonbelievers series, Paul Tabor and Rick Hightower show you how simple it can be to plug-in your own custom flavor of conversion or validation, even for complicated applications. Editor's note: Since publication, Sun has open sourced JSF 1.2 under their CDDL license. See Resources for a link to the new project page. For details on getting started with JSF 1.2, now integrated in JEE 5, see Richard Hightower's
tutorial series.
|
|
Articles |
|
19 Apr 2005 |
|
| |
Taming Tiger: Beyond the basics of enumerated types
In November 2004, Brett McLaughlin got you started using enumerated types with the Java 5.0 platform. In this month's Taming Tiger tip, John Zukowski explains how to work with enumerated classes and their predefined methods and shows how to add constructors, override methods, and have instance variables.
|
|
Articles |
|
19 Apr 2005 |
|
| |
Load list values for improved efficiency
Reduce the number of database hits and improve your Web application's efficiency when you load common shared list values only once. In this code-filled article, learn to load the values for drop-down lists when your Web application starts and then to share these loaded list values among all the users of your application.
|
|
Articles |
|
19 Apr 2005 |
|
| |
The buzz about Apache Beehive
Beehive is a new Apache project that simplifies Java 2 Platform, Enterprise
Edition (J2EE) and Web services programming. This article shows how to get started with
Beehive and offers a sneak preview of Pollinate, an Eclipse plug-in that creates
Beehive applications.
|
|
Articles |
|
19 Apr 2005 |
|
| |
Tip: Javadoc as XML
A lot of value is locked up in your Java code: all your classes and interfaces, as well as their instance variables and methods. You can use these data to create documentation, to build code generators, or to provide metrics for project reporting.
|
|
Articles |
|
14 Apr 2005 |
|
| |
AOP@Work: AOP and metadata: A perfect match, Part 2
In this second half of his two-part article on combining metadata and AOP, author and AOP practitioner Ramnivas Laddad suggests a novel way to conceptualize metadata as a signature in a multidimensional concern space. He also introduces a series of guidelines for effectively combining metadata and AOP and discusses the impact of metadata annotations on the adoption of aspect-oriented programming.
|
|
Articles |
|
12 Apr 2005 |
|
| |
Practically Groovy: Mark it up with Groovy Builders
Groovy Builders let you mimic markup languages like XML, HTML, Ant tasks, and even GUIs with frameworks like Swing.They're especially useful for rapid prototyping and, as Practically Groovy columnist Andrew Glover shows you this month, they're a handy alternative to data binding frameworks when you need consumable markup in a snap!
|
|
Articles |
|
12 Apr 2005 |
|
| |
Exploring Eclipse's ASTParser
This article shows how the ASTParser can be used to create and parse code. It shows also the compilation facilities provided by the Eclipse JDT.
|
|
Articles |
|
12 Apr 2005 |
|
| |
Build smart J2ME mobile applications, Part 1
This tutorial is the first in a two-part series designed as a step-by-step guide to building a smart Java 2 Platform, Micro Edition (J2ME) mobile application. In this tutorial you learn how to build a simple mobile application for order placement. The example application uses the J2ME record management system (J2ME RMS) to store order information and a MIDlet to perform the necessary logic of creating and accessing the database application. You learn how to work with the J2ME RMS, craft a MIDlet, and deploy the resulting application to a J2ME environment.
|
|
Tutorials |
|
05 Apr 2005 |
|
| |
JCA 1.5, Part 1: Optimizations and life-cycle management
In the first of a three-part series, Java developer David Currie introduces some Java 2 Enterprise Edition (J2EE) Connector Architecture (JCA) 1.5 optimizations that should make your existing or new outbound resource adapters go faster. He also takes a look at some additions that let resource adapters take on a new life of their own. This series is essential if you want to improve the performance of -- or add new functionality to -- existing resource adapters or are considering writing a new JCA 1.5 resource adapter. It should also be of interest if you write applications that use resource adapters and want to know a little more about what goes on behind the scenes.
|
|
Articles |
|
05 Apr 2005 |
|
| |
Classworking toolkit: Performance tracing with aspects
In this edition of Classworking toolkit, consultant Dennis Sosnoski takes up where he left off last month by applying an aspect-oriented approach to performance analysis. He investigates a client application using the Apache Axis Web services framework to find where the execution time is being spent. Along the way, Dennis looks into the issue of measuring time intervals in Java code and shows how you can find the granularity and overhead of the timer implementation on your system.
|
|
Articles |
|
05 Apr 2005 |
|
| |
Use the WebRowSet implementation with DB2 UDB
The WebRowSet interface is a product of JSR-114, the efforts of which brought us the offering of the JDBC Rowset in Java 1.5. RowSet objects allow for disconnected interaction with a backend database. This article sheds light on the WebRowSet, which extends from the javax.sql.RowSet interface. The WebRowSetImpl class, Sun's reference implementation of the WebRowSet interface will be showcased. You will see the innate relationship of the WebRowSet with XML.
|
|
Articles |
|
31 Mar 2005 |
|
| |
Create internationalized JSP applications
Designing Java Server Pages (JSP) applications for an international audience is more of an art than a science, involving much more than meets the eye. The key to success is to understand the unique server-side problems associated with internationalization. Java developer Sing Li clarifies the key problem and presents two solutions based on tried-and-true techniques.
|
|
Articles |
|
29 Mar 2005 |
|
| |
Using Aspects to autonomic-enable legacy applications
Learn how to use Aspects to generate Common Base Events in any legacy Java application, without modifying the original application source. This article shows you how and also provides an example framework that can be used with your applications today.
|
|
Articles |
|
29 Mar 2005 |
|
| |
Java theory and practice: Screen-scraping with XQuery
XQuery is a W3C standard for extracting information from XML documents, currently spanning 14 working drafts. While the majority of interest in XQuery is centered around querying large bases of semi-structured document data, XQuery can be surprisingly effective for some much more mundane uses as well. In this month's Java theory and practice, columnist Brian Goetz shows you how XQuery can be used effectively as an HTML screen-scraping engine.
|
|
Articles |
|
22 Mar 2005 |
|
| |
Develop P2P applications with device discovery technologies
Device discovery technology is one of the primary technologies of peer-to-peer (P2P) computing. This article illustrates how to use device discovery technology to enhance the performance of wireless applications in a P2P environment. With practical examples as well as a more advanced look at the technology, the writer addresses common setbacks and industrial product design techniques when implementing this popular technology.
|
|
Articles |
|
22 Mar 2005 |
|
| |
Introducing Hamlets
Servlets are a key component of server-side Java(TM) development, but despite a number of attractive traits, servlets do not support or enforce the separation of content and presentation. To master that functionality, Rene Pawlitzek proposes Hamlets -- servlet extensions that provide this functionality within a lightweight framework implemented with less than 500 lines of Java source code.
|
|
Articles |
|
22 Mar 2005 |
|
| |
Java Plug-ins for browsers on OS/2
Plug-ins are software programs designed to integrate with Web browsers and add new capabilities to the browsers. Get an introduction to Java(TM) Plug-in and learn how to configure Java Plug-ins, from various vendors, for different browsers on IBM(R) OS/2(R) Operating Systems.
|
|
Articles |
|
17 Mar 2005 |
|
| |
Practically Groovy: Go server-side up, with Groovy
The Groovlet and GroovyServer Pages (GSP) frameworks are built on the shoulders of the Java Servlet API. Unlike Struts and JSF, however, Groovy's server-side implementation isn't meant for all occasions. Rather, it's a simplified alternative for developing server-side applications quickly and easily. Follow along with Groovy advocate Andrew Glover as he introduces these frameworks and demonstrates their use.
|
|
Articles |
|
15 Mar 2005 |
|
| |
Taming Tiger: Virtual machine updates
In this installment of Taming Tiger, John Zukowski shows you how the latest Java virtual machine improves startup time, reduces memory requirements, and improves performance. With Tiger, you get a shared data archive, new thread scheduling algorithms, and a fatal error handler for those times when things don't go well.
|
|
Articles |
|
15 Mar 2005 |
|
| |
How to integrate Python 2.3 with the Java Native Interface on AIX 5L
Do you need to resolve the Python 2.3 runtime problem with the Java(TM) Native Interface (JNI) on AIX 5L(TM)? Nam Keung and Roger Leuckie show you how to resolve Python 2.3 program error linking with the JNI program by using a list of sample code to integrate Python 2.3 with JNI call.
|
|
Articles |
|
10 Mar 2005 |
|
| |
Java batch jobs on z/OS and OS/390
Java(TM) has many uses on z/OS(R) and OS/390(R) outside the confines of a Web server environment. Kirk Wolf and Steve Goetze explain how you can effectively run Java programs in a z/OS or OS/390 batch environment.
|
|
Articles |
|
10 Mar 2005 |
|
| |
Classworking toolkit: Putting aspects to werk
Aspect-oriented programming (AOP) promises to keep code clean by separating out functionality that applies across the application, rather than to a particular class or package. Logging is one of the commonly used examples of this type of function. Can AOP help with logging? In this article, developer and AOP enthusiast Dennis Sosnoski looks at using the AspectWerkz framework to find out.
|
|
Articles |
|
08 Mar 2005 |
|
| |
AOP@Work: AOP and metadata: A perfect match, Part 1
In this first half of a two-part article, author Ramnivas Laddad provides a conceptual overview of the new Java metadata facility and shows where AOP could most benefit from the addition of metadata annotations. He then walks you through a five-part design refactoring, starting with a metadata-free AOP implementation and concluding with one that combines the Participant design pattern with annotator-supplier aspects.
|
|
Articles |
|
08 Mar 2005 |
|
| |
Test your tests with Jester
A comprehensive unit-test suite is a necessity for a robust program. But how can you be sure that your test suite is testing everything it should? Jester, Ivan Moore's JUnit test tester, excels at finding test-suite problems and provides unique insights into the structure of a code base. Elliotte Rusty Harold introduces Jester and shows how to use it for best results.
|
|
Articles |
|
03 Mar 2005 |
|
| |
JSF for nonbelievers: The JSF application lifecycle
In this second article in his four-part JSF for nonbelievers series, Rick Hightower introduces the major phases of the JavaServer Faces (JSF) request processing lifecycle. Using a sample application, he walks you through the six phases of a request process. Along the way, he shows you how to combine JSF with JavaScript technology for immediate event handling and completes your introduction to the JSF component model with a first look at many of the components that ship with JSF. Editor's note: Since publication, Sun has open sourced JSF 1.2 under their CDDL license. See Resourcesfor a link to the new project page. For details on getting started with JSF 1.2, now integrated in JEE 5, see Richard Hightower's
tutorial series.
|
|
Articles |
|
01 Mar 2005 |
|
| |
Assess Java RAS functions directly
This article is for developers working with the IBM(R) Virtual Machine for Java(TM) (JVM), predominately on z/OS(R). Following practical examples, learn how to use the Java Virtual Machine Reliability Accessibility Serviceability Interface (JVMRI) to inject signals directly into JVM. Follow along as Richard Cole gives a simple example of how you can use JVMRI to get dumps out of JVM. Find out how the agent works, how to compile it and load it into the JVM, how the trigger for this agent works, and how to run the trigger to get a dump.
|
|
Articles |
|
24 Feb 2005 |
|
| |
StatCVS offers a view into CVS repository activity
StatCVS is a handy utility for creating charts of CVS repository activity. Tom Copeland explains how to install and run StatCVS, then explores running StatCVS reports on a server, StatCVS internals, and more.
|
|
Articles |
|
22 Feb 2005 |
|
| |
Wireless messaging with JXTA, Part 2: Implement JXTA-for-JMS
Learn how to implement the bridge between a Java 2 Platform, Micro Edition (J2ME) client and a Java Message Service (JMS) application using JXTA (JXTA-for-JMS, or JXTA4JMS for short). Use cases show how a J2ME device or a JMS client uses JXTA4JMS. The article also describes the JXTA4JMS architecture and explains the arrangement of classes in the JXTA4JMS implementation.
|
|
Articles |
|
22 Feb 2005 |
|
| |
Java theory and practice: Anatomy of a flawed microbenchmark
Software engineers are notoriously obsessed, sometimes excessively, with performance. While sometimes performance is the most important requirement in a software project, as it might be when developing protocol routing software for a high-speed switch, most of the time performance needs to be balanced against other requirements, such as functionality, reliability, maintainability, extensibility, time to market, and other business and engineering considerations. In this month's Java theory and practice, columnist Brian Goetz explores why it is so much harder to measure the performance of Java language constructs than it looks.
|
|
Articles |
|
22 Feb 2005 |
|
| |
Preparing for the Mobile Application Developer Certification
Learn how to become certified as a Java 2 Platform, Micro Edition (J2ME) mobile developer, an achievement that is recognized by peers and managers looking for experienced mobile developers. Getting ready requires knowledge of a lot of topics, though, and this article, presented by one of the designers of the certification, introduces you to these requirements.
|
|
Articles |
|
15 Feb 2005 |
|
| |
Practically Groovy: MVC programming with Groovy templates
Views are an integral part of MVC programming, which is itself a ubiquitous
component of enterprise application development. In this installment of Practically Groovy, Andrew Glover shows how Groovy's template engine framework can simplify view programming and make your code more maintainable over time.
|
|
Articles |
|
15 Feb 2005 |
|
| |
Taming Tiger: Get pane relief with Tiger
How many times have you written code with frame.getContentPane().add(), or forgotten to get the content pane before calling add() and ended up with an Error thrown at runtime? As consultant John Zukowski shows you in this Taming Tiger tip, these problems are a thing of the past.
|
|
Articles |
|
15 Feb 2005 |
|
| |
Create your own visualisations in Eclipse
The Visualiser plug-in from Eclipse.org is a universal tool for visualising any type of resource. This tutorial, written by the creators of the Visualiser, takes you step by step through the process of extending the tool to visualise a new type of resource -- the results returned by the Google Internet search engine. It then shows you some of the other ways in which the Visualiser has already been put to good use.
|
|
Tutorials |
|
15 Feb 2005 |
|
| |
Web services programming tips and tricks: Improve interoperability between J2EE technology and .NET, Part 3
Explore the source of the common interoperability challenges facing Web services integration across platforms. This third part in a series describes how the different naming conventions between J2EE technology and .NET can cause difficulty in Web services interoperability.
|
|
Articles |
|
10 Feb 2005 |
|
| |
Classworking toolkit: Cover your code with Hansel and Gretel
Unit tests provide a great technique for making sure that code performs to specifications. But the quality of unit tests is up to the test writer, and the results from unit tests are only as good as the quality of the tests. How can you make sure your unit tests deliver the quality you need? In the first article of this new series dedicated to classworking tools, regular developerWorks contributor Dennis Sosnoski discusses how code coverage tools provide one important quality check for your tests.
|
|
Articles |
|
08 Feb 2005 |
|
| |
AOP@Work: AOP tools comparison, Part 1
AOP is a technology whose time has come, but how do you choose the right tool for your projects? In this first article in the new AOP@Work series, aspect-oriented programming expert Mik Kersten compares the four leading AOP tools (AspectJ, AspectWerkz, JBoss AOP, and Spring AOP) to help you decide which one is for you. In Part 1 of this two-part discussion, the author focuses on the tools' language mechanisms and the trade-offs imposed by the different approaches.
|
|
Articles |
|
08 Feb 2005 |
|
| |
AOP@Work: AOP tools comparison, Part 2
In this second half of his two-part AOP tools comparison, aspect-oriented programming expert Mik Kersten focuses on the tools' integration with the development environment and build process, including a point-by-point comparison of the tools' IDE features. To help you make your final decision, the author concludes with a look at what's to come for these rapidly evolving tools, and provides a summary of each one's strengths and weaknesses. Note that this article addresses the implications of the recently announced merging of the AspectJ and AspectWerkz projects.
|
|
Articles |
|
08 Feb 2005 |
|
| |
FacesClient Components, Part 1: Portlet programming with FacesClient Components
Web applications developed using the thin client computing model exhibit performance gaps and user interface limitations. As an alternative, the FacesClient Components (formerly called the Odyssey Browser Framework) provides a more effective model for developing Web applications. FacesClient Components work inside a portlet programming environment to deliver exceptional value to users in the form of richer user interfaces and improved application performance. In this article, three software engineers explore the fundamentals of FacesClient Components and its uses for building portlet applications.
|
|
Articles |
|
04 Feb 2005 |
|
| |
Using JSF technology for XForms applications
This comprehensive hands-on tutorial by Java enterprise developer Faheem Khan examines how XForms authoring requirements fit into the JSF architecture. The author begins with a solid overview of JSF technology, then identifies the tasks you must perform if you plan to use JSF technology for XForms authoring, and demonstrates the development of a JSF tag library capable of authoring XForms markup. Throughout the tutorial, he guides your learning with a sample application to help you see the concepts put to work in a real-world application. Note: This tutorial is comprehensive and will take a significant time investment to complete.
|
|
Tutorials |
|
03 Feb 2005 |
|
| |
JSF for nonbelievers: Clearing the FUD about JSF
For such an indispensable technology, JavaServer Faces (JSF) has generated an undue amount of FUD. Hearsay has it that JSF development is difficult, more demanding than some mainstream approaches, and dependent on WYSIWYG tools to work at all. In this new four-part series, frequent developerWorks contributor Rick Hightower separates FUD from fact to show you that, actually, JSF can be easier to use than MVC Model 2 frameworks such as Struts. If you know what you're doing, that is. Editor's note: Since publication, Sun has open sourced JSF 1.2 under their CDDL license. See Resources for a link to the new project page. For details on getting started with JSF 1.2, now integrated in JEE 5, see Richard Hightower's
tutorial series.
|
|
Articles |
|
03 Feb 2005 |
|
| |
Introduction to JavaServer Pages
This tutorial introduces the fundamentals of JavaServer Pages (JSP) technology 2.0 and provides an update to the original tutorial written by Noel J. Bergman that discussed JSP 1.2. This tutorial provides a solid grasp of JSP basics to enable you to start writing your own JSP solutions. This tutorial will discuss the fundamental elements that define JSP, identify and exemplify each element, use topical examples to illustrate each element and clearly illuminate important issues related to that element.
|
|
Tutorials |
|
01 Feb 2005 |
|
| |
Advanced Synth
Take an in-depth look at the Synth look and feel, the newest addition to Swing introduced in Java 5.0. Synth lets developers rapidly create and deploy custom looks for an application by introducing the concept of a "skin" to Java UI programming. Software Engineer Michael Abernethy takes you through Synth concepts step-by-step to build an application with a Synth look from scratch. After reading this article, you should be able to create professional-looking UIs in no time.
|
|
Articles |
|
01 Feb 2005 |
|
| |
The EJB Advocate: Getting EJB cross references right
Trying to eliminate the use of EJB components by developers can lead to duplicate reference lists, broken encapsulation, and a maintenance headache. The EJB Advocate tries to ease the pain by showing how session EJBs go beyond providing just distribution, transactions, and security, and how they help make applications more maintainable and reliable.
|
|
Articles |
|
26 Jan 2005 |
|
| |
Java theory and practice: Generics gotchas
Generic types, added in JDK 5.0, are a significant enhancement to type safety in the Java language. However, some aspects of generics may seem confusing, or even downright bizarre, to first-time users. In this month's Java theory and practice, Brian Goetz examines the common pitfalls that ensnare first-time users of generics.
|
|
Articles |
|
25 Jan 2005 |
|
| |
Web services programming tips and tricks: Improve the interoperability between J2EE and .NET, Part 2
Part 2 of this series explores the source of common interoperability challenges facing Web services integration across platforms. Follow along as Wangming Ye analyzes the interop failures resulting from the use of certain data types and ways to overcome them such as collections, arrays, or primitive data types.
|
|
Articles |
|
21 Jan 2005 |
|
| |
Get dynamic Web content with HTTPRequest
The HttpRequest object initially might not seem like a big deal. Explore the possibilities of it when you issue a HTTP GET or POST on a URL for succinct page refreshes that update only a specific portion of the Web page.
|
|
Articles |
|
18 Jan 2005 |
|
| |
Heterogeneous database replication with SyncML
Availability and performance are primary considerations when you're developing distributed applications. But using data stores to address these concerns can result in problems with data synchronization between heterogeneous data stores. In this article, Jayanthi Suryanarayana and Neil Tunnicliffe offer a solution using JDBC and the SyncML standard to achieve generic database data replication.
|
|
Articles |
|
18 Jan 2005 |
|
| |
Use Eclipse to develop mobile applications for Nokia devices
This tutorial demonstrates how to develop Java 2 Platform, Micro Edition (J2ME) applications for Nokia handsets using the Eclipse IDE and the Nokia Developer's Suite for J2ME. It is written for J2ME and Nokia developers who are interested in using the powerful Eclipse IDE to boost productivity. It also targets existing Java Eclipse developers who need a short path to get started in real-world mobile application development for Nokia devices. Although the Nokia Developer's Suite for J2ME primarily provides tools for Nokia handset developers, you can use it for generic J2ME application development for other devices as well.
|
|
Tutorials |
|
18 Jan 2005 |
|
| |
Data mining with Intelligent Miner: Embed Intelligent Miner Visualization into your application
Intelligent Miner Visualization 8.2 is IBM's product to visually explore data mining models. Data mining models can give you new business insight, for example in Retail - monitor promotion effectiveness and understand product associations, in Manufacturing - understand the impact of process parameters on your production quality
and in CRM - understand your customer segments.
|
|
Articles |
|
13 Jan 2005 |
|
| |
Intermediate Java programming
The Java language provides most of what professional programmers expect to see in a language, and even in an object-oriented language. Beyond the basics, though, the Java language provides some useful tools for creating sophisticated programs. This tutorial, a follow-on to "Introduction to Java programming," also by Roy Miller will introduce you to some of these more advanced Java language features commonly seen on typical Java technology development projects.
|
|
Tutorials |
|
13 Jan 2005 |
|
| |
The role of JNDI in J2EE
Mastering J2EE can be daunting, with an ever-growing list of technologies and acronyms. The Java Naming and Directory Interface (JNDI) has been at the core of the Java 2 Platform, Enterprise Edition (J2EE) from its inception, but it is often underutilized by novice J2EE developers. This article will help demystify the role of JNDI in J2EE applications and show how it can help decouple your application from the details of deployment.
|
|
Articles |
|
13 Jan 2005 |
|
| |
Practically Groovy: JDBC programming with Groovy
Take your practical knowledge of Groovy one step further this month, as Andrew Glover shows you how to use GroovySql to build a simple data-reporting application. GroovySql combines closures and iterators to ease Java Database Connectivity (JDBC) programming by shifting the burden of resource management from you to the Groovy framework itself.
|
|
Articles |
|
11 Jan 2005 |
|
| |
Zap bugs with PMD
PMD, an open source static analysis tool, can be a worthwhile addition to your bug-zapping arsenal. Elliotte Rusty Harold explains how to use PMD's built-in rules and your own custom rule sets to improve the quality of your Java code.
|
|
Articles |
|
07 Jan 2005 |
|
| |
TestNG makes Java unit testing a breeze
The JUnit framework is the current the one-stop solution for Java language unit tests. This framework deserves praise for introducing the idea of test-driven development to Java developers and teaching them how to effectively write unit tests. However, JUnit has only marginally evolved during the last few years; thus, writing tests for today's complex environment has become an increasingly difficult task, in which JUnit must be integrated with several other complementary test frameworks. In this article, Filippo Diotalevi introduces TestNG, a new framework for testing Java applications. TestNG isn't just really powerful, innovative, extensible, and flexible; it also illustrates an interesting application of Java Annotations, a great new feature in JDK 5.0.
|
|
Articles |
|
06 Jan 2005 |
|
| |
FacesClient Components, Part 2: Use FacesClient Components in a portal environment
In this second article in a series on developing and enabling portlet applications with FacesClient Components, meet the challenges of using FacesClient Components in a portal environment. Using the prototype from the first article of the series plus examples and code samples, the authors explain how data models and instance data are shared between multiple portlets on a portal page, and also describe some best practice development approaches.
|
|
Articles |
|
05 Jan 2005 |
|
| |
Java theory and practice: Dynamic compilation and performance measurement
Writing and interpreting performance benchmarks for dynamically compiled languages, such as Java, is far more difficult than for statically compiled languages like C or C++. In this installment of Java theory and practice, Brian Goetz explores a few of the many ways in which dynamic compilation can complicate performance testing.
|
|
Articles |
|
21 Dec 2004 |
|
| |
Use continuations to develop complex Web applications
If you've ever developed a non-trivial Web application, you know that development complexity is increased by the fact that Web browsers allow users to follow arbitrary navigation paths through the application. No matter where the user navigates, the onus is on you, the developer, to keep track of the possible interactions and ensure that your application works correctly. While the traditional MVC approach does allow you to handle these cases, there are other options available to help resolve application complexity. Developer and frequent developerWorks contributor Abhijit Belapurkar walks you through a continuations-based alternative that could simplify your Web application development efforts.
|
|
Articles |
|
21 Dec 2004 |
|
| |
Web services programming tips and tricks: Improve interoperability between J2EE technology and .NET, Part 1
Explore the source of some common interoperability challenges facing Web services integration across platforms and join the author in analyzing a number of interoperability problems resulting from interaction styles, basic data types and structures, and namespace issues between .NET and J2EE technology. Wangming Ye offers best practices that you can use to avoid problems and improve the chances of successful integration. The first part of the series stresses the importance of WSDL design and analyzes the strength and pitfalls of the traditional RPC/encoded style in Web services interoperability.
|
|
Articles |
|
21 Dec 2004 |
|
| |
A gentle introduction to SWT and JFace, Part 1: How to create a simple SWT application
In this first article of A gentle introduction to SWT and JFace, find out how to create a simple Standard Widget Toolkit (SWT) application using Java, Eclipse, and the SWT and JFace libraries. Also learn how to create simple SWT GUIs using basic controls and layouts.
|
|
Articles |
|
16 Dec 2004 |
|
| |
Create test cases for Web applications
Looking for a way to apply automated testing techniques to Web development? Look no further. jWebUnit, which plugs easily into most Java IDEs, is an open source framework for creating test cases for Web applications. Software engineer Amit Tuli introduces jWebUnit by using a sample application to describe a step-by-step approach for generating concise test cases.
|
|
Articles |
|
16 Dec 2004 |
|
| |
Hibernate simplifies inheritance mapping
Hibernate is an object-relational mapping and persistence framework that provides a lot of advanced features, ranging from introspection to polymorphism and inheritance mapping. But mapping class hierarchies to a relational database model might prove somewhat difficult. This article covers three strategies that you can use in your everyday programming to easily map complex object models to relational database models.
|
|
Articles |
|
14 Dec 2004 |
|
| |
Practically Groovy: Ant scripting with Groovy
Both Ant and Maven rule the world of build processing, but XML is occasionally a less-than-expressive configuration format. In this second installment in his new series on the practical applications of Groovy, Andrew Glover introduces Groovy's builder utility, which makes it especially easy to combine Groovy with Ant and Maven for more expressive and controllable builds.
|
|
Articles |
|
14 Dec 2004 |
|
| |
What's new in JAXP 1.3? Part 2
In this article, the authors follow up on their overview of JAXP 1.3 in Part 1. They touch on utilities that add support for concepts defined in the Namespaces in XML specification, and describe changes to the javax.xml.transform package. They also discuss the new Java types defined and how these allow for the completion of native Java language support for W3C XML Schema datatypes. They conclude by giving details on JAXP's data model- and vendor-neutral XPath API.
|
|
Articles |
|
14 Dec 2004 |
|
| |
IBM developer kits for Java technology on Apple PowerPC hardware
This article shows how to use fully-featured, production-proven IBM developer kits for Java technology for Linux distributions for IBM POWER and IBM PowerPC hardware on Linux for Apple PowerPC hardware. Be aware that the use of IBM Java environments on Apple PPC hardware is not supported by IBM. IBM does not offer service support for these configurations and so the author is not encouraging customers to use them in production environments that use Linux distributions running on Apple PPC hardware.
|
|
Articles |
|
12 Dec 2004 |
|
| |
alt.lang.jre: All hail King NetRexx!
NetRexx is an extension of the popular IBM mainframe operating system scripting language REXX. In this sixth installment in the alt.lang.jre series, language enthusiast Barry Feigenbaum introduces you to one of the most stable and reliable scripting alternatives for the Java platform.
|
|
Articles |
|
07 Dec 2004 |
|
| |
Introduction to Java Servlet technology
Java developer and trainer Roy Miller revamps ourexisting introductory servlet material into this single easy-to-follow, hands-on tutorial. Roy introduces explains what servlets are, how they work, how you can use them to create Web applications of any degree of sophistication you can imagine, and how you can use servlets most effectively as a professional programmer.
|
|
Tutorials |
|
07 Dec 2004 |
|
| |
Introduction to generic types in JDK 5.0
This tutorial introduces generic types, a new feature in JDK 5.0 that lets you define classes with abstract type parameters that you specify at instantiation time. Generics increase the type safety and maintainability of large programs. Follow along with frequent developerWorks contributor and Java programming expert Brian Goetz, as he explains the motivation for adding generics to the Java language, details the syntax and semantics of generic types, and provides an introduction to using generics in your classes.
|
|
Tutorials |
|
07 Dec 2004 |
|
| |
Enhance looping in Java 5.0 with for/in
The for/in loop -- often called either enhanced for or foreach is largely a convenience feature in Java 5.0. It doesn't really offer any new functionality, but certainly makes several routine coding tasks simpler. In this article, you'll learn about many of those, including using for/in to iterator over arrays and collections, as well as how it can help avoid unnecessary (or just plain annoying) typecasts. You'll also learn how for/in is implemented, glean details about the new Iterable interface, and even understand how to make your own custom objects usable with this new construct. Finally, you'll learn about the things that for/in can't do to make sure you understand when plain old for is the right choice
|
|
Articles |
|
30 Nov 2004 |
|
| |
Developing J2ME applications with EclipseME
This tutorial demonstrates how to develop Java 2 Platform, Micro Edition (J2ME) applications using the Eclipse IDE, the open source EclipseME plug-in, and the Sun J2ME Wireless Toolkit. This tutorial is written for J2ME developers who are interested in using the Eclipse IDE to increase productivity. It also addresses Java Eclipse developers who want to produce J2ME mobile applications in their favorite IDE.
|
|
Tutorials |
|
30 Nov 2004 |
|
| |
Java theory and practice: Going atomic
Until JDK 5.0, it was not possible to write wait-free, lock-free algorithms in the Java language without using native code. The addition of the atomic variable classes in java.util.concurrent changes that situation. Follow along with concurrency expert Brian Goetz as he explains how these new classes have enabled the development of highly scalable nonblocking algorithms in the Java language. Share your thoughts on this article with the author and other readers in the accompanying discussion forum.
|
|
Articles |
|
23 Nov 2004 |
|
| |
Build a Web service using the Eclipse Web Tools Platform
This tutorial shows you how to build a Web service using the Eclipse Web Tools Platform. The Web service interacts with a Cloudscape (Apache Derby) database and is deployed to Apache Tomcat.
|
|
Tutorials |
|
23 Nov 2004 |
|
| |
Build a Web-based client with the Eclipse Web Tools Platform
This tutorial shows you how to build a complete Web-based auction client application using the Eclipse Web Tools Platform. The auction client accesses a Cloudscape (Apache Derby) database that houses auction stock, as well as a remote auction Web service.
|
|
Tutorials |
|
23 Nov 2004 |
|
| |
Concurrency in JDK 5.0
JDK 5.0 added major new support for developing concurrent applications, including JVM changes, new low-level synchronization utilities, and higher-level, thread-safe, high-performance concurrency classes such as thread pools, concurrent collections, semaphores, latches, and barriers. Learn how these new classes can help make your code faster, more scalable, more reliable, and easier to maintain.
|
|
Tutorials |
|
23 Nov 2004 |
|
| |
Using JCE in a J2ME environment
Learn a platform-independent approach for transitioning Java Cryptography Extension (JCE) to Java 2 Platform, Micro Edition (J2ME) environments.
|
|
Articles |
|
23 Nov 2004 |
|
| |
RELAX NG with custom datatype libraries
RELAX NG can do almost as much as the W3C XML Schema language. Both verify constraints on text content and attribute values specified with the W3C XML Schema simple types. RELAX NG isn't a Turing-complete language so you can't state some constraints. You can extend RELAX NG dynamically with custom, Java validation code and check those constraints by implementing three interfaces: Datatype, DatatypeLibrary, and DatatypeFactory. This article demonstrates these interfaces by verifying that a number is prime.
|
|
Articles |
|
23 Nov 2004 |
|
| |
Simplify your application delivery with One-JAR
If you've ever tried to deliver a Java application
as a single Java Archive file (JAR file), you've most likely encountered the need to expand
supporting JAR files before you build the final archive. As well as
being a development nuisance, this can put you in violation of license
agreements. In this article, Simon Tuffs introduces you to
One-JAR, a tool that uses a custom classloader to dynamically
load classes from JAR files inside an executable JAR file.
|
|
Articles |
|
23 Nov 2004 |
|
| |
Introduction to Java programming
The Java language, and the ever-growing Java platform, have revolutionized programming. The goal of this tutorial is to introduce you to the Java syntax you're most likely to encounter professionally, and to expose you to idioms that will help you avoid trouble. Follow along with Java professional Roy Miller as he guides you through the essentials Java programming, including the OOP paradigm and how it applies to Java programming, Java language syntax and use, creating objects and adding behavior, working with collections, handling errors, and tips for writing better code.
|
|
Tutorials |
|
19 Nov 2004 |
|
| |
Don't forget about memory
Even though the Java runtime handles the bulk of memory management, keeping a vigilant eye on your programs' memory usage is still crucial to optimizing machine performance and spotting memory leaks. Numerous tools are available for monitoring memory usage in Windows. But each has its own advantages and disadvantages and its own particular slant -- often without defining clearly what it measures. The authors clear up a few common misconceptions about memory usage and demystify some of the many available tools, offering guidance on when and how to use them.
|
|
Articles |
|
16 Nov 2004 |
|
| |
Wireless messaging with JXTA, Part 1: Using JXTA technology
Learn how to use JXTA technology to integrate thin Java 2 Platform, Micro Edition (J2ME) clients into enterprise-scale messaging applications by developing a set of classes that let you integrate J2ME clients into JMS (Java Message Service) applications running on Java 2 Platform, Enterprise Edition (J2EE) servers.
|
|
Articles |
|
16 Nov 2004 |
|
| |
Enable backwards navigation through Web applications
Web frameworks like Struts and JavaServer Faces focus only on forward navigation of Web applications. In this article, Maurizio Albari introduces a framework that improves the backwards navigation of Web applications by keeping a server-side navigation history of visited Web pages and visited named sequences of Web pages, also known as Webflows. With the framework, you can also use the server-side navigation history to automatically clean the HTTP session, thus improving application performance. And the best part is that you can still use your favorite Web framework for forward navigation.
|
|
Articles |
|
16 Nov 2004 |
|
| |
Integrate COM and Java components
Interoperability issues have long made integration of Microsoft Component Object Model (COM) and Java components a daunting task. The Development Tool for Java-COM Bridge, available from IBM alphaWorks, simplifies the job and also provides an evolutionary approach to migrating applications from COM to the Java platform. IBM Rational's Cheng-Yee Lin, Thomas Houser, and Peter Parapounsky, creators of the bridging technology, explain its basics and present a sample application that leverages its capabilities.
|
|
Articles |
|
16 Nov 2004 |
|
| |
Practically Groovy: Unit test your Java code faster with Groovy
Not long ago, developerWorks contributor Andrew Glover penned an article introducing Groovy, a new proposed standard language for the Java platform, as part of our alt.lang.jre series. Reader response was fantastic, so we've decided to launch this column to offer a practical guide to using this hot new technology. This first installment introduces a simple strategy for unit testing Java code with Groovy and JUnit.
|
|
Articles |
|
09 Nov 2004 |
|
| |
What's new in JAXP 1.3? Part 1
For a mature technology, the XML space is surprisingly active. Java API for XML Processing (JAXP) 1.3 was recently finalized, and is the conduit through which many of the newest open standards relating to XML will enter the J2SE platform. In this installment of a two-part article describing the JAXP 1.3 API, authors Neil Graham and Elena Litani provide a brief overview of the JAXP specification, give details of the modifications to the javax.xml.parsers package, and describe a powerful schema caching and validation framework.
|
|
Articles |
|
09 Nov 2004 |
|
| |
Getting started with enumerated types
One of the great new features in Tiger is the enumeration construct, a new type that allows you to represent specific pieces of data as constants, all in a type-safe manner. Tiger expert and frequent developerWorks contributor Brett McLaughlin explains what an enumeration is, how you can use it in your programs, and why it will allow you to dump all that old public static final code.
|
|
Articles |
|
09 Nov 2004 |
|
| |
Web Services APIs for J2ME, Part 2: Java API for XML processing
Become familiar with the Web Services APIs for J2ME. This article, focusing on the JAXP, spotlights the general remote service invocation and XML parsing that saves you from embedding these functions into every application.
|
|
Articles |
|
02 Nov 2004 |
|
| |
alt.lang.jre: Harnessing Rhino
JavaScript is well known as a language for dynamically manipulating and accessing the content of Web pages. With the introduction of Rhino, a 100% pure Java implementation of JavaScript, many developers have discovered that the language is also an excellent tool for quickly building and deploying GUI-based applications. In this fifth article in the alt.lang.jre series, regular developerWorks contributor Michael Squillace introduces you to the fundamentals of Rhino, a prototype-based alternative to the Java language on the Java platform.
|
|
Articles |
|
02 Nov 2004 |
|
| |
Now showing: Your own online MPEG-4 cinema
Think it's impossible to deliver an interactive multimedia experience over a network to a large audience? Think again! Widespread broadband connectivity and the availability of powerful PCs make delivery of video and multimedia content over a network a reality. Add in the IBM alphaWorks Toolkit for MPEG-4 and you can create your own Web cinema today. Follow along with popular author and Java developer Sing Li as he shows you how to code a custom Java MPEG-4 player using the SDK libraries, how to use an applet to create a download-on-demand MPEG-4 player, and how to prepare the content for delivery.
|
|
Articles |
|
02 Nov 2004 |
|
| |
Java theory and practice: More flexible, scalable locking in JDK 5.0
JDK 5.0 offers developers some powerful new choices for developing high-performance concurrent applications. For example, the ReentrantLock class in java.util.concurrent.lock is offered as a replacement for the synchronized facility of the Java language -- it has the same memory semantics, the same locking semantics, better performance under contention, and features not offered by synchronized. Does this mean that we should forget about synchronized, and instead use ReentrantLock exclusively? Concurrency expert Brian Goetz returns from his summer hiatus to supply the answer.
|
|
Articles |
|
26 Oct 2004 |
|
| |
Taming Tiger: Ocean and Synth meet Metal
Now that Tiger is an official release, it's time to explore even more exciting differences between the 1.4 version of the Java 2 Standard Edition platform and 5.0 of the Java 2 Development Kit. In this installment of Taming Tiger, UI expert John Zukowski explores the newly available Ocean and Synth look and feels. Now, even non-programmers can develop custom look and feels without writing code or having the benefit of a good eye!
|
|
Articles |
|
19 Oct 2004 |
|
| |
Understanding JCA transactions
Transaction processing is a vital part of most real-world J2EE application development. In this article, IBM Solution Architect Mikhail Genkin explains how different enterprise information systems (EIS) can participate in transactions via the J2EE Connector Architecture. Using an example e-commerce application, Mikhail demonstrates the various levels of transaction support provided by different EISs and resource adapters and shows how these factors can affect application design. The article concludes with Mikhail's tips for choosing the right transaction demarcation strategy and EJB deployment descriptor settings for your enterprise development scenario.
|
|
Articles |
|
19 Oct 2004 |
|
| |
IBM security providers: An overview
The 1.4.2 release of the IBM developer kit for the Java platform provides the most comprehensive security offering from IBM for the Java 2 platform to date. It includes several IBM-specific security providers, with new features and great enhancements. IBM security experts Yanni Zhang, Audrey Timkovich, and John Peck introduce the IBM security providers, review their functionality, and explain how they differ from Sun's providers.
|
|
Articles |
|
12 Oct 2004 |
|
| |
EJB Programming with snippets in WebSphere Studio V5.1.2
EJBs provide a powerful mechanism for distributed computing and container-managed persistence. The programming model, however, can be complex.
This article shows you how to use WebSphere Studio to automate EJB programming by generating the client code and hiding the complexity.
Along the way, it explains how the code works and shows best practices for simplicity and portability.
|
|
Articles |
|
06 Oct 2004 |
|
| |
alt.lang.jre: Twice as Nice
Nice is a JRE compatible, object-oriented language that brings tremendous expressiveness to the Java platform. Nice also lets you implement many of the cutting edge features found in Java 5 on any Java virtual machine. In this fourth installment of the alt.lang.jre series, regular contributor and all around "Nice" guy Andrew Glover walks you through some of the most exciting features of Nice.
|
|
Articles |
|
06 Oct 2004 |
|
| |
Developing and testing message-driven beans, Part 1
This demo shows users how to incorporate enterprise messaging into a small J2EE sample application by adding a Message-Driven Enterprise Bean.
|
|
Demos |
|
05 Oct 2004 |
|
| |
Reduce code bloat with XDoclet
The open source XDoclet code-generation engine, an integral part of many leading Java frameworks, is often heralded as an enabler for attribute-oriented programming and continuous integration. But XDoclet also has an undeserved reputation for being difficult for beginning developers to grasp and master. In this article, the ever-popular Sing Li takes on XDoclet and reveals the simple yet elegant design at its heart, enabling you to understand the technology and put it to productive use.
|
|
Articles |
|
05 Oct 2004 |
|
| |
Simple JSP and servlet
Ideal for students and beginning developers, this demo highlights the difference between a Java Servlet Page (JSP) and a Servlet. Users will learn how to create two identical Web pages, one using a JSP and the other using a Servlet.
|
|
Demos |
|
05 Oct 2004 |
|
| |
Web applications using Java Server Pages and servlets
This demo walks the user through the creation of two simple applications. One displays the user's name and date/time when submitted, and the other is a simple Login application that allows users to access a welcome page with a password.
|
|
Demos |
|
05 Oct 2004 |
|
| |
Developing and testing message-driven beans, Part 2
This demo shows users how to incorporate enterprise messaging into a small J2EE sample application by adding a Message-Driven Enterprise Bean.
|
|
Demos |
|
05 Oct 2004 |
|
| |
Taming Tiger: Get environment variables and invoke subprocesses
Accessing platform-specific information hasn't always been easy. While you could certainly create processes with Runtime.exec(), dealing with differences across platforms to build parameter sets often led to headaches. In addition, the getenv() method of System has been deprecated since the beginning of Java programming time. Now, as columnist John Zukowski shows you, the new ProcessBuilder class makes accessing platform-specific information easier than ever.
|
|
Articles |
|
30 Sep 2004 |
|
| |
Creating a Web site the easy way with WebSphere Studio Web Site Designer and page templates
WebSphere Studio Web Site Designer and page templates enable you to generate JSP/HTML pages with a consistent look and dynamically generated navigation links. This article shows you how to apply a page template to a Web site using sample data, how to use the nav bar with a page template, how to create a page template from scratch, and how to apply a page template.
|
|
Articles |
|
29 Sep 2004 |
|
| |
Introduction to Service Data Objects
If you think the J2EE programming models and APIs force developers to spend too much time on technology-specific configuration, programming, and debugging, then this article is for you! Many Java developers are skeptical about how heterogeneous data can be accessed uniformly, and have been disappointed in the various programming frameworks that propose to solve the problem. In this article, Java developers Bertrand Portier and Frank Budinsky introduce you to next-generation data programming with Service Data Objects (SDO).
|
|
Articles |
|
28 Sep 2004 |
|
| |
Plugging in a logging framework for Eclipse plug-ins
Eclipse lacks a configurable logging facility with rich features like the ones found in J2SDK Logging Utilities or Apache's Log4j. In this article, learn how to configure and use a logging framework for Eclipse plug-ins that is itself a plug-in and that is based on the Apache Log4j. Complete source code is provided for your use and extension.
|
|
Articles |
|
27 Sep 2004 |
|
| |
Can't beat Jazzy
Users have come to expect spell-check capabilities from applications that involve natural-language text entry. Because building a spell checker from scratch is no simple task, this article offers you a workaround using Jazzy, an open source Java spell checker API. Java developer Tom White offers an in-depth explanation of the main algorithms behind computer-based spell checking, then shows you how the Jazzy API can help you incorporate the best of them into your Java applications.
|
|
Articles |
|
22 Sep 2004 |
|
| |
Develop aspect-oriented Java applications with Eclipse and AJDT
AspectJ is an aspect-oriented extension of the Java(tm) language that enables a modular implementation of crosscutting concerns. This crosscutting behavior, which can be static or dynamic, presents an extra challenge to tools that support AspectJ. The AJDT project aims to provide Eclipse platform-based tools for AspectJ, consistent with the Eclipse Java Development Tools (JDT), with additional capabilities for visualizing and understanding the crosscutting nature of aspect-oriented applications. In this article, AJDT contributors and IBM aspect-oriented software development team members Matt Chapman and Helen Hawkins introduce you to AJDT. You'll learn how to install the tools; how to create, run, and debug AspectJ applications; and how to visualize and navigate the crosscutting structures inherent to aspect-oriented programming.
|
|
Articles |
|
21 Sep 2004 |
|
| |
Java certification success, Part 3: SCBCD
This tutorial is designed to aid EJB professionals in preparing for the Sun Certified Business Component Developer (SCBCD) for the Java 2 Platform, Enterprise Edition 1.3 Exam. Certification experts Seema Manivannan and Pradeep Chopra of Whizlabs walk you through the core concepts that are tested in the SCBCD exam, offering guidance and sample questions to test your knowledge along the way.
|
|
Tutorials |
|
09 Sep 2004 |
|
| |
alt.lang.jre: Take a shine to JRuby
JRuby combines the object-oriented strength of Smalltalk, the expressiveness of Perl, and the flexibility of the Java class libraries into a single, efficient rapid development framework for the Java platform. In this third installment in the alt.lang.jre series, Michael Squillace and Barry Feigenbaum introduce JRuby, a sophisticated addition to your Java development toolbox.
|
|
Articles |
|
08 Sep 2004 |
|
| |
Migrating to Eclipse: A developer's guide to evaluating Eclipse vs. JBuilder
Many programmers are moving to Eclipse, the popular, open source development environment. For programmers familiar with Borland's free JBuilder X Foundation edition, this article starts with a brief comparison of both IDEs' features, ease of use, and stability, and then demonstrates essential tasks in Eclipse -- and shows how they differ from JBuilder -- so you can decide if Eclipse is right for you.
|
|
Articles |
|
08 Sep 2004 |
|
| |
Migrating to Eclipse: A developer's guide to evaluating Eclipse vs. IntelliJ IDEA
New features in the latest release of Eclipse -- the free and increasingly popular Java integrated development environment -- make it competitive not only with other free IDEs, but also with proprietary, commercial offerings such as IntelliJ IDEA. This article briefly compares the features, ease of use, and stability of Eclipse and IDEA, and then provides a guide for programmers who are considering switching or who simply want to try out Eclipse to see what all the fuss is about.
|
|
Articles |
|
08 Sep 2004 |
|
| |
Migrating to Eclipse: A developer's guide to evaluating Eclipse vs. Netbeans
By now, most Java programmers have heard of Eclipse, the extensible open source development platform that is rapidly becoming the most popular IDE for Java programming. If you are considering a move to Eclipse and are currently programming with Netbeans, this article is for you. Starting with a brief comparison of both IDEs' features, ease of use, and stability, this article then covers the essential Eclipse features -- and how they differ from those in Netbeans -- so you can decide if Eclipse is right for you.
|
|
Articles |
|
08 Sep 2004 |
|
| |
Annotations in Tiger, Part 1: Add metadata to Java code
Annotations, a new feature in J2SE 5.0 (Tiger), brings a much-needed metadata facility to the core Java language. In this first of a two-part series, author Brett McLaughlin explains why metadata is so useful, introduces you to annotations in the Java language, and delves into Tiger's built-in annotations. Part 2 covers custom annotations.
|
|
Articles |
|
02 Sep 2004 |
|
| |
Annotations in Tiger, Part 2: Custom annotations
Part 1 of this series introduced annotations, the new metadata facility in J2SE 5.0, and focused on Tiger's basic built-in annotations. A more powerful related feature is support for writing your own annotations. In this article Brett McLauglin shows how to create custom annotations and then how to annotate your annotations to document and customize your code further.
|
|
Articles |
|
02 Sep 2004 |
|
| |
The On Demand operating environment
The On Demand operating environment is based upon the concepts of Service Oriented Architecture (SOA). SOA views every application or resource as a service implementing a specific, identifiable set of (business) functions. In addition to the business functions, services in an on demand environment might also implement management interfaces to participate in the broader configuration, operation, and monitoring of the environment. This article provides an introduction to the On Demand operating environment.
|
|
Articles |
|
24 Aug 2004 |
|
| |
Generate certificate chains for testing Java applications
Learn how to create digital-certificate chains to test your software. IBM Software Engineer, Paul H. Abbott, clarifies this seldom-documented process by showing you how to use the freely available OpenSSL toolkit to create a certificate chain of any length. He also describes common certificate attributes and shows you some sample Java code for reading the certificates you create into a Java keystore.
|
|
Articles |
|
18 Aug 2004 |
|
| |
Taming Tiger: Default exception handling in threads
Tracking down unexpected runtime exceptions can be a real drag, and just getting the default thread name and stack trace isn't always enough. In this installment of Taming Tiger, Java developer John Zukowski shows how you can customize the output by replacing the default behavior. He also contrasts the old way of customizing output by subclassing ThreadGroup with the new way by providing your own customUncaughtExceptionHandler.
|
|
Articles |
|
10 Aug 2004 |
|
| |
Dynamic data analysis on the Web: A design approach
Learn about an adaptable approach which separates programming tasks from Web page design tasks. This strong conceptual model encourages good design, enables re-use of data definitions, and is well-suited to the construction of dynamic user interfaces.
|
|
Articles |
|
05 Aug 2004 |
|
| |
alt.lang.jre: Feeling Groovy
Andrew Glover offers an informal introduction to Groovy, the proposed addition to the standard programming languages for the Java platform.
|
|
Articles |
|
03 Aug 2004 |
|
| |
Develop Contact Center telecom applications
Learn just how easy it is to create a basic telecommunications application using SIP servlets. The use of open standards such as SIP, together with Java programming, has radically simplified the task of creating complex applications.
|
|
Articles |
|
03 Aug 2004 |
|
| |
Java theory and practice: State replication in the Web tier
How state will be managed and replicated in a clustered server application has a significant impact on the scalability of the application. Many Java applications store state in the HttpSession provided by the Servlet API. This article examines some of the options for HttpSession replication and how to most effectively use HttpSession to provide good scalability and performance.
|
|
Articles |
|
29 Jul 2004 |
|
| |
Use the Element Construction Set to create formatted logs
The Jakarta Element Construction Set (ECS) is an open source project for creating markup language documents using the Java language and an object-oriented approach. Java developer Amit Tuli provides an introduction to ECS and shows you a step-by-step approach for using it to generate well-formatted status reports from log files. You will create a sample application to help you better understand ECS and its usage. You'll also learn some other potential uses for the API.
|
|
Articles |
|
22 Jul 2004 |
|
| |
Web Services APIs for J2ME, Part 1: Remote service invocation API
The Web Services APIs (WSA) for Java 2 Platform, Micro Edition (J2ME), as defined by the Java Community Process for the Java Specification Request 172 (JSR 172), are two independent optional packages for remote service invocation and XML parsing. These are targeted at both the Connected Device Configuration (CDC) and the Connected Limited Device Configuration (CLDC 1.0 and CLDC 1.1)-based profiles. Why should you care? Because the JSR 172 specification provides support for remote service invocation and XML parsing at the device level -- this means that developers don't have to embed such functionality into each application. This article introduces the remote service invocation optional package API.
|
|
Articles |
|
20 Jul 2004 |
|
| |
XML programming in Java technology, Part 3
This advanced tutorial covers more sophisticated topics for manipulating XML documents with Java technology. Author Doug Tidwell shows you how to do tasks such as generate XML data structures, manipulate those structures, and interface XML parsers with non-XML data sources. As you'd expect, all of the examples are based on open standards.
|
|
Tutorials |
|
16 Jul 2004 |
|
| |
Contract enforcement with AOP
Your Java code often needs to interact with external components when you develop enterprise software. Whether your application must communicate with a legacy application, an external business system, or a third-party library, using components you don't control introduces the risk of unexpected results. IBM IT Specialist Filippo Diotalevi shows how aspect-oriented programming (AOP) can mitigate this risk by helping you design and define clear contracts between components while keeping your code clean and flexible.
|
|
Articles |
|
15 Jul 2004 |
|
| |
Functional programming in the Java language
Abhijit Belapurkar shows you how to use functional programming constructs such as closures and higher order functions to write well-structured, modular code in the Java language.
|
|
Articles |
|
13 Jul 2004 |
|
| |
XML programming in Java technology, Part 2
In an earlier tutorial, Doug Tidwell looked at the basics of XML parsing in the Java language. He covered the major APIs (DOM, SAX, and JDOM), and went through a number of examples that demonstrated the basic tasks common to most XML applications. In this tutorial, he looks at more difficult things that weren't covered in Part 1, such as working with namespaces, validating XML documents, building XML structures without a typical XML document, converting between one API and another, and manipulating tree structures. He also shows you some of the more esoteric features of DOM, SAX, JDOM, and JAXP.
|
|
Tutorials |
|
09 Jul 2004 |
|
| |
alt.lang.jre: Get to know Jython
Get to know Jython, in this first article in a new series introducing alternate languages for the Java Runtime Environment.
|
|
Articles |
|
06 Jul 2004 |
|
| |
Java theory and practice: Kill bugs dead
The FindBugs tool is a powerful tool for auditing your code for compliance with good design practices and represents a huge step forward in the state-of-the-art of real-world code analysis tools.
|
|
Articles |
|
29 Jun 2004 |
|
| |
Introduction to Jena
RDF is increasingly recognized as an excellent choice for representing and processing semi-structured data. In this article, Web Developer Philip McCarthy shows you how to use the Jena Semantic Web Toolkit to exploit RDF data models in your Java applications.
|
|
Articles |
|
23 Jun 2004 |
|
| |
The BlueSpace wall display project
This article provides some of the implementation details behind the BlueSpace wall display, a high-resolution screen display built on the Java platform.
|
|
Articles |
|
22 Jun 2004 |
|
| |
Best practices for Struts development
Leverage your Web application development using the flexible Struts framework. Here, the authors explore best practicesthat you can follow to optimize this open source and mature framework. Learn to use standard, yet valuable, Struts components, including ActionForm, Action class, and ActionErrors.
|
|
Articles |
|
16 Jun 2004 |
|
| |
Taming Tiger: Concurrent collections
What began as author Doug Lea's util.concurrent package has morphed into JSR-166 and into the Tiger release of the J2SE platform. What the new library provides is a set of utilities commonly needed in concurrent programs. If you are interested in optimizing multithreaded access to your collections, you've come to the right place.
|
|
Articles |
|
16 Jun 2004 |
|
| |
Python development with Eclipse and Ant
Python is a very flexible and powerful dynamic scripting language with full object oriented features. This article highlights the use of the popular Java technology-based Eclipse and Ant development tools for Python development.
|
|
Articles |
|
15 Jun 2004 |
|
| |
Understand Enterprise Service Bus scenarios and solutions in Service-Oriented Architecture, Part 1
This article explores the minimum capabilities needed to implement an Enterprise Service Bus (ESB) to support a Service-Oriented Architecture (SOA).
|
|
Articles |
|
15 Jun 2004 |
|
| |
Java programming dynamics, Part 8: Replacing reflection with code generation
Earlier in this article series, you learned how reflection performance is many times slower than direct access, and then learned about classworking with Javassist and the Apache Byte Code Engineering Library (BCEL). Java consultant Dennis Sosnoski wraps up his Java programming dynamics series by demonstrating how you can use runtime classworking to replace reflection code with generated code that runs at full speed ahead.
|
|
Articles |
|
10 Jun 2004 |
|
| |
Introducing the Java Message Service
This tutorial provides an overview of the Java Message Service (JMS) and offers the basics for developing programs that use it. JMS provides a way for Java programs to access an enterprise messaging system, also known as message oriented middleware (MOM). MOM provides a mechanism for integrating applications in a loosely coupled, flexible manner by providing asynchronous delivery of data between applications in an indirect way through an intermediary. Note: This tutorial has been updated to include changes in JMS version 1.1.
|
|
Tutorials |
|
08 Jun 2004 |
|
| |
Mastering JSP custom tags
Interested in adding custom tags to your JavaServer Pages (JSP) applications? This tutorial will show you how to use these tags to write custom actions that are similar to those built in to JSP technology, such as jsp:useBean, jsp:getProperty, and jsp:forward. Learn how you can extend the JSP syntax with your very own custom actions that are specific to your domain's presentation logic.
|
|
Tutorials |
|
01 Jun 2004 |
|
| |
Build distributed object management frameworks for J2EE apps
Many enterprise Java technology developers build their own object management infrastructures to improve application performance. However, traditional object pools encounter problems in applications that run across distributed JVMs on multiple physical machines. In this article, Zhengrong Tang presents an object management framework that uses the concept of scopes to handle distributed systems with ease.
|
|
Articles |
|
25 May 2004 |
|
| |
Java theory and practice: The exceptions debate
When should you use checked versus unchecked exceptions in Java classes? The prevailing wisdom is to use checked exceptions in nearly all cases, but some Java luminaries have begun to think otherwise. This month, columnist Brian Goetz examines the exceptions debate and offers guidance on when and how to use unchecked exceptions.
|
|
Articles |
|
25 May 2004 |
|
| |
FindBugs, Part 2: Writing custom detectors
FindBugs is a static analysis tool that can be extended and customized to meet your team's unique requirements. In the second article of this series, Senior Software Engineer Chris Grindstaff shows you how to create application-specific bug detectors. Don't miss Part 1 of this series.
|
|
Articles |
|
25 May 2004 |
|
| |
FindBugs, Part 1: Improve the quality of your code
Static analysis tools promise to find existing bugs in your code without requiring much effort on the part of the developer. Of course, if you've been programming for long, you know those promises don't always pan out. Even so, good static analysis tools are a valuable addition to your toolbox. In this first of a two-part series, Senior Software Engineer Chris Grindstaff looks at how FindBugs can help improve the quality of your code and eliminate bugs lying in wait. Don't miss Part 2 of this series to get the final part of the story.
|
|
Articles |
|
25 May 2004 |
|
| |
Practical data binding: Looking into JAXB, Part 1
In the last installment, Brett examined several important concepts in data binding, including round-tripping and semantic equivalence. In this article, he looks at Sun's JAXB architecture and implementation in light of these terms. You'll learn how JAXB handles class generation, and how that affects the XML input and output accepted by the API.
|
|
Articles |
|
19 May 2004 |
|
| |
Cellular automata and music
Take computers, mathematics, and the Java Sound API, add in some Java code, and you've got a recipe for creating some uniquely fascinating music. IBM Staff Software Engineer Paul Reiners demonstrates how to implement some basic concepts of algorithmic music composition in the Java language. He presents code examples and resulting MIDI files generated by the Automatous Monk program, which uses the open source jMusic framework to compose music based on mathematical structures called cellular automata.
|
|
Articles |
|
18 May 2004 |
|
| |
Model with the Eclipse Modeling Framework, Part 3: Customize generated models and editors with Eclipse's JMerge
The Eclipse Modeling Framework includes an open source tool called JMerge, which makes code generation flexible and customizable. This article uses an example to explore how to add JMerge to an application and customize its behavior for different environments.
|
|
Articles |
|
13 May 2004 |
|
| |
Taming Tiger: Context popup menus
Tired of adding the same code all the time to show a JPopupMenu over a component? As John Zukowski shows you in this latest installment of Taming Tiger, J2SE 1.5 finally adds common code to the JComponent class so you don't have to.
|
|
Articles |
|
12 May 2004 |
|
| |
Use Jython to build JUnit test suites
Developers decide to automate unit tests for a number of reasons. Many take it even a step further and automate the location and execution of those tests. But what if you need your test harness to act as if it were statically defined? Follow along with developer Michael Nadel and see how to use Python to feign statically defined JUnit TestSuite classes.
|
|
Articles |
|
11 May 2004 |
|
| |
Java certification success, Part 2: SCWCD
Sun Certified Web Component Developer (SCWCD) is one of most coveted certifications in the J2EE domain. If you're considering the SCWCD certification, you need to be aware that it takes more than just learning the servlet and JSP technologies. It requires in-depth knowledge of the topics specified in the exam objectives, and Java programmer and certification trainer, Seema Manivannan of Whizlabs offers just that in this comprehensive tutorial. Seema covers the 13 main objectives of the SCWCD exam and provides a QandA section to ensure you understand the concepts.
|
|
Tutorials |
|
04 May 2004 |
|
| |
Java authorization internals
If you're the type who needs to know how a technology works from the inside out in order to use it effectively, you'll jump on this guided tour of the Java platform's authorization architectures. Follow along as Java architect Abhijit Belapurkar leads this detailed, behind-the-scenes introduction to two distinctly different (yet related) models of authorization: the code-centric model of the Java 2 platform security architecture and the user-centric model of the Java Authentication and Authorization Service.
|
|
Articles |
|
04 May 2004 |
|
| |
Lend a helping hand to your Java applications
Even help system designers can use a helping hand sometimes, and with JavaHelp 2.0, help is finally available. In this article, you'll learn how to use the Java platform's unique help system API to build a standard, full-featured, easy-to-use system for presenting online information to Java application users.
|
|
Articles |
|
29 Apr 2004 |
|
| |
Model with the Eclipse Modeling Framework, Part 2: Generate code with Eclipse's Java Emitter Templates
Eclipse's Java Emitter Templates (JET) is an open source tool for generating code within the Eclipse Modeling Framework (EMF). JET is similar to Java Server Pages, but is powerful and flexible enough to generate Java, SQL, and any other languages, including JSPs. This article covers how to create and configure JET and deploy it in a variety of environments.
|
|
Articles |
|
27 Apr 2004 |
|
| |
Java theory and practice: Coaxing J2EE out of the container
Most projects fall squarely into either the category of J2EE application or J2SE application. However, there are a number of J2EE technologies that can exist outside of the J2EE container, and some J2SE applications may benefit from them. This month, Brian Goetz looks at how some J2EE services can be used in J2SE applications. Share your thoughts on this article with the author and other readers in the accompanying discussion forum.
|
|
Articles |
|
20 Apr 2004 |
|
| |
Model with the Eclipse Modeling Framework, Part 1: Create UML models and generate code
The Eclipse Modeling Framework (EMF) is an open source framework for developing model-driven applications. It creates Java code for graphically editing, manipulating, reading, and serializing data based on a model specified in XML Schema, UML, or annotated Java. EMF is the basis for many of the tools within IBM WebSphere Studio and Eclipse projects. This article will step you through the process of creating a model, generating code, using the generated applications, and customizing the editor.
|
|
Articles |
|
15 Apr 2004 |
|
| |
Java programming dynamics, Part 7: Bytecode engineering with BCEL
The Apache Byte Code Engineering Library (BCEL) lets you dig into the bytecode of Java classes. You can use it to transform existing class representations or construct new ones, and because BCEL works at the level of individual JVM instructions, it gives you the utmost power over your code. That power comes with a cost in complexity, though. In this article, Java consultant Dennis Sosnoski gives you the BCEL basics and guides you through an example BCEL application so you can decide for yourself if the power justifies the complexity.
|
|
Articles |
|
14 Apr 2004 |
|
| |
Considerations of globalization solutions in J2ME
This article explores a solution for globalization applications in Java 2 Platform, Micro Edition (J2ME). It describes this solution throughout the software development life cycle, including requirements analysis, design, implementation, testing, and deployment. You'll learn why globalization is important in J2ME applications, the guidelines for developing a globalization application, and how to implement these guidelines throughout the development cycle.
|
|
Articles |
|
13 Apr 2004 |
|
| |
Control your test-environment with DbUnit and Anthill
The inception of the Extreme Programming methodology has brought test-driven development and continuous integration into mainstream Java development practices. Applying these techniques to Java server-side development can quickly become a nightmare if you don't have the right tools. In this article, software developer Philippe Girolami describes how to deal with continuous integration and how to use DbUnit in conjunction with JUnit to control the test environment end-to-end by setting up the state of the database before each test.
|
|
Articles |
|
13 Apr 2004 |
|
| |
Get the message: Messaging in J2EE 1.4
As more and more application servers that comply with the new J2EE 1.4 spec become available, Java developers will have to consider how -- and if -- they should migrate their J2EE 1.3-compliant code. In this article, David Currie takes a look at the changes to one particular area of the J2EE specification: messaging. You'll see what you'll need to change, what you can leave as is, and what new opportunities await you.
|
|
Articles |
|
09 Apr 2004 |
|
| |
Introduction to Jython, Part 1: Java programming made easier
This is the first in a two-part tutorial that will introduce you to the Jython scripting language and provide you with enough knowledge to begin developing your own Jython-based applications. In this first half of the tutorial, you'll learn the concepts and programming basics of working with Jython, including access options and file compilation, syntax and data types, program structure, procedural statements, and functions.
|
|
Tutorials |
|
08 Apr 2004 |
|
| |
Developing Struts with Easy Struts for Eclipse
This article shows you how to develop a Struts application in the Eclipse IDE, with the help of the Easy Struts plug-in. You'll get an introduction to Easy Struts, installation and configuration steps, and instructions on building a basic Struts application through a progressive example. Different ways of enhancing the Struts application -- such as connecting to a database, modularizing the application, internationalizing and localizing content, handling exceptions, and creating custom plug-ins -- are also covered. Finally, you will learn how to deploy your Struts application on the Tomcat Web server.
|
|
Articles |
|
08 Apr 2004 |
|
| |
Introduction to Jython, Part 2: Programming essentials
This is the second installment in a two-part tutorial designed to introduce you to the Jython scripting language. Part 1 covered the basics of Jython, including installation and setup, access options and file compilation, syntax and data types, program structure, procedural statements, and functions. In Part 2, you will delve into some of the more advanced aspects of working with this powerful scripting language, starting with an in-depth introduction to object-oriented programming with Jython. You'll also learn about topics essential to the mechanics of application development in any language, including debugging, string processing, and file I/O.
|
|
Tutorials |
|
08 Apr 2004 |
|
| |
Unclog the server bottleneck with active containers
Regular developerWorks contributor Aashish Patil offers yet another inventive solution to a common problem. In this article, Aashish shows you how to use containers to overcome data-processing redundancy, which can otherwise drain the life out of your handheld or Web server.
|
|
Articles |
|
06 Apr 2004 |
|
| |
Taming Tiger: Formatted output
Tiger brings printf-style formatted output to the world of Java programming, and this month, columnist John Zukowski discusses all facets of the C-inspired support for printf and format strings.
|
|
Articles |
|
02 Apr 2004 |
|
| |
Java theory and practice: Fixing the Java Memory Model, Part 2
JSR 133, which has been active for nearly three years, has recently issued its public recommendation on what to do about the Java Memory Model (JMM). In Part 1 of this series, columnist Brian Goetz focused on some of the serious flaws that were found in the original JMM, which resulted in some surprisingly difficult semantics for concepts that were supposed to be simple. This month, he reveals how the semantics of volatile and final will change under the new JMM, changes that will bring their semantics in line with most developers' intuition. Some of these changes are already present in JDK 1.4; others will have to wait until JDK 1.5. Share your thoughts on this article with the author and other readers in the accompanying discussion forum.
|
|
Articles |
|
30 Mar 2004 |
|
| |
Tracing in a multithreaded, multiplatform environment
Most Java programmers use some kind of tracing system to keep track of potential errors and problems in code that is under development. However, multithreaded and multiplatform systems can generate a large and baffling amount of tracing data. In this article, software engineer Daniel Would offers some tips that will help you make sense of trace data from complex applications. You'll learn how to use log4j, an open source logging package, to generate information-rich log files. You'll also see how you can use standard UNIX shell commands to mine that data for the information you need.
|
|
Articles |
|
18 Mar 2004 |
|
| |
Threads and networking in J2ME
This tutorial teaches you how to use threads in MIDlets to communicate over a network connection. Without multithreading, a MIDlet that requests a network connection blocks while waiting for a response from the network. In the real world, a user expects the application to continue running, even while a network connection is underway. The tutorial demonstrates the problems of non-threaded MIDlets and lets you build a multithreaded MIDlet.
|
|
Tutorials |
|
16 Mar 2004 |
|
| |
Tune Eclipse's startup performance with the Runtime Spy, Part 2
One of Core Tools available from Eclipse.org, the Runtime Spy is a perspective and set of views specifically designed to help you find and diagnose plug-in startup performance problems. This article describes how to find common programming mistakes that may lead to poor startup time and how to correct them. Included is a case study demonstrating how the Runtime Spy was used to improve the startup performance of IBM WebSphere Studio Application Developer. The previous article, Part 1, introduces the Runtime Spy.
|
|
Articles |
|
16 Mar 2004 |
|
| |
Mobile database access
This tutorial shows you how to build a database application using Java 2 Micro Edition (J2ME) Record Management System (RMS). It also demonstrates how to craft a MIDlet that performs the necessary logic of creating and accessing a sample database application and deploys it to a J2ME environment.
|
|
Tutorials |
|
09 Mar 2004 |
|
| |
Use AOP to maintain legacy Java applications
If you've ever inherited and then had to maintain a Java-based legacy application, then this article is for you. Author Abhijit Belapurkar shows you how to use aspect-oriented programming (AOP) to gain an unprecedented view into the inner workings of even the most opaque of legacy applications.
|
|
Articles |
|
09 Mar 2004 |
|
| |
Tune Eclipse's startup performance with the Runtime Spy, Part 1
This article introduces the Runtime Spy, one of Core Tools available from Eclipse.org. The Runtime Spy is a perspective and set of views specifically designed to help you find and diagnose plug-in startup performance problems.
|
|
Articles |
|
04 Mar 2004 |
|
| |
Build an LSID Resolution Service using the Java language
We take you through a step-by-step approach to building a Java technology-based Life Sciences Identifier (LSID) authority from scratch. We demonstrate how to build this on a minimal data set and on data downloaded from the protein sequence database Swiss-Prot, all on the Linux platform.
|
|
Articles |
|
03 Mar 2004 |
|
| |
Java programming dynamics, Part 6: Aspect-oriented changes with Javassist
Java consultant Dennis Sosnoski saves the best for last in his three-part coverage of the Javassist framework. This time he shows how the Javassist search-and-replace support makes editing Java bytecode practically as easy as a text editor's Replace All command. Want to report all writes to a particular field or patch in a change to a parameter passed in a method call? Javassist makes it easy, and Dennis shows you how.
|
|
Articles |
|
02 Mar 2004 |
|
| |
Taming Tiger: Loading Properties from XML
The Properties class is an old favorite, around since the beginning of Java programming time with very few changes. The Tiger release of J2SE enhances this class, which allows you not only to use it to specify key-value pairs on a single line separated by an equal sign, but also to use XML files to load and save those key-value pairs. In this installment of Taming Tiger, John Zukowski demonstrates how to use this updated work horse.
|
|
Articles |
|
25 Feb 2004 |
|
| |
Java theory and practice: Fixing the Java Memory Model, Part 1
JSR 133, which has been active for nearly three years, has recently issued its public recommendation on what to do about the Java Memory Model (JMM). Several serious flaws were found in the original JMM, resulting in some surprisingly difficult semantics for concepts that were supposed to be simple, like volatile, final, and synchronized. In this installment of Java theory and practice, Brian Goetz shows how the semantics of volatile and final will be strengthened in order to fix the JMM. Some of these changes have already been integrated in JDK 1.4; others are slated for inclusion in JDK 1.5.
|
|
Articles |
|
24 Feb 2004 |
|
| |
Lock down J2ME applications with Kerberos, Part 3: Establish secure communication with an e-bank
If you have participated in the first two lessons in this series, you are now ready for the third and final project in which you'll set up a KDC server, send a Kerberos ticket request to it, and fetch its response. Of course, you'll then study the low level ASN1 processing methods required to process the KDC server's response in order to fetch the ticket and the session key. Once you have the service ticket, you'll send a request to the e-bank's business logic server to establish a secure context. Finally, you'll see the actual secure communication with the e-bank's business logic server.
|
|
Articles |
|
18 Feb 2004 |
|
| |
AOP banishes the tight-coupling blues
Many Java developers have embraced the non-intrusive style and flexibility of aspect-oriented programming (AOP), particularly when it comes to building highly decoupled and extensible enterprise systems. In this article, you'll see for yourself how one of AOP's functional design concepts -- static crosscutting -- can turn what might be a tangled mass of tightly coupled code into a powerful, extensible enterprise application.
|
|
Articles |
|
18 Feb 2004 |
|
| |
Client and server-side templating with Velocity
Velocity is a versatile, open source templating solution that can be used standalone in report generation/data transformation applications, or as a view component in MVC model frameworks. In this article, Sing Li introduces Velocity and reveals how you can integrate its template-processing capabilities into your own client-side standalone application, server-side Web application, or Web services.
|
|
Articles |
|
10 Feb 2004 |
|
| |
Designing MIDP applications
When designing software applications for devices such as cell phones and PDAs, you must consider any potential problems, such as resource-challenged platforms for instance. With those tasks in mind, Mikko Kontio walks you through the design process for MIDP-based applications.
|
|
Articles |
|
10 Feb 2004 |
|
| |
The Servlet API and NIO: Together at last
Think it's impossible to combine NIO and the Servlet API? Think again. In this article, Java developer Taylor Cowan shows you how to apply the producer/consumer model to consumer nonblocking I/O, thus easing the Servlet API into a whole new compatibility with NIO. In the process, you'll see what it takes to build an actual Servlet-based Web server that implements NIO; and you'll find out how that server stacks up against a standard Java I/O server (Tomcat 5.0) in an enterprise environment.
|
|
Articles |
|
03 Feb 2004 |
|
| |
Java programming dynamics, Part 5: Transforming classes on-the-fly
After a short hiatus, Dennis Sosnoski is back with Part 5 of his Java programming dynamics series. Prveiously, you've seen how to write a program that transforms Java class files to change code behavior. In this installment, Dennis shows you how to combine transformation with the actual loading of classes using the Javassist framework, for flexible "just-in-time" aspect-oriented feature handling. This approach lets you decide what you want to change at runtime, and potentially make different modifications each time you run a program. Along the way you'll also get a deeper look at the general issues of classloading into the JVM.
|
|
Articles |
|
03 Feb 2004 |
|
| |
Encrypt data within mobile apps
In this tutorial, you'll employ the open standard Bouncy Castle to encrypt mobile MIDlet applications. The tutorial provides an overview of how to encrypt application-related data in a Java 2 Micro Edition (J2ME) application. It begins with a brief introduction to data encryption, then continues on to introduce the open source obfuscator, ProGuard. The final section in this tutorial compares MIDlet JAR file sizes, with and without obfuscation.
|
|
Tutorials |
|
03 Feb 2004 |
|
| |
Distributed transactions with WS-AtomicTransaction and JTA
The aim of this article is to introduce Web Services Transaction (WS-Transaction) concepts and its interaction with transaction services, specifically the J2EE transactional model, Java Transaction API (JTA). It references WebSphere Application Server in its examples and describes an interoperability scenario recently shown at a technology demo hosted by Steve Mills and Bill Gates.
|
|
Articles |
|
27 Jan 2004 |
|
| |
Java theory and practice: Garbage collection and performance
The past two installments of Java theory and practice have discussed various techniques for garbage collection and the basics of the JDK 1.4.1 garbage collectors. This month, columnist Brian Goetz looks at the performance impact of the choice of collector, how various coding idioms interact with the garbage collector, and how allocation and other related costs have changed in Java virtual machines over the past several years.
|
|
Articles |
|
27 Jan 2004 |
|
| |
J2EE pathfinder: Filtering with Java Servlets 2.4
The Servlet API has long been the cornerstone of enterprise application development, but Servlet filters are a relatively new addition to the J2EE family. In this final article in the J2EE pathfinder series, author Kyle Gabhart introduces you to the Servlet filter architecture, defines the many uses of filters, and walks you through the three steps of a typical filter implementation. He also spills the beans on some of the exciting changes you can expect from the just-released Java Servlet 2.4 specification.
|
|
Articles |
|
27 Jan 2004 |
|
| |
Design service-oriented architecture frameworks with J2EE technology
The loose coupling and interoperability inherent in a service-oriented architecture (SOA) make it a natural choice for the many enterprise applications. In this article, you'll see how the Web services features available in J2EE 1.4 make it easy to build SOA systems that provide access to the business processes that you already have.
|
|
Articles |
|
23 Jan 2004 |
|
| |
Migrate your Swing application to SWT
One of the reasons for the success of the Eclipse platform is the performance of its user interface compared to other Java applications. The SWT is a key contributor to that success. SWT allows you to build cross-platform user interfaces that are as rich as Swing UIs and that perform as well as native UIs, but the toolkit does have a drawback: SWT is not compatible with AWT and Swing. Java developer and Eclipse enthusiast Yannick Saillet offers this comprehensive, hands-on guide to porting a Swing application to SWT using extensive code samples to illustrate the techniques.
|
|
Tutorials |
|
19 Jan 2004 |
|
| |
XML-RPC in Java programming
Interapplication communication can be a nasty problem for programmers. Many of the available options, such as JNI, can be difficult to use. XML-RPC provides a much easier solution. It's clean, simple to implement, and well supported by open source libraries for most popular programming languages (such as Java language and C++). If you have a Java application, for example, that needs to talk to an application written in C++, XML-RPC just might be the simplest approach. In this article, software developer and coach Roy Miller talks about what XML-RPC is and how to use it effectively.
|
|
Articles |
|
13 Jan 2004 |
|
| |
J2ME 101, Part 4: The Generic Connection Framework
The Generic Connection Framework (GCF) provides an extensible, generic I/O framework for resource constrained devices. In this final installment in the J2ME 101 series, author John Muchow walks you through the GCF interfaces, showing you how they facilitate the development and support of various types of network and file I/O on MIDP.
|
|
Articles |
|
13 Jan 2004 |
|
| |
XML programming in Java technology, Part 1
This updated tutorial covers the basics of manipulating XML documents using Java technology. Doug Tidwell looks at the common APIs for XML and discusses how to parse, create, manipulate, and transform XML documents.
|
|
Tutorials |
|
13 Jan 2004 |
|
| |
Session management with J2ME and PHP
This tutorial provides an introduction to session management between a J2ME MIDlet and a Web server running PHP.The course discusses how to create and establish connections using HTTP, and also has a short overview of PHP, including how PHP and HTML work together to create dynamic content.
|
|
Tutorials |
|
13 Jan 2004 |
|
| |
2D animation with image-based paths
Why code your animated sequences when you can draw what you want and let a program do the rest? In this article, Barry Feigenbaum and Tom Brunet show you how to combine lossless images, Swing technology, and the authors' own Java-based animation engine to generate movement sequences for fixed objects in 2D animation.
|
|
Articles |
|
09 Jan 2004 |
|
| |
Managed mobile clients with OSGi: Managed smart clients
The Open Service Gateway initiative (OSGi) framework provides a Java technology-based lightweight (fully J2ME-compatible) container for dynamic software components. It handles the interactions between components and allows developers to remotely manage the entire application life cycle, including over-the-network deployment and updating. The OSGi framework was originally designed to fit the needs of pervasive devices, which need to run a variety of different software and to be managed remotely. Examples of such devices include smart home information hubs (for example, TV set-top boxes), automobile-mounted devices and even enterprise PDA devices. As more and more developers discover the power of OSGi, it has recently been used beyond the mobile embedded gateway context. For example, it has been selected as the next generation MicroKernel of the Eclipse IDE platform. In this excerpt chapter from the book Enterprise J2ME, Michael Yuan introduces you to OSGi programming and gives two complete example applications that run on PDA devices.
|
|
Articles |
|
23 Dec 2003 |
|
| |
Magic with Merlin: The generics prototype
J2SE 1.5 (a.k.a. Tiger) hasn't yet made its official debut, but you can take the early access release of the generics prototype download out for a spin now. Try out parameterized types, enumerations, variable argument lists, autoboxing, enhanced for loops, and static imports -- all language-level enhancements expected in the 1.5 release of J2SE. Share your thoughts on this article with the author and other readers in the accompanying discussion forum.
|
|
Articles |
|
19 Dec 2003 |
|
| |
Apache Ant 101: Make Java builds a snap
Whether you're a veteran user of Apache Ant in need of a refresher or just starting out with this open source Java-based build tool, this tutorial provides a wealth of information. With Java developer and Ant enthusiast Matt Chapman from the IBM Java Technology Centre, you'll walk through the steps involved in writing a build file for a simple Java project, and then look at some of Ant's other useful functions, including filesystem operations and pattern matching. You'll finish the course by writing our own Java class that extends Ant's functionality.
|
|
Tutorials |
|
17 Dec 2003 |
|
| |
J2ME 101, Part 2: Introduction to MIDP''s low-level user interface
This second part of a two-part tutorial series on J2ME shifts the focus from MIDP's high-level user interface to the most important components of the low-level interface. You'll learn the basics of creating and working with the Canvas and Graphics classes. As with Part 1, you will learn about each component and build a MIDlet to demonstrate its capabilities. The tutorial will conclude with a brief overview of the Game API, introduced with MIDP 2.0.
|
|
Tutorials |
|
17 Dec 2003 |
|
| |
Work with sprites in J2ME
This tutorial shows you how to create two MIDlets (J2ME applications). The first will demonstrate how to create and display an animated sprite, whereas the second will be a simple game that illustrates collision detection in action.
|
|
Tutorials |
|
16 Dec 2003 |
|
| |
J2ME 101, Part 3: Inside the Record Management System
MIDP does not use a filesystem to save application data. Rather, MIDP stores all information in non-volatile memory, using a storage system called the Record Management System (RMS). In In this article, the first in a two-part companion series to the J2ME 101 tutorial series, author and developer John Muchow introduces the basics of the RMS application interface, then walks you through several development examples that illustrate its functionality.
|
|
Articles |
|
12 Dec 2003 |
|
| |
Create a portable Web service in multiple J2EE environments
This tutorial shows how to create a portable end-to-end Web service in multiple J2EE environments with the IBM WebSphere Studio Application Developer 5.1.1 Web Service wizard. The Web service client and server application code are generated with different runtimes and EARs. The Web service is deployed to a remote server.
|
|
Tutorials |
|
04 Dec 2003 |
|
| |
Eclipse and HSQLDB: Embedding a relational database server into Eclipse, Part 2
The first part of this series introduced the HSQLDB engine for embedded applications that can also serve as a development platform for projects targeting "bigger" databases. We created an Eclipse plug-in and started pre-existing tools from Workbench menus. In this second part, we'll look at how to use Eclipse features to overcome some limitations of the plug-in developed in the first part, such as allowing many concurrent active HSQLDB server instances, each one listening for connections on a different TCP port.
|
|
Articles |
|
04 Dec 2003 |
|
| |
Master the Tiles Framework
In this hands-on tutorial, Tiles master Rick Hightower guides you through more advanced uses of the Tiles framework, including compartmentalizing your presentation tier to better reuse layouts, HTML, and other visual components. You will build these visual componentswith JSP (JavaServer Pages) technology using custom tags and Java scriptlets.
|
|
Tutorials |
|
01 Dec 2003 |
|
| |
Lock down J2ME applications with Kerberos, Part 2: Authoring a request for a Kerberos ticket
In the last article in this series, you saw the outlines of a J2ME application that can connect securely to a Kerberos-enabled server; you also learned the details of how Kerberos encryption works at the byte level. This article gets into the meat of the application itself. You'll see how to use the J2ME's facilities and some open source libraries to perform surprisingly powerful encryption routines.
|
|
Articles |
|
25 Nov 2003 |
|
| |
J2EE pathfinder: Java security with JAAS and JSSE
Kyle Gabhart introduces the Java Authentication and Authorization Service (JAAS) and the Java Secure Socket Extension (JSSE). Follow along to find out how these two APIs combine to provide the core functions of the J2EE Web application security framework: authentication, authorization, and transport-level security.
|
|
Articles |
|
25 Nov 2003 |
|
| |
Java theory and practice: Garbage collection in the HotSpot JVM
Brian Goetz examines how the 1.4.1 JVM actually handles garbage collection, including some of the new garbage collection options for multiprocessor systems.
|
|
Articles |
|
25 Nov 2003 |
|
| |
Using the WS-I Test Tools with Java technology
"Understanding the WS-I Test Tools" presented an overview of the architecture and functions provided by the WS-I Test Tools. In this tutorial, we give you step-by-step instructions on how to use the Java version of the test tools to verify that a sample Web service conforms to the WS-I Basic Profile.
|
|
Tutorials |
|
25 Nov 2003 |
|
| |
J2ME 101, Part 1: Introduction to MIDP''s high-level user interface
This is the first installment of a comprehensive four-part introduction to Java 2 Micro Edition (J2ME) and the Mobile Information Device Profile (MIDP). The series will consist of two tutorials and two companion articles. In this first tutorial, you will learn about the essential components of J2ME, with a primary focus on MIDP. The focus is on MIDP's high-level user interface, with a step-by-step introduction to the components that facilitate the main interaction between the user and the device display.
|
|
Tutorials |
|
20 Nov 2003 |
|
| |
Equipping SWT applications with content assistants
For users of the Eclipse Java editor, content assistants are a well-known feature. You can easily add this feature to any SWT-based application, either a stand-alone application or a plug-in to the Eclipse workbench.
|
|
Articles |
|
19 Nov 2003 |
|
| |
Magic with Merlin: Indeterminate progress bars
Developers use a JProgressBar component to show users how far along a task has progressed. For really long tasks or those where it's difficult to figure out exactly how far along that task is, the Merlin release adds an indeterminate mode to JProgressBar. This month, columnist John Zukowski provides a refresher on using JProgressBar and discusses its new indeterminate mode.
|
|
Articles |
|
18 Nov 2003 |
|
| |
Navigate the JNDI maze
EJB developer Daniel Would explains how you can write client code that successfully finds its way to an EJB component published in a JNDI namespace. He shows you various programming options that make the process easier, and offers some code that you can use as a utility class in your own applications.
|
|
Articles |
|
18 Nov 2003 |
|
| |
Monitor and estimate logical log usage in Informix Dynamic Server
This article will discuss in detail how to configure and manage logical logs. The article will also demonstrate a real life example how to estimate and predict logical log usage.
|
|
Articles |
|
18 Nov 2003 |
|
| |
Remote scripting servlet in action
This article presents a Web-based incoming-call monitor for a Customer Service Representative (CSR) in a Customer Relationship Management, or CRM, product based on Erik Hatcher's work, "Remote scripting using a servlet." To take that a step further, Victor Yang here analyzes those requirements and looks into such design options as why IFRAME is recommended over XML-RPC. Finally, he'll show you how to customize the original framework while explaining the key issues that take place during implementation with the code snippets.
|
|
Articles |
|
11 Nov 2003 |
|
| |
Java certification success, Part 1: SCJP
This tutorial is designed to prepare programmers for the Sun Certified Java Programmer (SCJP) 1.4 exam, providing a detailed overview of all the exam's main objectives.
|
|
Tutorials |
|
06 Nov 2003 |
|
| |
Scheduling recurring tasks in Java applications
All manner of Java applications commonly need to schedule tasks for repeated execution. However, the standard scheduling classes, Timer and TimerTask, are not flexible enough to support the range of scheduling tasks typically required. In this article, Tom White shows you how to build a simple, general scheduling framework for task execution conforming to an arbitrarily complex schedule.
|
|
Articles |
|
04 Nov 2003 |
|
| |
Java theory and practice: A brief history of garbage collection
Garbage collection has been an integral part of many programming languages and has been in use since the early 1960s. In this article, Brian Goetz describes the most common techniques for garbage collection.
|
|
Articles |
|
28 Oct 2003 |
|
| |
Lock down J2ME applications with Kerberos, Part 1: Introducing Kerberos data formats
Users need assurance that the wireless applications they use won't compromise their sensitive information. One way to do that is to use industry-standard protocols like Kerberos to provide security. In this series, Faheem Khan will build a sample J2ME MIDlet that uses Kerberos to protect financial data. In this first article of the series, he lays the foundation by explaining the Kerberos data formats that will provide the backbone for his application's security.
|
|
Articles |
|
28 Oct 2003 |
|
| |
J2EE pathfinder: Implement JSP custom tags in five easy steps
Kyle Gabhart introduces the basics of JSP custom tags and takes you through the five-step process of incorporating them into your JSP pages.
|
|
Articles |
|
22 Oct 2003 |
|
| |
Magic with Merlin: Dynamic event listener proxies
Java 1.4 introduces the EventHandler class, which relies on the dynamic generation of listeners to ease the task at hand. Though the new features are typically meant for the IDE vendor to use, in this article columnist John Zukowski shows you how you can use them for hand coding, too.
|
|
Articles |
|
21 Oct 2003 |
|
| |
Store objects using the Preferences API
This article offers an introduction to the Preferences API, a lightweight, cross-platform persistence API introduced in JDK 1.4 and designed to store small amounts of data. Greg Travis explains how objects are stored, demonstrates the process in action, and provides a code library to do the work.
|
|
Articles |
|
14 Oct 2003 |
|
| |
JAR files revealed
Most Java programmers are familiar with basic operations on JAR files. But few programmers are aware of the power of the JAR file format. In this article, the authors explore the many features and benefits of the JAR format, including packaging, executable jar files, security, and indexing.
|
|
Articles |
|
09 Oct 2003 |
|
| |
Advanced DAO programming
J2EE developers use the Data Access Object (DAO) design pattern to separate low-level data access logic from high-level business logic. Implementing the DAO pattern involves more than just writing data access code. In this article, Java developer Sean C. Sullivan discusses three often overlooked aspects of DAO programming: transaction demarcation, exception handling, and logging.
|
|
Articles |
|
07 Oct 2003 |
|
| |
PDA images with J2ME
This tutorial demonstrates how to download and display images with J2ME (Java 2 Micro Edition) and the Mobile Information Device Profile (MIDP).
|
|
Tutorials |
|
07 Oct 2003 |
|
| |
Eclipse and HSQLDB: Embedding a relational database server into Eclipse, Part 1
This article shows how to develop a plug-in that embeds the HSQLDB pure-Java relational database server into the Eclipse Workbench. Although not as powerful as DB2 and not as popular as MySQL, HSQLDB (the hypersonic SQL database) can satisfy the needs of a wide range of Java applications, because of its extensibility and low memory/processor requirements.
|
|
Articles |
|
30 Sep 2003 |
|
| |
Build and implement a single sign-on solution
It is particularly difficult to bolt a single sign-on solution -- SSO, the ability to log in once and be authenticated to all your network resources -- onto existing applications, but every developer faces this problem when building sophisticated portals. Because portals need to integrate with back-end resources, each with its own authentication needs, the portal often has to provide the appearance of single sign-on to the user. In this article, Chris Dunne provides a step-by-step description of his experience with building a single sign-on solution for a Web portal. He shows you how to set up an open source solution, the Central Authentication Service from Yale University, and how to extend it to authenticate to a Microsoft Active Directory infrastructure.
|
|
Articles |
|
30 Sep 2003 |
|
| |
SIP: Creating next-generation telecom applications
Developing applications to run on a telecommunications network has never been easier. Instead of yesterday's proprietary protocols and interfaces, you now can use open, Internet-based standards such as the Session Initiation Protocol (SIP). Combined with the power and simplicity of Java technology in the form of the SIP Servlet API, an application developer can create and deploy new services to users in a fraction of the time it previously took. Taking advantage of this revolution means being conversant with SIP. In this article, you'll discover how SIP operates and, building on that knowledge, you will learn how to use the Java SIP Servlet API to build the exciting new applications of the future. The SIP tour concludes with code examples that demonstrate SIP application development in action.
|
|
Articles |
|
30 Sep 2003 |
|
| |
Entity management in XML applications
Entity management is the term used to describe the process for controlling how an XML application discovers and accesses external resources known as entities. Entity management is an often overlooked aspect of XML application development. However, the technique offers a number of advantages. This tutorial presents the basic principles of entity management through the concept of an XML catalog -- an address book that defines mappings from resources referenced in XML documents (such as a stylesheet or schema) to URI references (such as file system paths or URLs).
|
|
Tutorials |
|
30 Sep 2003 |
|
| |
Java theory and practice: Characterizing thread safety
In July our concurrency expert Brian Goetz described the Hashtable and Vector classes as being conditionally thread-safe. Shouldn't a class either be thread-safe or not? Unfortunately, thread safety is not an all-or-nothing proposition, and it is surprisingly difficult to define. But, as Brian explains in this month's Java theory and practice, it is critically important that you make an effort to classify the thread safety of your classes in their Javadoc.
|
|
Articles |
|
23 Sep 2003 |
|
| |
Magic with Merlin: SpringLayout manager
The newly introduced SpringLayout manager offers an alternative when designing complex screens, allowing components to be positioned relative to one another. In this article, Merlin veteran John Zukowski shows you how to use this new layout manager.
|
|
Articles |
|
17 Sep 2003 |
|
| |
Java programming dynamics, Part 4: Class transformation with Javassist
Java consultant Dennis Sosnoski takes a look at Javassist, the bytecode manipulation library that's the basis for the aspect-oriented programming features being added to the widely used JBoss application server. You'll find out the basics of transforming existing classes with Javassist and see both the power and the limitations of this framework's source code approach to classworking.
|
|
Articles |
|
16 Sep 2003 |
|
| |
Add XML parsing to your J2ME applications
More and more enterprise and Java technology projects are making use of XML as a medium to store data in a portable fashion. But due to the increased processing power demanded by XML parsers, J2ME applications have largely been left out of this trend. Now, however, small-footprint XML parsers for the Java language are emerging that will allow MIDP programmers to take advantage of the power of XML. Soma Ghosh illustrates their potential with a sample application.
|
|
Articles |
|
16 Sep 2003 |
|
| |
Simplify enterprise Java authentication with single sign-on
Faheem Khan shows you how to implement single sign-on (SSO) functionality on the Java platform. You'll see how you can use the GSS-API and Kerberos standards to abstract away some of the difficulty, and implement an SSO-based architecture with relative ease.
|
|
Articles |
|
09 Sep 2003 |
|
| |
Refactoring for everyone
Eclipse provides a powerful set of automated refactorings that, among other things, let you rename Java elements, move classes and packages, create interfaces from concrete classes, turn nested classes into top-level classes, and extract a new method from sections of code in an old method. Becoming familiar with Eclipse's refactoring tools is a good way to improve your productivity. This survey of Eclipse's refactoring features, with examples, demonstrates how and why to use each.
|
|
Articles |
|
09 Sep 2003 |
|
| |
Access USB devices from Java applications
Java technology's platform independence makes the process of writing Java applications that interact with hardware quite tricky. In this article, research scientist Qingye Jiang examines two projects that are making the process easier by providing APIs through which Java applications can make use of USB devices.
|
|
Articles |
|
02 Sep 2003 |
|
| |
UI development with JavaServer Faces
This tutorial provides an overview of JavaServer Faces (JSF) and walks you through the basics for developing Web applications using the technology. With Java developer and consultant Jackwind Li Guojie as your guide, examine the JSF life cycle, input validation, event handling, page navigation, and internationalization -- all of which are illustrated through a sample application.
|
|
Tutorials |
|
02 Sep 2003 |
|
| |
J2EE pathfinder: The many uses of implicit objects
In this follow-up to last month's introduction to session scopes, Java enterprise expert Kyle Gabhart delves into the many uses of JSP implicit objects. Follow along as he introduces the nine implicit objects, explains the purpose (and multiple purposes) of each one, and closes with a list of best practices for using these handy little workers in your JSP programming efforts.
|
|
Articles |
|
26 Aug 2003 |
|
| |
Discover key features of DOM Level 3 Core, Part 2
In this two-part article, the authors present some of the key features brought by the W3C Document Object Model (DOM) Level 3 Core Working Draft and show you how to use them with examples in Java code. In this second part, they cover operations on the document, access to type information, and introduce you to the early implementation of this API in the Apache Xerces2 project.
|
|
Articles |
|
26 Aug 2003 |
|
| |
Java theory and practice: Building a better HashMap
Brian Goetz dives into the code of ConcurrentHashMap and looks at how it achieves excellent throughput and concurrency without compromising thread safety.
|
|
Articles |
|
21 Aug 2003 |
|
| |
Tip: Attributes in ContentHandler
The one aspect of data processing with ContentHandler that the author didn't cover in his last tip was attribute processing. While attributes are most commonly used for information transfer between an XML document and an XML processor, they also often contain valuable business data. In this tip, Brett shows you how SAX handles elements and reports those elements, as well as how you can use code to extract element data.
|
|
Articles |
|
21 Aug 2003 |
|
| |
Dynamic JNLP
This tutorial examines a custom, dynamic implementation of Java Network Launch Protocol (JNLP) to shift some of the server's processing load to the client. Veteran developer Claude Lacombe draws on his experience developing an industrial-sized application that required some modifications to JNLP and presents the fruits of his labor. A fully-functioning application is provided for guidance.
|
|
Tutorials |
|
20 Aug 2003 |
|
| |
Discover key features of DOM Level 3 Core, Part 1
In this two-part article, the authors present some of the key features brought by the W3C Document Object Model (DOM) Level 3 Core Working Draft and show you how to use them with examples in Java code. This first part covers manipulating nodes and text, and attaching user data onto nodes.
|
|
Articles |
|
19 Aug 2003 |
|
| |
Build a life sciences collaboration network with LSID
If widely adopted, the Life Sciences Identifier protocol will enable scientists and researchers across multiple organizations to share data and collaborate in ways never before considered. You can build services that implement the LSID protocol using a combination of J2EE components that abstract away the protocol handling itself, leaving only the necessity of writing the service logic.
|
|
Articles |
|
15 Aug 2003 |
|
| |
Tip: Elements and text in ContentHandler
With a solid understanding of the SAX ContentHandler interface (which you can obtain by reading my previous tips), you are ready to perform useful tasks with SAX. The most common task, of course, is obtaining the textual content of a specific element, and then doing something with that data. This tip details that process, from locating a certain element to reading its data.
|
|
Articles |
|
14 Aug 2003 |
|
| |
Magic with Merlin: Formatting numbers and currency
With the Merlin release of the J2SE platform, internationalizing your applications when formatting integers has gotten simpler, and you can now find out the ISO 4217 currency codes. In this month's Magic with Merlin column, John Zukowski shows you how to format numbers and introduces the new support for discovering local currency codes.
|
|
Articles |
|
13 Aug 2003 |
|
| |
Build interoperable Web services with JSR-109
JSR-109 facilitates the building of interoperable Web services in the Java 2 Platform, Enterprise Edition (J2EE) environment. It standardizes the deployment of Web services in a J2EE container. This article discusses the server and client programming models defined by JSR-109 and provides code examples.
|
|
Articles |
|
05 Aug 2003 |
|
| |
MIDlet music: Add sound with WTK
This tutorial shows how you can now create Java-based wireless applications that offer a range of sounds, from simple tones to playing WAV files.
|
|
Tutorials |
|
05 Aug 2003 |
|
| |
J2EE pathfinder: Create and manage stateful Web apps
In this installment of J2EE pathfinder, Java developer and consultant Kyle Gabhart sheds some light on the proper handling of the four J2EE session scopes for stateful Web application development.
|
|
Articles |
|
30 Jul 2003 |
|
| |
Java theory and practice: Concurrent collections classes
In addition to many other useful concurrency building blocks, Doug Lea's util.concurrent package contains high-performance, thread-safe implementations for workhorse collection types List and Map. This month, Brian Goetz shows you how many concurrent programs will benefit from simply replacing Hashtable or synchronizedMap with ConcurrentHashMap.
|
|
Articles |
|
23 Jul 2003 |
|
| |
Extend Eclipse's Java Development Tools
Extend Eclipse's Java development tools through the refactoring capability
of Eclipse's Java development environment. It is one of the most useful features
Eclipse Java platform provides. This article will introduce you to the steps for
creating your own refactoring as a natural extension of Eclipse.
|
|
Articles |
|
22 Jul 2003 |
|
| |
Java programming dynamics, Part 3: Applied reflection
Learn how the Java Reflection API can be used to simplify the job of command line argument processing. In this article, Java consultant Dennis Sosnoski outlines an open source library that makes command line arguments practically handle themselves.
|
|
Articles |
|
15 Jul 2003 |
|
| |
Magic with Merlin: Focus, focus, focus
Focus is the art of managing what component receives keyboard input and when it receives it. In past versions of J2SE, this feature didn't always work according to plan. In this article, columnist John Zukowski explores one of Merlin's many changes to remedy earlier focus problems.
|
|
Articles |
|
15 Jul 2003 |
|
| |
Getting started with new I/O (NIO)
The new input/output (NIO) library, introduced with JDK 1.4, provides high-speed, block-oriented I/O in standard Java code. This hands-on tutorial covers the NIO library in great detail, from the high-level concepts to under-the-hood programming detail. You'll learn about crucial I/O elements like buffers and channels, and examine how standard I/O works in the updated library.
|
|
Tutorials |
|
09 Jul 2003 |
|
| |
Servicing Eclipse plug-ins
This article describes strategies you can use to diagnose customer-reported problems with Eclipse plug-ins. The most powerful of these strategies is the ability to attach a debug session from one Eclipse instance to a running instance of Eclipse on a remote host. The strategies described in this article are valid for all products based on Eclipse 2.x, such as WebSphere Studio Application Developer and WebSphere Studio Site Developer.
|
|
Articles |
|
08 Jul 2003 |
|
| |
Tip: Set up a SAX parser
This is the first in a series of tips that will serve as a comprehensive guide to using XML from the Java programming language. I begin with coverage of the SAX API. This tip reviews getting an instance of a SAX parser and setting various features and properties on that parser.
|
|
Articles |
|
02 Jul 2003 |
|
| |
Demystifying Extreme Programming: Just-in-time design
XP advocate Roy Miller wraps up his series on Extreme Programming by showing you how safe and easy just-in-time (JIT) design is -- and how it just might revolutionize the way you write code.
|
|
Articles |
|
01 Jul 2003 |
|
| |
Java theory and practice: Whose object is it, anyway?
While garbage collection means that Java developers don't have to worry (much) about memory leaks, sometimes we still do have to worry about object ownership to prevent data races and unwanted side effects. In this article, Brian Goetz identifies some of the situations where Java developers must pay attention to object ownership.
|
|
Articles |
|
24 Jun 2003 |
|
| |
J2EE pathfinder: Enterprise messaging with JMS
In this installment of J2EE pathfinder, Java developer and consultant Kyle Gabhart explains why a messaging service is essential to your enterprise architecture, what kind of obstacles your solution must overcome, and what alternatives you have under the Java Message Service (JMS).
|
|
Articles |
|
24 Jun 2003 |
|
| |
Implementing Push technology with J2ME and MIDP
This tutorial will walk through the basics of using Push technology with MIDP 2.0, including development of a MIDlet that will be activated based on an incoming SMS message (Simple Message Service).
|
|
Tutorials |
|
24 Jun 2003 |
|
| |
Deploy an SWT application using Java Web Start
Over the past few months, the Standard Widget Toolkit (SWT) has
continued to pick up momentum and is capturing more and more of the brain-share
of Java developers. At some point in the development process of an SWT
application -- typically after a basic prototype is operational -- concerns
about the deployment process arise. Unlike traditional Java applications, SWT
applications require some operating system-specific libraries to be loaded
before an application can operate. While the ongoing deployment and maintenance
of these libraries might seem like a headache, rest assured there is a
solution: Sun Microsystems' Java Web Start. The marriage of SWT with Java Web
Start provides powerful tools to deploy great-looking client-side Java applications.
|
|
Articles |
|
19 Jun 2003 |
|
| |
Diagnosing Java code: The future of software development
Eric Allen discusses some of the current trends in software development and predicts what they may lead to in the coming years.
|
|
Articles |
|
17 Jun 2003 |
|
| |
Working with James, Part 1: An introduction to Apache's James enterprise e-mail server
This article is the first in a two-part series on the Java Apache Mail Enterprise Server, also known as James. It lays a foundation for understanding James and for developing server-side e-mail applications. The article provides a high-level overview, briefly touches on the Apache group's design objectives, and describes how to install and configure a workable development environment. You can also take a brief tour of the features supported by James.
|
|
Articles |
|
10 Jun 2003 |
|
| |
Working with James, Part 2: Build e-mail based applications with matchers and mailets
This is the second of two articles focused on developing applications with the James e-mail server from the Apache group. In this article, go beyond the basic James infrastructure and implement a practical application for flagging users as available or unavailable, and for automatically sending custom messages to senders from users who chose to make themselves unavailable.
|
|
Articles |
|
10 Jun 2003 |
|
| |
Integrate ActiveX controls into SWT applications
With the Standard Widget Toolkit (SWT), you can develop a stand-alone Java
application that feels and operates like a native application. If you've spent any
time developing Java client-side applications for Windows, you've probably wanted to
integrate some native Windows components into your applications. SWT, part of the
developing Eclipse Project, fulfills this need by giving you a way to easily leverage
and integrate ActiveX controls within a stand-alone SWT application.
|
|
Articles |
|
05 Jun 2003 |
|
| |
An SCJP 1.4 certification primer
The Sun Certified Java Programmer (SCJP) examination has recently been updated for J2SE 1.4, which means you'll have to jump through some new hoops to get a passing score. In this primer to SCJP certification, Pradeep Chopra, cofounder of Whizlabs Software, outlines some of the most important changes to the SCJP 1.4 exam, suggests several ways to prepare for it, and offers some sample questions to get you started.
|
|
