Blogging Roller

I know others have mentioned this before but, where are the Sun weblogs? Microsoft bloggers abound and now blogs are starting to show up on MSDN. Hey Sun, I'll help up Roller, no charge. Just fly me out to JavaONE and we'll discuss this further.

InternetWeek: IBM Preps DB2-Based Integration Software, New Dev Tools. Here are a couple of excerpts:

The new RAD tool is a model-driven development approach for developers unfamiliar with J2EE. One solution provider said the tool potentially could compete with WebSphere Studio, but Schurr said it is aimed at developers without Java expertise and is not specifically intended for skilled J2EE developers, which are the target customers for WebSphere Studio.

Man, that sounds like a tough problem: bringing model-driven architecture to novice J2EE developers without Java experience. Hows does that work? Don't you have to write some code at some point?

The new tools tend to confirm what every Microsoft-centric development shop that uses Rational fears: New and improved products will be Java-centric/exclusive and will first be available for WebSphere, then maybe available for Visual Studio .Net

That's why Microsoft and IBM battled it out for Rational. What is the upgrade path for those customers now? Does Microsoft do UML anymore? I can't seem to find any recent info on UML or MS Visual Modeler on their site.

I really enjoyed Sam Ruby's talk on SOAP at the Triangle JUG meeting tonight. Sam has a special skill for breaking things down to fundamental, easy-to-understand, thought-units, and then putting them back together and showing how the pieces fit together to do interesting things. Using this approach, Sam showed the audience that SOAP does not have to be complex and can be understood using the same view-source approach that we all used to learn HTML. He also took some shots at SOAP's dim-witted half-brother (those were not Sam's words) XML-RPC, but that flew right past the crowd because, frankly, outside of the meta-blogging clique, XML-RPC is just the fork that fizzled.

I'll be honest with you: I don't remember why I used the title "Only 5 Java-based databases?" Too much hefeweizen, maybe? I did not mean to spark controversy, but I like the results. Eric follows up by listing 7 more Java-based databases: QED, tinySQL, Daffodil DB, JDataStore, XL2, JDBM, and Jsdbm.

Eric Foster-Johnson lists the Java databases: McKoi SQL, HSQLSB, Axion, PointBase, Cloudscape, Ozone, Apache Xindice, and eXist.

Well, this was inevitable. (Background: Technorati API released.)

Remember that whole not-taking-on-new-projects thing? Well, somebody else said that, not me. Which, honestly, is obvious to those who read that other RTP blogger.

Open source, Apache-licensed. Share and enjoy.

;-)

After looking at Mark Pilgrim's PyTechnorati and seeing how little Python code is needed to wrap the Technorati API (one file with 171 lines, not including the header comments), I developed a case of language envy. I decided to see what I could do with Java, JDOM, XPath, and a couple of inner classes. Technorati.java is the result (get the project here: technoratj.zip). My wrapper is about the same size as PyTechnorati, but it does not handle HTTP proxies as Mark's does (is there a FancyURLOpener for Java?). Seeing PyTechnorati also inspired me to revisit Jython. Here is how you'd use technoratj from Jython:

Jython 2.1 on java1.4.1_01 (JIT: null)
Type "copyright", "credits" or "license" for more information.
>>> from org.roller.technorati import Technorati
>>> technorati = Technorati("YOUR_KEY")
>>> cosmos = technorati.getLinkCosmos("http://rollerweblogger.org/page/roller")
>>> cosmos.weblog.name
'Blogging Roller'
>>> cosmos.weblog.rssurl
'http://www.rollerweblogger.org/rss/roller'
>>> cosmos.weblog.inboundblogs
33
>>> cosmos.weblog.inboundlinks
44
>>> for blog in cosmos.weblogs:
...     print blog.name
...
BlogAtom
Erik's Weblog
Feelings and Thoughts
Quidnunc
Hacking Log 3.0: America's Blog
...

Note: I had to provide an EntityResolver and my own copy of the technorati.dtd because Technorati results sometimes contain mdash entities and mdash is not in Dave Sifry's DTD. The Technorati API can return malformed XML (I've seen ampersands in name and excerpt elements) and this is a problem for my wrapper. Is the Python MiniDOM more lenient about these issues?

Via The Server-Side: Babeldoc, an open source, flexible, and dynamically reconfigurable XML pipeline processor that can be used for EAI and B2B projects.

Jon Udell on appropriate use of J2EE/EJB. I like the article, but I don't think he makes it clear enough that J2EE != EJB.

I agree that Sun could do a much better job of working with the open source community. One of Java's greatest assets is the wealth of open source Java applications, servers, class libraries, and development tools that exist free for the taking. Sun should be exploiting this advantage, not inflaming open source developers. This is a real shame, because when Sun inflames open source developers those open source developers start spewing FUD like this:

Andy Oliver: Who has the utmost confidence in the financial future of Sun? What if you're using SunOne and Sun becomes the next Enron for instance? You're in deep doggy doo.

That just doesn't make a lick of sense. If you have written your SunONE-based app using the standard J2EE APIs such as Servlets, EJB, JMS, etc., as any server-side Java developer does, all you have to do is to tweak a couple of deployment files and move your app over to JBoss, Websphere, or Weblogic, or some other J2EE server.

J2EE developers shouldn't "walk through walls" into container-internals as the JBoss guys advocate, they should stick to the standard J2EE APIs. I'm not saying that all of the JCP foisted standards are good things or that the JCP is a perfect process. They aren't and it isn't, but you only have to use the standards that make sense to you. The standards allow the Java app/message/portal server vendors, both closed and open source alike to compete to provide the best implementations. I don't want my Java code to be locked into any one Java server, not even an open source one.

Michael Yuan points out that a couple of books on Eclipse are about to hit the racks. Very cool. Yet another sign that <a href= "http://www.rollerweblogger.org/page/roller/20021107#the_eclipse_dominates_scenario">Eclipse will dominate. It's not just an IDE, it's the universal tool platform.

In the style of Steal these icons / Steal these buttons:

Stuart Halloway also has some words on Ted Neward's persistence posts.

I've been thinking about Java persistence and O/R mapping a lot over the last year or two, so I was excited to see Ted Neward's latest items from his upcoming book Effective Enterprise Java. According to Ted, there are four approaches to Java persistence: object-first, relational-first, procedural-first, and hierarchical-first. I really like the way Ted introduces the approaches, exploring the history and the developer motivations behind each, but I do think there is room for improvement. Here are the short-comings from my point-of-view.

The approaches need more differentiation. Apart from the hierarchical-first approach, which I will ignore because it involves using XML rather than a relational database, the approaches, in the end, are very similar. When you get right down to it, they all involve building an encapsulation layer that stores and retrieves objects. The approaches differ only in the extent to which either the underlying database schema is exposed or the overarching object model is preserved.

More guidance is needed on choosing an approach. How do you know when to use each of these different approaches? For example, if you have an existing database schema, possibly one that is imposed upon you by your database administrator, does that mean you have to use the relational-first approach and use JDBC, RowSets, or SQLJ as Ted shows? I would say no, but Ted does not really make this clear. Conversely, if you start with a nice object model, does that mean you have to use the object-first approach and use O/R mapping, JDO, or EJB? I think the answer is no here too, but Ted does not explain this. How do you choose an approach and how do you know when circumstances have imposed an approach on you?

Characterizing the approaches as procedural-first, relational-first, and object-first is useful from the story-telling historical perspective, but I think it might be lacking for the practical how-to perspective. For an alternative, take a look at the way the Hibernate guys break it down, cookbook style. The Hibernate site describes four approaches to O/R mapping: top-down, bottom-up, middle-out, and meet-in-the-middle. These terms/approaches are useful even if you are not using Hibernate. Here are my summaries of the four approaches (from an earlier post of mine):

• Top-down: Starting with an existing JavaBeans object model, develop a mapping that maps those objects to tables in your database, generate DDL to create your database, and then use a persistance API to persist those objects to that database.
• Bottom-up: Starting with an existing database schema, describe your database schema using using XML or some other meta-data representation, generate your JavaBeans object model, optionally add business logic to those objects, and use a persistence API to store and retrieve your objects.
• Middle-out: Starting with a meta-data description of your object model, generate your JavaBeans object model, generate DDL to create your database, and use a persistence API to store and retrieve your objects.
• Meet-in-the-middle: Starting with an existing database schema and an existing JavaBeans object model, develop a mapping to map between the two, and use a persistence API to store and retrieve your objects.

I was kind of hoping that I would read Ted's new chapters and realize "damn, I'm doing it all wrong" but that didn't happen and I guess that is not all bad. The chapters and the talk I attended this week by Ken Hygh both confirmed that the Persistence Manager/DAO encapsulation layer approach is a good approach to take in a database-driven web application. All of that being said, I think Ted's book is going to be a great resource for Java developers and I'm looking forward to buying a copy.

Great stuff on Ted Neward's weblog today on object first, relational first, procedural first, and hierarchical first approaches to persistence - all from his upcoming book Effective Enterprise Java. I'm printing them out now and cancelling all appointments this morning ;-)

But are they going to notice that tiny glimmer in their rear-view mirror? Mike describes the Webwork-2 feature set.

I went to the RTP Websphere Users Group meeting last night to see IBM consultant Ken Hygh talk about best practices for Java web application development. Ken works in the IBM Websphere Enablement Group and he is a co-author of Performance Analysis for Java Websites. His slides were titled Websphere Best Practices, but the talk was generic J2EE goodness that could be applied to any Java app server. The slides should be available on the RTP-WUG web site at some point.

Ken gave us the same talk that he gives to Websphere app server customers who are about to begin development on web application projects. I'm sure this was familiar ground for most of the RTP-WUG members as most WUG members are probably Java developers, but it was very interesting to hear how Ken lays it out for IBM customers. Ken really knows how to explain the issues well and he is about as down-to-earth practical and pragmatic as you can get. I was a little surprised to hear him down-play EJB and Web Services as much as he did. Attending a talk in the heart of Websphere-land I expected a little hype, but Ken is not about hype. He did not rule these technologies out, but he pointed out that they are often not the right choices. If Ken was guilty of hyping anything, it was XP. He really pushed unit testing hard and talked about JUnit and JUnit related testing tools such as HTTPUnit, Cactus, etc. He also recommended that everybody run right out and purchase a copy of Martin Fowler's Refactoring.

Ken walked through the development of an example web application, showing how to roll your own controller Servlet and simple Model 2 architecture. In the end, he had something that looked like Struts or Webwork. For the back-end, he recommended using the Data Access Object (DAO) pattern - even if you are using EJB. He said that he always recommends using DAO because it enforces modularity which makes testing and refactoring easier and because you never know when you might need to switch persistence technologies (as we recently did in Roller).

All in all, excellent talk. IBM customers are getting great advice from Ken.

eWeek published an interesting series of articles today on the ongoing integration of Rational Software Corp. into IBM. Rational Digs Up Gems describes how Rational's Grady Booch is working to identify IBM Research projects to be productized, such as hyperdimensional programming (AOP). Rational's Devlin Eyes Tight IBM Ties discusses bringing Model Driven Architecture to the Visual Basic-type programmers of the world. Rational, IBM Model a New World analyzes the merger's impact on the enterprise software and dev-tools markets.

The ServerSide is reporting that the JSP 2.0 and Servlet 2.4 Proposed Final Draft 3 is available available.

Download the JSP 2.0 PFD 3 spec:
http://jcp.org/aboutJava/communityprocess/first/jsr152/index3.html

Download the Servlet 2.4 PFD 3 spec:
http://jcp.org/aboutJava/communityprocess/first/jsr154/index3.html

Don Park points out that you can now download "SWT libraries and source for standalone SWT application development." See the Eclipse download page and scroll all the way down to the bottom. There are also a bunch of example snippets.

Don Park: Eclispe team released binary and source packages for building standalone SWT applications.  Good stuff.  SWT API is a little akward compared to Swing, but not too bad considering the benefit: responsive GUI.  Downloadable packages for most of the key platforms are at bottom of the usual download page. Enjoy.

that some subset of Wrox Press has been purchased by Wiley. I have absolutely no idea what this means for Professional JSP 2.0.