Java Validation With Dynamic Proxies

2010-05-26T11:20:14+00:00 May 14th, 2005|Java|

Version 1.3 of the Java platform saw the introduction of the dynamic proxy facility. Dynamic proxies offer many interesting solutions to Java developers, including a validation scheme that easily decouples validation logic from an application's core business logic. In this article, Java developer Eric Olson shows you how dynamic proxies can keep your core application code free of validation routines and focused solely on business logic.

JSF for Nonbelievers: The JSF Application Lifecycle

2010-05-26T11:22:48+00:00 May 5th, 2005|Java|

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

Assertion Extensions for JUnit

2010-05-26T11:22:55+00:00 May 5th, 2005|Java|

JUnit lets you test software code units by making assertions that the intended requirements are met, but these assertions are limited to primitive operations. IBM Software Engineer Tony Morris fills the gap by introducing Assertion Extensions for JUnit, which provides a set of complex assertions that execute within the JUnit framework. Follow along as the author shows you how using this new package from alphaWorks can increase the reliability and robustness of your Java™ software.

Practically Groovy: Go Server-Side Up, with Groovy

2010-05-26T11:23:13+00:00 May 5th, 2005|Java|

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.

StrutsTestCase Simplifies the Development Process

2010-05-26T11:26:14+00:00 April 28th, 2005|Java|

This article introduces the StrutsTestCase (STC) framework and explains how to test a sample application using the mock approach and Cactus approach. Author Sunil Patil, a developer at the IBM Software Labs in India, introduces STC, then walks you through setting up an environment for using STC and testing various Struts features. He also demonstrates using both the Cactus and mock approaches from within STC.

Eye on performance: Wait leaks

2010-05-26T11:26:20+00:00 April 28th, 2005|Java|

A fine line runs between performance tuning and debugging. Several particular categories of bugs, including memory errors and thread race conditions, frequently surface during performance tuning, and this month, our performance tuning experts Jack Shirazi and Kirk Pepperdine show how to spot a particular class of race conditions, called wait leaks.

Java Theory and Practice: Anatomy of a Flawed Microbenchmark

2010-05-26T11:27:43+00:00 April 27th, 2005|Java|

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.

Getting Started with Enumerated Types

2010-05-26T11:29:53+00:00 April 22nd, 2005|Java|

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.

Use Continuations to Develop Complex Web Applications

2010-05-26T11:30:02+00:00 April 22nd, 2005|Java|

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.