All-You-Can-Gulp Steamin' Hot Hard-Core Java! No-compromise, professional, non-newbie tips, tricks and solutions. You're invited to join!
Through OSNews.com comes news of a new post by Osvaldo Pinali Doederlein. The post brings the welcome news of a new register allocator for the Client version of the HotSpot VM making it into the latest build of Mustang. The new register allocator brings a mighty 58% perfomance boost to this most widespread version of the HotSpot VM.
Dynamically typed language lovers rejoice!
My team-leader Yuval Koren has pointed my way to this article at OnJava.com. Its a nice overview of an extension to JUnit, called DbUnit that allows easy unit testing of code that interacts with a database.
Its finally here, the most exciting release of the JDK since 1.2 is here-- JDK 1.5 tiger roars its beta roar... See a full list of the new features. Download it here. Can't wait to play with it!
James Gosling is back! Gosling has returned to head the development of Java (and tools). Hurrah :)
Some of you already know of my little open-source project. Those that don't, check out DOM ResultSet Wrapper. Basically it is what it sounds like, it efficiently serves as a DOM interface adapter to a JDBC ResultSet. Allowing you to perform XPaths and XSLT on the resulting query.
My co-worker Dovik Nissim, pointed my way to this interview with Kitto Mann on JavaServer Faces posted at TheServerSide.com, especially with regards to migrating from Struts and other frameworks etc.
It seems that IBM has patented the MVC approach as it applies to Java Servlets and JSPs...How silly.
If you want to understand the differences between different web-frameworks for Java, here is a brief summary:
Even better -- Check out Echo, as pointed to me by the Slashdot article: "Building Rich-Client-Like Web Apps With Echo".
Get excited about JSR-127, the JavaServer Faces specification!
I am very impressed with this tiny but useful open source library called Domify. Their site says it best:
Andrew C. Oliver's 'Hacking Log 3.0' has brought to my attention "... this post by Werener Ramaekers which points to this performance report..." -- Interesting, IBM's JDK seems to beat Sun's by a large margin.
Old (May, 2003) yet very interesting blog post by Carlos E. Perez, regarding languages and the thinking style they employ.
Slashdot is reporting that Sun has released a preview (registration req.) of Tiger (Java 1.5) with the suggested new features implemented (generics, type-safe enums, etc.)
There hasn't been a utility function of the day for a long time around here, so this one is extra special.
/**
* Recursively calculate DOM digest,
* disregarding order but taking all content except
* comments into consideration.
* @param node The node to start with
*/
public static long digestDOM(Node node)
{
long digest = 0L;
/**
* First calculate the 'self' digest
*/
if (node instanceof Attr)
{
Attr attr = (Attr) node;
digest = attr.getName().hashCode() + attr.getValue().hashCode();
}
else if (node instanceof Text)
{
Text text = (Text) node;
digest = XMLUtils.getContent(text).hashCode();
}
else if (node instanceof Element)
{
Element element = (Element) node;
digest = element.getTagName().hashCode();
}
/**
* Now calculate the attribute's digest, disregarding order
*/
long attributeDigest = 0L;
NamedNodeMap attributes = node.getAttributes();
if (attributes != null)
{
/**
* Iterate through a node list, examine only elements
*/
int attributeCount = attributes.getLength();
for (int i = 0; i < attributeCount; i++)
{
Node currentNode = attributes.item(i);
attributeDigest += digestDOM(currentNode);
}
}
/**
* Append the attribute digest
*/
digest = (digest * 2 + (attributeDigest));
/**
* Then calculate the children, disregarding ordering
*/
long childrenDigest = 0L;
/**
* Iterate through a node list, examine only elements
*/
NodeList childNodes = node.getChildNodes();
int nodeCount = childNodes.getLength();
for (int i = 0; i < nodeCount; i++)
{
Node currentNode = childNodes.item(i);
childrenDigest += digestDOM(currentNode);
}
/**
* Append the children digest
*/
digest = (digest * 4 + (childrenDigest));
return digest;
}
Slashdot has pointed my attention to an Q&A article on Sun's Java site, regarding the new features expected in JDK 1.5. We've reported on this already, but what the heck.
I've missed an interesting article at Slashdot two days ago. Check it out if you are interested in Sun's plan to provide Visual Basic-like tools for Java.
Finally... :)
This post on Slashdot brings lights to the Object Prevalence concept. Object Prevalence is a simple, smart solution to many problems that have been plaguing modern enterprise projects. Notably those of maintaining persistency and thus transactional integrity with objects and object hierarchies (or graphs), which by definition do not fit RDBMs.
Slashdot is reporting that the good people at the Blackdown project have released their version of the 1.4.1 JDK, for Linux on x86 and SPARC. Congratulations!
