 |
|
|
|
|
|
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
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 |
|
| |
