Archive for the ‘Reports’ Category

WordCamp Austin, 2010

Thursday, December 9th, 2010

I was able to attend WordCamp Austin this past weekend. It was the first time I’d been to a WordPress conference so I wasn’t exactly sure what to expect. It turned out to be small but very well run conference with several interesting topics.  For this post I am going to review my notes from the conference and highlight the items or topics that I thought were interesting.

WordCamps are typically small 1-day conferences held all over the world focusing on WordPress related topics. For any given weekend there are likely several conferences being held. The big problem is that the camps almost always sellout before the first speaker is even scheduled. So you you either have to be ‘in the know’ about what are the good WordCamps or take your luck of the draw as to whether the camp will be right for you. I was afraid that the conference would be too flufy (i.e. topics like how to build a community, or just using WordPress) instead of technical topics. It turned out that most of the presentations were at least mildly technical with very few covering topics of just how to use WordPress. It seemed to be a direct match with the audience. I’d say that if you feel you’re a programmer you’re probably not going to get the most of out these conferences. Technical concepts are not covered in depth as you would expect from other communities.

With that said, I’m a newb to the WordPress community. I’ve built a few themes for my self (i.e. this blog) and a few others. So take what’s said here with a grain of salt from an outsider’s perspective.


Maven vs Grails

Monday, May 31st, 2010

We have a Grails 1.1 which uses ant + Ivy as its build mechanism. The Ivy configuration has always been wonky, I wasn’t the person who set it up so I’m not exactly sure why it is that way. You would have to run this special ant target, “copy-jars”, which movies the libraries downloaded with Ivy around because some grails command would delete them.  When it came time to upgrade to the latest version, Grails 1.2.2, we wanted to address this problem. One of the new features touted for this release is its maven integration and since we use Maven for several of our other projects we figured this would be a good choice.

Our experiment upgrading to Grails 1.2.2 with Maven integration took a few days to work our way through the errors and gotchas.  In the end we were able to “successfully” upgrade our project – it compiled and passed all the tests. However it didn’t work that well. I’ve included my notes from the upgrade at the end of the post for anyone else who’s trying to do something similar. However in the end Grails + Maven integration sucked for a few reasons.

  • Tests will fail if you do not run a mvn clean in-between. So you can’t run mvn test, fix something then, re-run mvn test again and expect it to work.
  • Running the mvn package command required a larger amount of memory. I had to increase memory available via JAVA_TOOL_OPTIONS=-Xmx512m. This wasn’t required for our old Ivy-based build system nor is it required when using a pure grails build.
  • The build is fragile, minor changes would break in unexpected ways. But the worst part is any errors encountered were always hidden behind java invocation errors masking the real error. This makes debugging the build much harder.
  • In general the integration is very immature, maybe in the future this will improve. But at this state if I can’t recommend this to anyone.

In the end we decided that Maven integration just wasn’t worth it, and we needed something better. The next option we looked at was a pure grails-based build system. This option worked well, there we’re no errors or gotchas like the previous experiment. The best part is that it is able to pull dependencies from Maven without dealing with maven! It’s pretty simple, as described in the manual, just set your dependencies into grails-app/conf/BuildConfig.groovy. That’s it, you’re done. Run “grails compile” and you’re dependencies will be downloaded and the application compiled. This just took a an hour to figure it all out and show it working compared to the days it took getting the Maven integration barely working. In the end I highly recommend using a pure-grails based build, it is a 1000 times better than the traditional Maven integration.

DSpace Functional Tests?

Sunday, April 4th, 2010

The Texas Digital Library has been focusing on testability for our projects. Since DSpace is related too or part of most of our projects we’ve been looking for a way to increase DSpace’s testability. Traditionally this would mean adding unit tests and integration tests. However as DSpace currently stands is hard to break it up into individual components that can be tested in isolation. You’ll quickly find that writing tests for DSpace pull in the entire system, plus databases, and a file system. To address this problem we’ve created a simple framework for adding both integration tests and functional tests which improve the reliability of our projects. I’m interested to see if this is something the greater DSpace community would be interested in?

The goals of our project were to create a mechanism where we could run complete functional tests. Functional tests evaluate the entire system as the end user would use it, so think of it as opening a web browser and evaluating the output – but completely automated. They test everything all together. Ideal it would be better to test each component individual, but this is in practical for DSpace for two reasons 1) DSpace is highly integrated and nearly impossible to separate from the database and file systems, 2) Creating unit test for all of DSpace is very time consuming it is simpler to write a few functional tests that cover a wide set of features over the whole application. It gets you to a point where you can reliably verify the software quicker. If you’re working on unit tests for DSpace please do not let this stand in your way.


Grails HTTP-based test plugins

Wednesday, November 18th, 2009

grails-logoThere are two leading frameworks for doing http-based integration tests within the Grails framework: functional-test and webtest. Both are packaged as grails plugins and accomplish the same task in a similar manner. The main library behind the scene is HtmlUnit. This is a well thought out library for abstracting web conversations, i.e get this url, check that it has a form, click the submit button. It’s basically a headless browser which even supports Javascript. HtmlUnit appears to have taken the mantle from HttpUnit as the premeir library in this small arena. There has only been one release since 2006 for HttpUnit while HtmlUnit has been very active with 11 releases in the same period.

Webtest is the more established project with its first release in 2007. Webtest is provided by Canoo as a free open source plugin to Grails. The tests are run via an Ant script that packages together the test cases and runs through each one.

Functional-test is a relatively new project with its first release in early 2009. Functional test is basically the same as webtests however instead of using the Ant-based scripts everything is based on Junit and implemented in plain old java or groovy.

We’ve chosen to proceed with using the Junit-based plugin for our HTTP integration tests. Our primary reason in deciding to use Junit is that it integrates well with our other unit-based tests which also use Junit instead of using disparate frameworks for the various types of tests. While this plugin may be newer it’s traffic on the mailing lists is growing and substantial.

Microsoft tools for repositories workshop

Thursday, May 28th, 2009

During the Open Repositories 2009 conference I attended the Microsoft’s “Tools for Repositories” workshop.  At the workshop Microsoft was able to get down into the details of their new products and how they are intended to work together. I was impressed by the breadth of work that Microsoft is engaging in to support scholarly publishing use-cases within their tool set. The workshop lasted about 4 hours, longer than most of the other workshops at OR09. The bulk of time was given to the two developers Savas Paratatidas and Pablo Fernicola, along with the team leader Alex Wade.

Microsoft announced their intention to engage with the repository community at last year’s OR08 conference in Southhampton. The OR09 workshop featured the tools that Microsoft has developed in the intervening year starting with new authoring tools in Word, publishing via SWORD, a new peer-reviewed journaling service, and the new .NET based repository. It’s clear to see that Microsoft will have a huge impact on scholarly publishing in the future. We, as the repository community, will need to adjust our services to ensure they work smoothly within the Microsoft ecosystem. After the jump read about the three big features that were presented.