There’s an interesting interview with the creators of Twig, Objectify-Appengine, and SimpleDS, which are all ORM-like frameworks built for the GAE that facilitate working with the underlying datastore (an abstraction of Bigtable). If you haven’t worked with GAE, you need to know that the exposed hip datastore isn’t relational — it’s schema-less and more like a key/value store; consequently, the JDO features exposed by default tend to leave people a bit distressed (especially when it comes to relationships).

The questions asked and the answers these developers provide are quite helpful in understanding both the pains and the beauties of the Bigtable abstraction. And while these developers are obviously biased towards their respective framework and the details of the interview are focused on the datastore itself, this conversation is a worthwhile read for anyone new or considering using the GAE.

What’s more, the interview provides a link to a GAE forum where both the creators of Twig and Objectify-Appengine square off regarding their respective frameworks implementations. Both frameworks have a distinctly different mechanism for dealing with relationships and while I tend to prefer Twig’s relaxed syntax, Jeff Schnitzer, the creator of Objectify-Appengine makes a cogent case for why dealing directly with GAE keys is safer.

Interestingly enough, a full-stack framework targeting the GAE has yet (to my knowledge) fully emerge — indeed, Grails works on the GAE but this is basically an afterthought (i.e. Grails wasn’t built for the GAE). Moreover, Gaelyk is specifically built for the GAE, but lacks a fully fleshed out ORM implementation, preferring to expose an enhanced version the low-level Entity API. The Play framework, which is somewhat like Grails but without a lot of Groovy, has a GAE module (aka plugin) along with an Objectify-Appengine one. It should be interesting to see how things play out (no pun intended).

As part of the Amazon Web Services family, Amazon’s SimpleDB is a massively scalable and reliable key/value datastore, which is exposed via a web interface and can be accessed using any language you’d like — from Java to Ruby to Perl to C#. In fact, Amazon has recently released a standardized SDK for both the .NET and Java platforms.

Check out IBM DeveloperWorks’ newest article entitled “Cloud storage with Amazon’s SimpleDB, Part 1” — in this article, you’ll see firsthand how to leverage Amazon’s Java SDK to work with SimpleDB. In fact, this is the first of two articles exploring SimpleDB’s unique approach to schemaless data storage, including a demonstration of one of the datastore’s most unusual features: lexicographic searching.

Stay tuned for part 2, where I’ll cover using JPA to work with SimpleDB. Until then, happy reading!

Recently a bogue error popped up with an existing Grails project at a client site. In an effort to abstract core domain logic (i.e. business rules) for a financial application, we decided to leverage Drools; consequently, after some prototyping of rules in a non-Grails project, we decided to start evaluating the Grails Drools plugin.

After installing said plugin, however, Grails failed to start up, instead issuing the error:

java.lang.LinkageError: loader constraint violation: loader (instance of ) previously initiated loading for a different type with name “org/xml/sax/SAXParseException”

followed by an equally nefarious stack trace.

It turns out that differing versions of the xml-apis jar will force this issue; accordingly, if this happens to you, you can fix the situation by simply locating the offending jar file (in this case, it was the Drools plugin which includes a differing version: xml-apis-1.0.b2.jar) and removing it.

Does the prospect of learning a new language daunt you? Does the effort it takes to download a jar file and place it in your classpath overwhelm you? If you answered “yes” (or even “maybe”) to either of these questions, have no fear, baby! The bright folks behind the Gaelyk framework (and not to mention Groovy itself) have lowered the bar as low as it can possibly get for checking out Groovy. The Groovy web console is one of the hippest websites around for seeing firsthand how Groovy works.

Via the web console, you can enter in valid (or invalid for that matter) Groovy code and execute it — all that’s required is a browser. That’s it! Interestingly, the website even allows you to save your scripts and view and comment on other people’s scripts — this provides a great way to learn more about Groovy (think of it as an IDE-blog combination). So what are you waiting for? Check it out today (unless the effort to click a link is just too arduous for you).

NoSQL datastores like Bigtable and CouchDB are becoming more and more hip these days because they solve the problem of scalability on a massive scale. Google, Twitter, Digg and Facebook are just a few of the big names that have adopted NoSQL, and we’re in early days yet. Schemaless datastores, however, are fundamentally different from traditional relational databases. Leveraging them is easier than you might think, especially if you start with a domain model, rather than a relational one.

Check out IBM DeveloperWorks‘ “Schemaless data modeling with Bigtable and Groovy’s Gaelyk” and see for yourself how refreshing schemaless datastore modeling combined with the power of Groovy really is!