Design Patterns

Design Patterns

Learn Scala with Specs2 Spring
Using Specs2 Spring to test your Java apps is one way to start learning Scala's object-functional programming patterns, without leaving the Spring framework or tossing out perfectly good Java code.
Jan Machacek, December 2011

11 programming trends to watch
Whether you're banging out Cobol or hacking Node.js, keeping an eye on programming trends is key to staying competitive in an ever-shifting job market. Peter Wayner sorts the debris from the diamonds in this look at 11 tools and techniques that really are changing how developers work.
Peter Wayner, November 2011

Tough tests flunk good programmer job candidates
Quizzes and brain-teasers are useful in evaluating potential software development hires, but don't take them too far.
Neil McAllister, November 2011

Java Tip: When to use ForkJoinPool vs ExecutorService
This Java Tip demonstrates the performance impact of replacing the Java 6 <code>ExecutorService</code> class with Java 7's <code>ForkJoinPool</code>.
Madalin Ilie, October 2011

Lean service architectures with Java EE 6
Thanks to Java EE 6's simplified development model, a few interfaces and annotated classes are all you need to implement the facade, the service, and the domain structure that constitute a lean service-oriented architecture. Surprised? Read on.
Adam Bien, April 2009

Lamport's one-time password algorithm (or, don't talk to complete strangers!)
The Lamport algorithm provides an elegant scheme for generating and applying one-time passwords, or OTP. Find out how Lamport works, then see it in action with an OTP reference implementation for an extensible, Java-based library.
Louis J. Iacona, March 2009

Building cloud-ready, multicore-friendly applications, Part 1: Design principles
Atomicity, statelessness, idempotence, and parallelism: that's your ticket to code that's ready for both modern multicore chips and the future of distributed -- or cloud -- computing. Appistry engineer Guerry Semones introduces these four pillars of distributed design.
Guerry Semones, March 2009

The PathProxy pattern: Persisting complex associations
Matthew Tyson is back with another of his highly useful design patterns. Learn the ins and outs of the PathProxy pattern, which makes it easier to persist complex relationships without a proliferation of lookup tables.
Matthew Tyson, July 2008

Asynchronous HTTP and Comet architectures
There's a lot more to asynchronous, non-blocking HTTP than Comet. Get an overview of the programming techniques and servlet container extensions that are breathing new life into HTTP on the server side, with or without the support of the Java Servlet API.
Gregor Roth, March 2008

Asynchronous HTTP Comet architectures
There's a lot more to asynchronous, non-blocking HTTP than Comet. Get an overview of the programming techniques and servlet container extensions that are breathing new life into HTTP on the server side, with or without the support of the Java Servlet API.
Gregor Roth, March 2008

The AjaxComponent strategy for JSF: The best of both worlds
If you're looking to add Ajax functionality to your JSF applications, the AjaxComponent strategy provides the simplicity of a component and the power of a phase listener.
Matthew Tyson, December 2007

Exceptions for action
Is your code overloaded with exceptions? Get some guidelines for writing efficient, reusable exceptions that minimize processing overhead without leaving users or sysadmins in the dark.
Jean-Pierre Norguet, November 2007

REST easy with the JavaBeans Activation Framework
Find out what makes the JavaBeans Activation Framework a perfect vehicle for RESTful data transmission, then put JAF to work in a sample Web application that tracks requests and responses through a Java Servlet-based system.
Jeff Hanson, October 2007

Add dynamic Java code to your application
Did you ever wish your Java code could be dynamic like JavaServer Pages? That it could be modified and recompiled at runtime, with your application updating itself on the fly? This article shows you how to make your code dynamic. As such, some of your source code will be deployed, instead of compiled binary code. Any changes to the source code will cause it to be recompiled and the class to be reloaded. Your application will then run on the new class, and users will see the change immediately. This article covers not only runtime source compilation and class reloading, but also a design that separates the dynamic code from its caller. The caller holds a static reference to the dynamic code, and no matter how the dynamic code reloads at runtime, the caller can always access the up-to-date class without updating the reference. In this way, dynamic code changes are transparent to the client.
Li Yang, June 2006

Plug memory leaks in enterprise Java applications
Because Java uses automatic garbage collection, developers think Java programs are free from possible memory leaks. Although automatic garbage collection solves the main cause of memory leaks, they can remain in a Java program. Specifically, such memory leaks in complex multitiered applications can be extremely daunting to detect and plug. This article analyzes the main causes of memory leaks in Java Enterprise Edition (Java EE) applications, and suggests strategies for detecting them.
Ambily Pankajakshan, March 2006

Find more >