Introduction to nonblocking algorithms

Article by Brian Goetz, 6 pages, 40 minutes.
A very interesting article about so-called nonblocking algorithms that are possible in Java 5. If you know about the difference between pessimistic and optimistic locking, then using the synchronized keyword is similar to pessimistic locking while nonblocking is similar to optimistic locking. I found the article a very good read and spent a long trying trying to understand the examples. Nonblocking can be immensely complex, but it will in most cases result in a more efficient implementation.
read it

Using Java platform management beans

Article on DeveloperWorks, 16 pages, 45 mins.
This article discusses what's behind the great JConsole application that was introduced in Java 5.0. They're called MXBeans and they're an extension to the JMX technology that has been available for some time. The article gives a nice introduction to MXBeans and shows how to create both local and remote clients for them.
read it

LDAP Programming in Java Made Simple

Article by Ulrik Sandberg and Mattias Arthursson , 9 pages, 30 minutes.
This article introduces the LdapTemplate framework, which attempts to make LDAP programming easier in a way similar to how the Spring JdbcTemplate makes JDBC programming easier. From what I understand from the article it is indeed less work to get LDAP working with the framework and most of the templating code is gone. It is still quite verbose however, so from my view further improvements could be made to the framework.
read it

From DHTML to DOM scripting - an example of how to replace outdated JavaScript techniques

Document by Christian Heilmann, 40 pages, 90 minutes.
This is quite a long read, but gives a good introduction to what it takes to move from old-style DHTML scripting to the now more favored non-obtrusive DOM scripting. It's an interesting read and for once this article seems to match the pace I like. My only complaint is that my mind started to wander in the latter pages. This is most likely caused by the fact that the example used for the demonstration is a bit too big.
read it

Mastering Ajax, Part 5: Manipulate the DOM

Article by Brett McLaughlin, 14 pages, 20 minutes.
This the second to last article in the series and the author is still only explaining very basic DOM manipulation. The reason this takes so many articles and pages is in the fact that the text is sprinkled with code samples, repeats of fragments of those code samples and screenshots. Although this results in a very readable article, I can't help bub feel that the author is trying to fill more pages than strictly needed.

Developing the Server-side Layer of an Email Application in AJAX

Article by Alejandro Gervasio, 4 pages, 15 minutes.
In this last part of the series on creating an AJAX based mail reader, the author introduces the server-side PHP script. There really isn't much to it, so most of the pages is filled with the code of the previous articles. It's not much code, but that shows how easy it is to get an advanced web application started.
read it

Scripting for the Java Platform

Article by Thomas Kunneth, 5 pages, 20 minutes.
An interesting introduction to the new scripting engine support that will be in Java 6. The support seems pretty simple, but should be adequate for plugging in most scripting engines. It still looks like they took most ideas from Rhino, but there's nothing wrong with that.
read it

Design enterprise applications with the EJB 3.0 Java Persistence API

Article by Borys Burnayev, 6 pages, 30 minutes.
I'll easily admit to never being a fan of EJBs. For me they're just too much work for what they accomplish in the real world. But from what I'd read on EJB3, it seems to have taken a big step forward. But somehow, this article doesn't prove that to me. It seems full of references about tiers, separations of concern and decoupling, without worrying about the domain. From reading this article, EJB3 still doesn't seem like it's my cup of tea. Or coffee for that matter.
read it

Take AJAX to your Email Inbox: Developing the Client-side Application Layer

Article by Alejandro Gervasio, 7 pages, 20 minutes.
The second part of this article is as readable as the first. It shows how easy it is to create a simple AJAX mail reader. I must admit that I sometimes do get tired of the author's intro and outro lines. I guess that these work well as a transition between screen pages. But on paper you really notice that there's too many of these lines when compared to the actual content. But it doesn't hurt readability and the article is still an interesting read.
read it

Exception-Handling Antipatterns

Article by Tim McCune, 5 pages, 20 minutes.
This article is about bad exception handling practices we've all seen and maybe even been guilty of. It's mostly a listing of such patterns as "swallow the exception without logging", "log and rethrow" and "throws Exception". The naming of these patterns is nice and I'm sure a few of then will even stick. What I missed was more clarification about why certain patterns are bad. There is a short explanation, but some deeper material would have been useful.

Testing legacy code

Article by Elliotte Rusty Harold, 7 pages, 30 minutes.
An interesting article on how to start unit testing apps that don't have any unit tests yet. The article clearly describes how testing this type of "legacy code" is different from the more commonly documented test driven development.
read it

Crossing borders: Domain-specific languages in Active Record and Java programming

Article by Bruce Tate, 8 pages, 20 minutes.
This series is one of my favorites at the moment: wel written articles with an interesting and clear topic. Combine that with just the right reading length for my daily commute and you'll understand why I like it. This episode is mostly about using Ruby to create domain specific languages. It answered some of the questions I had when I first read about Rails like "how do take make is seem like an entirely different language, where it's implemented as a library". I now know, and so will you once you read this article.
read it

Developing a Web-based POP 3 Client

Article by Alejandro Gervasio, 4 pages, 15 minutes.
This is the first article in a series on creating an AJAX style web-based mail reader. This first edition introduces the target application, builds the CSS and HTML and names the javascript functions. This results in a very readable article, albeit somewhat light on content. I'm looking forward to the next article in the series.
read it

Create VoiceXML pages within a Java Web developer framework, Part 2: Expanding Java-driven VoiceXML applications

Article by Brett McLaughlin, 12 pages, 30 minutes.
This article has little to do with VoiceXML. It's better to say that it uses a VoiceXML application to introduce the reader to modularizing code. It is a readable piece of text, but not in the level nor on the subject I was expecting.
read it

Introducing JAXX: A New Way to Swing

Article by Ethan Nicholas, 6 pages, 20 minutes.
I'm not a big fan of frameworks that wrap GUI toolkits in an XML syntax. Sure, it saves you from having to start up your compiler to make a GUI change. But it also saves you from compile time checks on your GUI changes. JAXX looks like a well though out XML GUI framework, but I'll wait for IDE support before trying it.
read it

Secrets of lightweight development success, Part 8: Seaside

Article by Bruce Tate, 6 pages, 20 minutes.
I didn't read the other articles in this series, since they seemed too high level for my taste (since I'm also reading Tate's "Crossing Borders" series). But a quick intro into Seaside seemed interesting to me, since hopefully it'd help me understand the value of continuations. Well... the article did a great job in spurring my interest in Seaside, since it's now installed on my home machine waiting for test runs during the weekend. But aside from that, I still haven't learned what the value of continuations is. Hopefully the practice will make it clear.
read it

Testing Java in an Object-Oriented Way

Article by Soumen Chaterjee, 8 pages, 45 minutes.
I printed this article expecting to get practicle advice on how to make my unit testing more object oriented. But it read more like the abstract of a thesis than as an introductory article. I must admit that I had problems keeping my mind focussed at the text and kept wondering what the practicle use of the presented material was.
read it

In pursuit of code quality: Monitoring cyclomatic complexity

Article by Andrew Glover, 7 pages, 30 minutes.
In this second article in the series, Glover introduces cyclomatic complexity as an indicator of the amount of testing that a code needs. In itself this is a nice idea. But it needs to be backed up by tools that clearly tell you the number of paths that are tested. Most tools emulate this using a "branch count", but from my limited understanding this is not the same thing. Anyway, the article is a nice introduction to cyclomatic complexity.
read it

Copying Arrays Fast

Newsletter by Heinz Kabuts, 8 pages, 20 minutes.
In this edition the author does some performance comparisons between using clone() and using new-array-and-arraycopy. The newsletter is quite heavy on code and light on insights. Combine that with one too many plugs for courses given by the author and can't help but I hope the next edition is better.
read it

Comparing XML Documents with Oracle's XDK 10g for Java

Article by by Deepak Vohra, 4 pages, 15 minutes.
This is a very simple introduction to the topic of comparing XML documents using Oracle's XDK. The samples are readable but the code and explanation too verbose. The article could have been half the size. That would have left the other two pages for all the listings, that we're now pointed to as "click here for listing 2". Something that would look rather silly given that I'd printed the article out.
read it