Zero Configuration Networking: Using the Java APIs, Part 1

Article by Stuart Cheshire and Daniel H. Steinberg, 10 pages, 45 minutes.
If you're looking for a lightweight introduction to Bonjour/Zeroconf like I was, you should skip this article. The article dives straight into the details and often reads more like API documentation with intermingled do's-and-don'ts than it reads like an introduction to the topic. The references to the C and C++ APIs might be meaningful to experienced Bonjour developers, but were just a distraction to me.
read it

Crossing borders: Continuations, Web development, and Java programming

Article by Bruce Tate, 8 pages, 30 minutes.
In this edition of the Crossing Border series Tate goes into a brief investigation of Continuations, a concept that is supposed to seriously simplify web development. In Tates' words: "in two years time 90% of the web development will be done using continuations". Given the fact that continuations have been around since the mid 90's, I fail to see why they'll suddenly catch on now. But maybe that's just my lack of understanding, so that why I've added a few articles about continuations to my reading list.
read it

Mastering Ajax, Part 4: Exploiting DOM for Web response

Article by Brett McLaughlin, 11 pages, 30 minutes.
This fourth article in the series introduces the DOM. And it's really just that: an introduction; and a rather lightweight introduction for anyone that's followed along with the series or has done any serious web development work. I hope the next article in the series will be better, but I'm seriously starting to doubt whether the author will deliver on the promise of "mastering Ajax".
read it

Comparing Web Frameworks: RIFE

Blog post by Geert Bevin, 8 pages, 30 minutes.
In the series on comparing web frameworks, Bevin took it upon himself to create the reference application (a read only blog) using the RIFE framework that he created. It shows that the author is also the creator of the framework as the article often feels more like a sales pitch than an objective approach. As a result the article wanders of onto features of RIFE that are irrelevant to the blog application.
read it

Comparing Web Frameworks: Wicket

Blog post by JavaGeek, 8 pages, 30 minutes.
This article shows how to build a read-only weblog using the Wicket framework. It uses the same domain model as the other articles in the "Comparing Web Frameworks" category, allowing for easy comparison. Wicket seems to do a fine job of keeping the business logic out of your templates. It seems to do a lesser job of keeping view logic out of your Java code, but somehow that seems to bother most Java developers less.
read it

Against the Browser's Will: Make Mashups Talk Across Domains

Article by Dan Theurer, 5 pages, 15 minutes.
In this article the author compares three ways of performing cross domain usage of XMLHttpRequest. The JSON approach seems most flexible to me, since it doesn't require anything specific to be put on the server. But at the same time, this approach is not explained very well in the article. So I'll need to do some more research before I can use it in my own projects.
read it

Build your own profiling tool

Article by Andrew Wilcox, 10 pages, 30 minutes.
In this article the author shows how to create a simple profiler using Java Agents (a new feature in Java 5) and ASM (a byte code injection framework). The article sticks to only explaining the bare essentials and only mentions what other things are possible. As such it read more like a plug for Java Interactive Profiler than anything else. Still, I learned how to load Java Agents and that technology looks promising.
read it

Ruby on Rails and J2EE: Is there room for both?

Article by Aaron Rustad, 7 pages, 20 minutes.
This article tries to do a side-by-side comparison of the architectures of Rails and a typical Java (Struts+Hibernate) website. After already reading some more on Rails, I didn't learn anything new. It's probably not a bad read if you're a Struts + Hibernate developer and you want to learn more about this Rails-thing that everyone is talking about.
read it

Strategy Pattern with Generics

Newsletter by Heinz Kabutz, 7 pages, 45 minutes.
This newsletter covers a complex topic: writing generic interfaces and classes in Java. Although using generics is normally pretty easy, I find writing generic code rather dificult. The article gives a good case for using generics in combination with the Strategy pattern to avoid downcasts. While I think the amount of code and hard-to-read generics syntax in this case outweighs the loosing of a downcast, I can imagine cases where this approach would be worth its weight.
read it

All Hail Shale: Shale isn't Struts

Article by Brett McLaughlin, 12 pages, 45 minutes.
This article is the first in a series on Shale, the successor to the succesful Struts framework. This first edition goes into some of the architectural differences between Shale and Struts and shows how to install Shale. The architectural overview is way too high level to be really interesting. Combine that with the fact that the installation instructions could have been about half the number of pages they are now and you'll probably understand that I can only hope that he next article in the series is better.
read it

Copying Files from the Internet

Newsletter by Heinz Kabutz, 4 pages, 15 minutes.
In this newsletter the author introduces a simple class to download files from the internet. Although the class is simple and readable, I'm not sure why you'd want to use this instead of commonly available alternatives like wget.
read it

Introduction to the Java Speech API

Article by Nathan Tippy, 10 pages, 30 minutes.
The article starts with an overview of the Speech API in general. The overview is not the most readable, since it focuses on classes and interfaces instead of concepts. After the overview, the article switches to the FreeTTS library, explaining how to download and install it and how to build a sample application with it. The source code of the sample fills almost 6 pages of the article. All in all this article seems rather light on concepts, which luckily is reflected in the time it takes to read.
read it

Crossing borders: Exploring Active Record

Article by Bruce Tate, 10 pages, 45 minutes.
Tate seems to have become a big fan of Rails. Which makes him a good candidate for explaining some of it's benefits. In this case he focuses on Active Record, the persistence layer of Rails. There is not a web interface in sight, as all interaction is done through the command line or through Rails internal console. This really helped to not get side-tracked by other features of Rails. The article ends with a short summary of the Java RIFE framework, which didn't provide any value to me. But up until that, the article was well worth the time.
read it

Using Ruby on Rails for Web Development on Mac OS X

Article on apple.com, 13 pages, 1 hour.
Apple jumps on the Rails bandwagon with this article. I was expecting it to be more marketing than content, but it's actually a pretty good introduction to Rails development. They take you from the initial installation of Ruby and Rails, through the creation of a small expenses app, to deployment and testing. I must say that the bit about testing seems like an afterthought and you can easily skip it. But the rest of the article is a readable introduction to application development using Rails.
read it

Painless JavaScript Using Prototype

Article by Dan Webb, 15 pages, 1 hour.
This article shows you how to use the Prototype javascript library in your web pages. It introduces a lot of functionality of the library using small examples. While reading I was already thinking of how I could use the functions in my own web pages, so the article does a good job of drawing you in.

I must admit that near the end of the article the quality of the descriptions and code samples got less, even though this is where the most interesting functions are explained. Maybe the author should split these topics off into a separate article and give them the attention they deserve.
read it

New features added to Servlet 2.5

Article by Jason Hunter, 4 pages, 20 minutes.
The title sums it up nicely: this short article introduces the changes that have been made in Servlet 2.5. And although some of them are nice (wildcards in url-patterns for one), none of them are anywhere near groundbreaking. This makes the article sort of a dry read, trying to get us excited about little things. That also explains why it took me 20 minutes to get through just 4 pages.
read it

In pursuit of code quality: Resolve to get FIT

Article by Andrew Glover, 14 pages, 30 minutes.
In his article series on testing, Glover this time introduces data-driven testing using the Framework for Integration Testing (FIT). I remember reading about this table-driven approach to testing years ago and being intrigued by the concept. These days table- and data-driven testing are picking up steam and this article gives a good introduction.
read it

Using REST with Ajax

Article by Nic Ferrier, 5 pages, 20 minutes.
This short article is mostly about explaining what REST is. It does this with a RSS aggregator use-case and some Python sample code. It's readable even for non-Python'ers and serves as a good introduction to REST. The last bit of the article demonstrates the use of AJAX to use a REST service and to accomplish delete actions that are normally not possible using HTML forms. A good read.
read it

SWT, Swing or AWT: Which is right for you?

Article by Barry Feigenbaum, 12 pages, 30 minutes.
This article puts the components, layouts and events of AWT, Swing and SWT side by side and tries to see parallels and differences. As a quick reference of what's in each toolkit, it can be quite useful. It doesn't seem provide insight however in determining which toolkit is best for a certain situation.
read it

Asynchronous Messaging Made Easy With Spring JMS

Article by Srini Penchikala, 8 pages, 30 minutes.
The article starts with a high level overview of JMS and then shows how to set up and program an application that uses JBoss MQ both directly and using Spring. The JMS introduction was readable. But the Spring vs. no-Spring comparison left me less than impressed. Why is everyone so exited that you can replace about 50 lines of Java code with 7 (!) XML configuration files? Am I just not getting "it"?
read it

PS: why is it that onjava (like many other sites) has a special "printable" view of their articles, but I still get thumbnail images with "click to view full size image" on my printout?

Smooth Moves

Article by Chet Haase, 6 pages, 30 minutes.
This article introduces some approaches that make animations seem smoother on the screen. Although the article focuses on Java (with some JNI thrown in for good measure) the approaches are applicable to any language. That makes this an interesting article, that focuses on a single topic: animation smoothnes.
read it