Most development teams working on complex projects in this day and age are going to employ some combination of generally accepted best practices in software engineering to ensure consistency in build quality, automate complex build processes, and automate unit and functional testing to continually ensure quality as development progresses.  Such practices include:

• Automated unit, integration, and functional testing (faciliated by tools such as JUnit and Selenium)
• Build automation (using tools like Ant and Maven)
• Continuous build integration (to ensure build quality and identify conflicts early)
• Code coverage analysis (measuring how much of your application you’ve tested)
• Static code analysis (find common coding errors with tools such as FindBugs)

It is reasonable to assume that a complex Android application would benefit from these practices, especially with a larger development team.

Android provides most of the necessary integration points and tools to implement many of the best practices mentioned above, and allows for automating the several steps required to build an Android application.  However, despite this, there are some key lessons to learn that to learn that separate an Android build process from other Java-based projects.

Java is not Java

First off, let’s get one thing straight.  The Java classes that one writes to implement an Android application compile to the Dalvik VM, not the Java Virtual Machine provided by Sun (now Oracle).  The engineers building the Android platform chose a separate virtual machine implementation for a variety of reasons, but it is arguably the need to slim down and tailor a VM for use on a mobile device, which has very hard limitations on processor resources and memory, that lead to this decision.

Because of the separate VM implementation, the full set of standard Java SE classes is not available.  The Android team has provided a workable subset of the Java SE API with a few notable additions to assist in such things as managing HTTP communication, parsing JSON, and parsing XML.  This distinction leads to one very important point:

Not all Java targeted for the Sun JVM will run in Android.

This is important to note when planning to use 3rd party libraries in an Android application that were not targeted for Android.  While many 3rd party JARs can be included in Android projects, many cannot.  Clearly if the dependencies can be met with the pared down API, the JAR will not work.

Running It

The APIs provided by Android’s augmented subset of the Java SE API are exposed to developer projects (primarily in Eclipse) via the android.jar file.  This JAR provides the interfaces for the Android API, but none of the implementation code.

Why the limitation?

Classes compiled for the Dalvik VM aren’t executed in their .class file bytecode form, but rather must be converted to Dalvik’s Executable format, or dex.  According to this Android page, dex is optimized for a smaller memory footprint, and also to allow multiple VMs to execute efficiently.

What this means for the average developer is that you cannot go to your trusty Eclipse Run As > JUnit Test menu item and fire off unit tests.  All Java code targeted for Android must run within the Android execution environment, compiled as .dex files, in the Dalvik VM.  Without the implementation classes for android.jar being in standard JAR format (they’re buried in .dex files in Android), the best options for running your code during development is either:

• Plugging in your favorite Android phone via USB debugging or
• Running your code in an Android emulator

While there are ways to run the Dalvik VM on the desktop, those methods are not yet integrated into the Android standard toolchain.

Emulating Success

The Android SDK provides a rich set of tools for creating, launching, customizing, and debugging emulated Android devices, known as Android Virtual Devices (AVDs).  These emulator instances can model different hardware configurations as well as different target Android OS versions, which is useful for testing an application across the many deployed versions of Android that exist on the many Android devices that exist today.

The Android emulator, based on QEMU, provides emulated versions of many of the hardware features commonly found on Android devices (from the Android Developer Center):

• An ARMv5 CPU and the corresponding memory-management unit (MMU)
• A 16-bit LCD display
• One or more keyboards (a Qwerty-based keyboard and associated Dpad/Phone buttons)
• A sound chip with output and input capabilities
• Flash memory partitions (emulated through disk image files on the development machine)
• A GSM modem, including a simulated SIM Card

The slowness is evident elsewhere.  It is a generally held belief that the emulator does not adequately support video playback, and my experience in building custom video players in Android supports this.  Playback often does not come close to the video frame rate, therefore video playback testing is best handled on a physical device via USB debugging.  Given that it is difficult to automate testing around video playback, this is less of a concern, however it is important to note when setting up a QA team for playback testing.  Real devices should be available for QA as the emulator will likely not suffice.

Up Next

This is just a taste of some of the relevant architectural details of the Android platform that affect build automation.  In the next installment, I’ll dig deeper into build configuration, automating tests and managing the emulator from Ant.

The main reason why I cared is not because I’m a diehard soccer fan, but because we just expected to be able to watch the games. Live. Wherever we were at that moment. In good quality. With good audio (vuvuzelas notwithstanding). And a host of other features to keep us interested. And we did. Online. Over the phone. It’s amazing how quickly we’ve come to expect that we can consume a live event of the magnitude of the World Cup online. I mean – that is cool.

But does it matter to your business? How does this relate at all? In some ways, of course, it doesn’t. Sports have been a driver for many of the mega-events in recent online video history, primarily due to the nature of the events themselves. But outside of the media world – what does this mean for your online video strategy:

Go global. If your company has a global presence this event certainly confirmed what you may already know….that audiences around the globe have the capability and desire to consume online video. But don’t just throw anything out there. Make sure you provide the proper translations and content to fit the needs of the region you are targeting.

Interactivity = engagement. The majority of the implementations had a high level of interactive features woven into the experience. The ESPN3 player allowed the ability to switch between games, languages, get stats, chat with others. It’s not just about providing the moving pictures. The ability to customize players with interactive details and hot spots is growing quickly and provides many businesses with the ability to create more engagement and calls to action towards your ultimate business goal.

Be where your users are. The success of online video with an event like the World Cup hinged directly on providing fans the ability to get their fix wherever they were – at work, on the road, at home. This means thinking not just about video on your website but also how to syndicate your assets externally and how you might leverage mobile platforms to deliver your message to your users.

1. Generating the app

> rails new sprinter --database=mysql

> cd sprinter/

> rm public/index.html

> rm public/images/rails.png

> git init

> git add .

> git commit -m "Initial creation of the Sprinter app"

> mate .

As you can see, I didn’t even think about a .gitignore file.  Since the Rails community has fully embraced git as the source control system of choice, Rails 3 provides a default .gitignore file for you.

Side note: if you haven’t gotten up to speed on using git yet, you should.  GitHub has a nice crash course.

2. Configuring the app

The first place to start is the Gemfile.  This is the new place to declare all your gem dependencies (it used to be in “config/environment.rb”, which, by the way,  is now “config/application.rb”).    Once you open it up, you’ll see it’s pretty much the same as how you declared gems in environment.rb, except you wont be typing “config” over and over.

Here’s the Gemfile I use for this project:

source 'http://rubygems.org'

gem 'rails', '3.0.0.beta4'

gem 'mysql'

gem 'mongrel'

group :test do

  gem "shoulda"

end

Normally, I would include a few more gems here (specifically: HAML, friendly_id, authlogic, and paperclip), but this is just a quick starter app, so I omitted them for now.  I included “shoulda” in the test group simply to illustrate how to include gems purely for a test environment.  Plus, you should be using shoulda.

3. Bundler

Now that the gems are defined, I can use Rails 3’s new bundler to make sure all required gems are installed.  This is how you can guarantee every system is using the right gems for the project.  It’s similar to requiring gems in environment.rb, but bundler allows you to package the gems in the deliverable.  Also, bundler is far smarter than the previous system.  Previously, gem dependencies were read linearly out of config/environment.rb which had the propensity to cause issues.

For example, consider the following scenario.

Since you have version “1.2.4″ installed, the “>= 1.2.3″ requirement would use the version “1.2.4″ installed on your system (because it is the latest, greatest version).  However, when it later reads that version “= 1.2.3″ is required, it fails since it already loaded version “1.2.4″.   It’s an edge case, but Bundler will prevent this from happening.

Anyway, I got a bit off subject there.  The next step is to use bundler to make sure all those gems are installed.

> sudo bundle install

You’ll see it fetch the correct versions of all the gems defined in the Gemfile.

4. Using jQuery

One of the best features of Rails 3 is that all the javascript is unobtrusive, thus being fairly framework-agnostic.  Since I’m a big fan of jQuery, and less so of Prototype, let’s swap in jQuery by doing the following:

Believe it or not, you now have everything you need to use jQuery.  To make things more seamless though, you should create file “config/initializers/jquery.rb”, and paste the following inside:

module ActionView::Helpers::AssetTagHelper

  remove_const :JAVASCRIPT_DEFAULT_SOURCES

  JAVASCRIPT_DEFAULT_SOURCES = %w(

    http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js 

    rails.js

  )

  reset_javascript_include_default

end

This will include the Google CDN hosted jQuery (saving you some bandwidth and speeding up your pages) when you use the “:defaults” javascript include tag.

Side note: Because all the javascript is unobtrusive,  some of those fun helpers like “link_to_function” no longer exist.  However, “link_to_remote” still exists, but you call it as a regular “link_to” with “:remote => true” as an option.

It’s one thing for the framework to try and enforce unobtrusive javascript, but we should also set up our code to enforce it as well.    At this point, I usually create the following helper methods in “app/helpers/application_helper.rb”:

def stylesheet(*args)
  content_for(:stylesheets) { stylesheet_link_tag(*args) }
end
def javascript(*args)
  content_for(:javascripts) { javascript_include_tag(*args) }
end

These functions help me group all the stylesheet and javascript includes together.  With that, I then update the application layout file like so:

<!DOCTYPE html>

<html>

<head>

  <title>Sprinter</title>

  <% stylesheet :all %>

  <% javascript :defaults %>

  <%= yield(:stylesheets) %>

  <%= csrf_meta_tag %>

</head>

<body>

  <%= yield %>

  <%= yield(:javascripts) %>

</body>

</html>

Another side note:  Rails 3 spits out pure HTML5.

Moving the javascript include tags to the bottom does several things:

5. Rails 3 Routes

Now that all the required gems are installed, we’re ready to roll.  I like to start by creating a simple “Welcome” controller for the app.  One thing to note is that all the Rails 2 “script/” commands are now part of the “rails” command.

> rails generate controller Welcome index

Followed by an update to the “config/routes.rb” file to set the “welcome” controller as the root of the project.

root :to => "welcome#index"

In Rails 2, you would have declared the same thing with something like:

map.root :controller => 'welcome', :action => 'index'

Rails 3 routes are built to be  more extendable and require a lot less typing (notice the “controller#action” naming convention).  Let’s make sure everything’s working:

> rake db:create

> rails server

The site should now be visible at “http://localhost:3000″.  When you’re satisfied, stop the server with Ctrl+C.

6. Scaffolding

So far, I think this is a great starting point for quickly getting up and running on a new Rails 3 project.  However,it really doesn’t do anything yet.    So, let’s make it into a simple blog.

> rails generate scaffold Post title:string body:text published:boolean

This looks pretty standard, but a few key things have changed for Rails 3.  One, the scaffold generates a “_form.html.erb” partial instead of repeating the form in the “new” and “edit” views, making things much DRYer.

This also sets up the routes like so:

resources :posts

Just to close the discussion on routes, consider if posts belonged to a user and also featured a “comment” action.  We could set the routes up like so:

resources :users do

  resources :posts do

    member do

      get :comment

    end

  end

end

Pretty clean, isn’t it?

Anyway, back to the app.  Let’s see how things are working.  Run:

> rake db:migrate

Starting the server and checking out “/posts” gives you the standard Rails scaffolding page.  All is good here.

7. And finally, Arel

Now I can introduce my favorite part of Rails 3: Arel.

In a nutshell, Arel is an ORM-agnostic framework based on Relational Algebra (what the SQL language is based on).  I’m sure I’ll be blogging about it in far more detail shortly, but it essentially allows you to make all your Rails queries chainable (much like “named_scope” in Rails 2 – in fact, it was written by the same guy).

Open up app/controllers/posts_controller.rb and we’ll give it a shot.

In the “index” action, you can see that it grabs the blog posts in the standard Rails way:

@posts = Post.all

Normally, to only show the latest 25 published posts, we’d change this to be:

@posts = Post.all(:conditions => { :published => true }, :limit => 25, : order => "posts.created_at DESC")

With Arel, we can make this awesome by writing it as:

@posts = Post.where(:published => true).order("posts.created_at DESC").limit(25)

You should notice that, apart from a new naming convention, there is one major difference:  in Rails 3, we don’t call “.all”.  This is by choice.  We could call .all on that line and everything would work as expected (and in some cases, you want to call it).  However, calling “.all” forces the query to be run immediately.  But, thanks to Arel, if we leave it off, the query is only run when we actually use the data.

So, our query is only run when the view hits:

<% @posts.each do |post| %>

...

<% end %>

I don’t know about you, but I think that’s awesome.  It’s cleaner, and far more extendable.  For example, say we wanted to have a toggle switch for published and unpublished posts.  Our “index” action could be something like:

@posts = Post.order("posts.created_at DESC").limit(25)

if(params[:draft])  

  @posts = @posts.where(:published => false)

else  

  @posts = @posts.where(:published => true)

end

Gorgeous, isn’t it?

Well, that’s it for now.  I hope this post helps you hit the ground running with Rails 3.  I’ll be sure to post more about Rails 3 as I discover it, but so far, I’m extremely excited about it.  I hope you feel the same way.  Leave your thoughts/gripes in the comments.

The key turned out to be the discovery of the DefaultGrailsDomainClass . This class performs a series of introspections on your domain objects, and allows you to programmatically access quite a bit of information on them. For example, suppose we had the following domain object:

class Pizza{

String name

BigDecimal diameter

List toppings

hasMany = [toppings:Topping]

}

Class ‘Pizza’ contains a name / description, diameter, and a many-to-many relationship with the ‘Topping’ class (although not defined here). Nice and simple… now, the good stuff.

By passing a Domain Object class to DefaultGrailsDomainClass, we can access a good deal of info about that Domain Object. Among other things there are methods to access a Map of the constraints, determine whether or not a property is a relation (1:1,1:m,m:m), and access the properties directly by obtaining a set of GrailsDomainClassProperties . Of particular use to me is the DefaultGrailsDomainClass.getPersistantProperties() method, which returns a GrailsDomainClassProperty List of all the properties that are persisted to the database. That’s pretty excellent.

To illustrate this, let’s get the persistent properties for a Pizza:

pizzaProperties now contains a list of ‘DefaultGrailsDomainClassProperty’ objects. If we iterate through them, we can see the following information:

Think of the possibilities of what can be accomplished by programmatically accessing the properties on your domain object! However, I am not exceedingly clever:

else{//do something clever!}

}

}

The exportClassSingle method above accepts the ConfigObject which will be populated with the domain object’s data, the name of the class, and an instance of the domain object. It is relatively simple: it takes the class, loads its persistent properties, loops through through them and if the property is not an association, it is added to the config object.  By repeatedly calling the method for each of our Domain objects, we build up the ConfigObject which contains class and instance data. The preExportClean() method looks for and escapes any usage of ‘$’, which can cause some odd behavior if not escaped. We ignore associations here because in the real app, everything is connected to one root object; if there were associations among the child objects that we wished to capture then the above method would be quite different.

Given the following DSL:

pizza{

pizza_0{

name="Small"

diameter="8.0"

}

pizza_1{

name="Medium"

diameter="14.5"

}

pizza_2{

name="Large"

diameter="21.0"

}

}

and assuming it’s saved in a String called ‘pizzaDSL’, we can import this data into our system using the following steps:

ConfigObject config = new ConfigSlurper().parse( pizzaDSL )

The ConfigObject config now contains a map of ConfigObjects. Using the key of ‘pizza’ returns a map of 3 more ConfigObjects.

2. Construct objects using the configObject.

config["pizza"].each{key,map->

Pizza p = new Pizza()

p.properties = map

//set toppings

p.save()

}

3. Celebrate

Well, that’s it. I hope this helps explain the usage of the Default Domain Class and that you all find a usage for it.

In what could be one of this summer’s only worthy entertainment highlights (Inception aside), it looks as if Boss Google may be ordering up a hit on the family Zuckerberg. Under the working title “Google Me” (ala “Analyze This”), the story also features Facebook’s agrarian darling Zynga, who has left the family farm for Google’s greener pastures. The search goliath seems to be launching another salvo (Orkut? Wave? Buzz?) on the social space. But will anyone watch?

Wait a minute – what about SNF? Only yesterday the headlines, the talk shows, and the naysayers were all passing the can around to raise awareness for that digital menace, Social Networking Fatigue. Apparently that’s all behind us now: “You can pry my user profile from my cold, dead hands,” says Gen Y. According to young lasses everywhere, “I’ll take mine before coffee thank you.”

The obvious questions beg, are folks willing to set up yet another profile on yet another social networking site? Or do the gazillions of existing Gmail accounts make the medicine go down? Google’s ubiquitous in-roads into all tasks digital certainly may help tip the scales. On the other hand, who doesn’t have a Facebook profile (beyond that “whaskely“ gang of 35,000)? Naturally the open sorcerers and early adopters are sure to line up and spread the Holy Google Invite, and perhaps that’ll be enough to get the momentum going. Then again, Wave anyone?

Interestingly, at the same time the rumors swirl about Googlebook, Microsoft announces Facebook integration into it’s Outlook mothership. But can a plug-in really even those odds? Will Outlookers actively seek out and install an email client plug-in?

And still the plot thickens! We learned today that a New York man has teamed up with Johnny Law to claim his piece of the Zuckerberg empire. Could he be a Google mole?

Stay tuned. In the meantime, grab your popcorn bins and head over to see the only film that promises to be more boring than “The Black Dahlia”, “The Social Network” (perhaps the bigger question is how can this possibly be from the same director as “Fight Club”?)

We’ve been here before. Online video gets portrayed as a new environment with new rules and new things to consider and sure, there’s some different dimensions to creating and deploying video as opposed to straight text/images, but at the end of the day, it’s still content. It’s new and still very much in that me-too stage, but companies are going to have to figure out how it serves their business or they’ll stop doing it. Not much different than the web for that matter. And similar rules apply to creating an online video strategy that would apply to creating a web site strategy, or any other business strategy. Understand your audience and their needs, match those needs to your business objectives and create compelling media and features that meet those needs and objectives. Oh, and don’t forget to create goals and how you’re going to measure them. Which brings me to the next point.

Measuring video is hard. Actually, measuring video use is easy at a basic level. What’s hard is measuring how your video is being used outside of your “control” and what’s even harder is figuring out whether your video is actually serving the business need you had in mind. No one has the silver bullet for this one but I think it’s a combination of planning (per my previous point) and doing the hard work to integrate your video statistics into your overall web measurement approach. Out of the box the video stats from OVPs are islands unto themselves, building those bridges will pay off in the long run.

HTML is back in vogue. The most popular session I attended was hands down the discussion on HTML5 and video. The discussion itself wasn’t particularly enlightening, but it is apparent from the interest of that audience combined with the buzz all over the internet (thanks Apple and Adobe!) has elevated this topic to near cult status. Once we parse through the hype, however, HTML5 does have the makings for a quantum shift in the development and deployment of media assets on the Web. The ability to replicate much of the interactive functionality inherent in frameworks such as Flash in a simpler, more open format such as HTML will have ramifications for years to come – and not just for Adobe. We’re going to dive into this topic in much more detail in coming posts – it’s too important to just riff on in a simple blog post such as this one.

These posts are the best posts I’ve seen yet on the subject, with real, nitty-gritty details about implementing I-AP.

Executive summary: 1 FTE for 1 month to convert an existing, fully operational app to one enabled for in-app purchases.

While the full list of iPhone OS 4.0 features is yet to be publicly disclosed, there are a number of iPad OS features (referred to by Apple as “iPhone OS 3.2″) that could conceivably show up on our iPhones in the future.  Some examples:

• The ability to email an app-specific file to a friend, and have them open it up on their own device in the proper app (Document Support)
• The ability for an app to generate a PDF with text and images (PDF Generation)
• The ability to easily move app-specific files back and forth from your mobile device to your laptop (File Sharing Support)

None of these features is earth-shattering in its own right; certainly it would be possible to accomplish any or all of these behaviors today by using the iPhone app as a “thin client”, and pushing the hard work like generating PDFs, sharing documents, and managing files up to a web app server.

What is significant about having these capabilities on the device itself is how much easier it will be for developers to build apps that enable these behaviors, and for consumers to adopt them:

• App Developers won’t have to lease a server and pay bandwidth fees to enable these types of apps
• App Developers won’t have to leave the comfort of their chosen programming language and tools (XCode / Cocoa)
• Consumers will be able to leverage familiar collaboration and file management paradigms like email, attachments, and copying files to and from the desktop

Most apps today are focused around consumption – consuming content, data or interactive entertainment for a short period of time, and then closing the app.  Features like those above could enable creation and collaboration behaviors – where the activity spent in the app yields some tangible artifact, which can be exported, transformed, or shared with other app users.

The possibilities exposed for consumer apps are intriguing, but the biggest impact may be felt in the enterprise arena – where creation and collaboration are more fundamental to day-to-day operations.  This is a point that others have pondered with the iPad, where the large touchscreen presumably makes it a better fit for content creation.

Definitely will be an interesting area to watch.  Please comment if you’ve heard of particularly clever mobile collaboration apps in the enterprise.

It is beyond value what a content publisher, advertiser, syndicator or whoever else you can think of can glean from metrics that track the behavior of viewers of video content. Here are some key items that can be “gleaned”:

• Popularity of certain videos
• Which kinds of video content retains users (e.g., short form vs. long form, ad-supported vs. free, etc)
• Abandonment of playback (e.g., when does a user call it quits on a clip)
• How is the content shared? Does a user send it to a friend, to Facebook, to a blog?

This kind of data can clearly help a variety of video content providers and advertisers target content better to their users and produce better content overall. In this space, Omniture has been leading the charge for a while now with their SiteCatalyst product suite, which includes specific video metrics. The product suite includes an API which can integrate directly into a Flash-based video player, with particularly close integration with Brightcove’s video players, and provides hooks to track the various user behaviors that can occur during video playback.

Google does not want to be left behind in this space, given that they wish to “organize the world’s information”, and have recently opened up a relatively new component of their Google Analytics to all users of that service. The Event Tracking API has now been added to all Google Analytics accounts, whereas previously it was an invite-only beta feature. This portion of their analytics API allows you to track almost arbitrary event-oriented data, without affecting the more conventional web site-oriented metrics, such as pageviews. Event Tracking really enables users of Google Analytics to leverage the platform for video tracking, allow you to define and measure user events that are important to your video content and players. Here are some examples:

• Start playback of video
• Pauses and resumes
• Skipping backwards or forwards in a clip
• Turning the volume up or down
• How far the user got before stopping or moving to another clip

But the richness this kind of event tracking doesn’t stop there. With the proliferation of RIA applications on the web, you now have the opportunity to track user behavior, beyond video playback, at a greater level of detail.

• Track search terms within Flash or Flex-based applications
• Follow navigation paths through RIA applications without incurring page views in your metrics
• Track viral features in a video player or other RIA application: blog posts & social link sharing (Delicious, Digg, Reddit, StumbleUpon)
• The list goes on…

Check out a great primer on using the API at the link below.

http://www.insideria.com/2009/02/using-google-analytics-within.html

Techcrunch just wrote a great article on how we’re shifting away from pages and into streams.  I think the article raises a great point that this is a huge opportunity for start-ups to really change the status quo and start developing applications that work in real time.

So, the question I would raise is how can your company shift it’s products toward a real time web?  Think about the big internet brands and what would happen if they had to live in the real time web.  What if companies like Amazon, Ebay, and Google had real time services?  We also know that every time our economy has gone through a shift, new companies and ideas emerge that make us re-think our perception of the web.  In other words, if you’ve got an idea for the real time web, this is your chance to go out and build it.

This may sound esoteric, but to someone doing plugin development in Grails, it’s a life saver, and here’s why.

When building a plugin for Grails, the plugin itself is built as a Grails application. This has many benefits, including in some cases being able to run the plugin and test controllers and domain classes directly in the running plugin. However, most, if not all plugins are intended to plug into another Grails application. Given that, the only real way to test the usability of your plugin API, and whether the plugin works in the context of larger Grails application, is to install the plugin into another Grails application. Here’s an example:

1. I’m developing Plugins A and B to be installed in a new Grails CMS application I’m building
2. Plugin A depends on Plugin B to function
3. Once Plugin B is in good enough shape, I’ll install it into Plugin A using the Grails install-plugin command
4. Once Plugin A is in good enough shape, I can install it and Plugin B into my Grails CMS application
5. After testing the CMS for a while, I discover a bug in Plugin B which also requires a small change in Plugin A to accommodate the bug fix (are you still with me?)
6. I fix the bug in Plugin B and repackage
7. I remove Plugin B from Plugin A and install the latest version of Plugin B into Plugin A to make the changes required in Plugin A and repackage
8. In the CMS application, I remove both of the plugins and reinstall both Plugins into the CMS
9. I become tired of installing and uninstalling plugins and go out for beers

With Grails 1.1, this development cycle is improved drastically. Now, during development you can provide explicit locations for Grails plugin projects, without needing to install the plugin, to develop against that plugin. Here’s an excerpt from the Grails 1.1 release notes:

An application can now load plugins from anywhere on the file system, even if they have not been installed. Simply add the location of the (unpacked) plugin to you BuildConfig.groovy file:

// Useful to test plugins you are developing.
grails.plugin.location.jsecurity = "/home/dilbert/dev/plugins/grails-jsecurity"

// Useful for modular applications where all plugins and
// applications are in the same directory.
grails.plugin.location.'grails-ui' = "../grails-grails-ui"

This is particularly useful in two cases:

1. You are developing a plugin and want to test it in a real application without packaging and installing it first.
2. You have split an application into a set of plugins and an application, all in the same “super-project” directory.

Now if you want to test your plugins in the context of a larger application, you can do so without the pain of constant reinstallation.

From a time perspective (you have to exclude RegOnline because it was a nights a weekend project) it takes on average about 5 months to launch one of these applications and you need roughly 3 or 4 engineers to get it done.  My guess is that most of these companies boot strapped their development but current estimates say developing a web application costs anywhere from 50k to a few hundred based on complexity.  It’s also great to see these rapid development frameworks, such as Ruby on Rails, are accelerating development and time to market.

Lastly, I would also emphasize their focus on business processes. Many early stage companies completely neglect support needs, such as returns, customer compliants, etc.  It can end up costing you a lot of time and money if you don’t have systems on the back end to handle customer support issues.

In turn, I hope to encourage the use of my current favorite language, Python (see http://www.diveintopython.org/ for a good tutorial). For an interpreted language (it does compile to c byte code at runtime), its capabilities and community support are overwhelmingly substantial. I’m continually surprised as I discover more; its breadth is so great, that Python leaves itself open to satire ( also: here and here). I could drone on,  evangelizing its advantages at some detail (and bore everyone to tears, I’m sure), but that’s not why I’m writing today. No, the point here is to give a quick presentation on a particular package I’ve just started using that amazes me, and it should get more use: wxPython.

WxPython is module for Python that is essentially a wrapper for an open source project called wxWidgets, so most of the credit should go to them. WxWidgets is certainly widely used (link: http://wxwidgets.org/about/users.htm ); it’s a package that allows developers to quickly and easily access the GUI components in Windows, OS X, and various flavors of Linux. This allows development of applications that look native to the OS. WxPython allows one to rapidly develop applications entirely in Python, that look native to the OS. Imagine writing an application in OS X, then moving the code to a Windows or Ubuntu machine and having it work and look perfectly without any modifications! No more dealing with .dlls or compiling on individual machines.. just ‘python <appname>.py’.

In practice, it’s surprisingly easily to generate an entire event-driven application. The basic order of implementation is (1) design layout of your buttons,menus, widgets, etc, (2) implement event handlers, (3) bind event listeners to buttons / actions. I’d post some of my code, but it’s almost all currently in an NDA’ed project, so instead here’s some sample code from http://wiki.wxpython.org/AnotherTutorial that creates a program with a toolbar:

#!/usr/bin/python

# toolbar.py

import wx

class MyToolBar(wx.Frame):

def __init__(self, parent, id, title):

wx.Frame.__init__(self, parent, id, title, wx.DefaultPosition, wx.Size(350, 250))

vbox = wx.BoxSizer(wx.VERTICAL)

toolbar = wx.ToolBar(self, -1, style=wx.TB_HORIZONTAL | wx.NO_BORDER)

toolbar.AddSimpleTool(1, wx.Image(’stock_new.png’, wx.BITMAP_TYPE_PNG).ConvertToBitmap(), ‘New’, ”)

toolbar.AddSimpleTool(2, wx.Image(’stock_open.png’, wx.BITMAP_TYPE_PNG).ConvertToBitmap(), ‘Open’, ”)

toolbar.AddSimpleTool(3, wx.Image(’stock_save.png’, wx.BITMAP_TYPE_PNG).ConvertToBitmap(), ‘Save’, ”)

toolbar.AddSeparator()

toolbar.AddSimpleTool(4, wx.Image(’stock_exit.png’, wx.BITMAP_TYPE_PNG).ConvertToBitmap(), ‘Exit’, ”)

toolbar.Realize()

vbox.Add(toolbar, 0, border=5)

self.SetSizer(vbox)

self.statusbar = self.CreateStatusBar()

self.Centre()

self.Bind(wx.EVT_TOOL, self.OnNew, id=1)

self.Bind(wx.EVT_TOOL, self.OnOpen, id=2)

self.Bind(wx.EVT_TOOL, self.OnSave, id=3)

self.Bind(wx.EVT_TOOL, self.OnExit, id=4)

def OnNew(self, event):

self.statusbar.SetStatusText(‘New Command’)

def OnOpen(self, event):

self.statusbar.SetStatusText(‘Open Command’)

def OnSave(self, event):

self.statusbar.SetStatusText(‘Save Command’)

def OnExit(self, event):

self.Close()

class MyApp(wx.App):

def OnInit(self):

frame = MyToolBar(None, -1, ‘toolbar.py’)

frame.Show(True)

return True

app = MyApp(0)

app.MainLoop()

results in this (on Ubuntu):

Resulting application in Ubuntu

While not much to look at, certainly, briefly think about what’s going on here. In ~45 lines of code, we have a fully functional application. It doesn’t do much,  yet, but imagine what we could do if you started hooking up some of your existing Python code, or hooking in some other Python modules. There’s a lot of power in this; the mind can hardly grasp the possibilities of, say, Windows apps powered by Python (take that, Visual Studio). I feel strongly that it has the potential to handle some serious projects, if given the opportunity.

This would be intensive, but I’m still learning wxPython myself. So far, it’s been great fun, and I highly recommend others to check it out. I’d love to see some examples out there of anyone who’s developed apps in the framework (a quick search doesn’t reveal much), and perhaps I’ll post some of my own as I start using it more.

Until then, try taking a look at wxPython.org (link) and the wxPython wiki (link). Give it a shot; I’m sure you’ll love it.

Steve brings a wealth of experience to the table, including research in social network analysis and data mining during his Master’s at Tufts University, as well as extensive consulting experience delivering complex client projects in Flex/Flash, Java, Python, and PHP, to name a few.

He’s been a great asset so far, as in the 3 weeks he’s been with us he’s brought in two new clients, helped us through crunch mode to launch a major project for one of our largest clients, and has begun restructuring our server architecture. Not bad!

Read more about Steve and his experience on our About page, or visit him on LinkedIn.

http://help.brightcove.com/developer/samples/iPhone/iPhone-portal.cfm

This sample application highlights a couple interest points regarding the iPhone and Brightcove:

• Just because the iPhone doesn’t currently support Flash doesn’t mean that you can’t deliver high quality video via web applications. Brightcove’s sample iPhone web application simply loads an h.264 encoded QuickTime into the iPhone browser which can be played through the iPhone’s built-in QuickTime video player. No Flash needed.
• With some fairly basic JavaScript, you can achieve functionality in a web application similar to native applications with support for clean and “touchable” menus, and orientation (portrait vs. landscape) detection
• Brightcove’s RESTful Media API provides a flexible way to incorporate videos published through their platform, without requiring a Flash video player
]]> http://www.cantinaconsulting.com/2009/02/10/web-based-video-on-iphone-sans-flash/feed/ 0 http://www.cantinaconsulting.com/2009/02/04/random-thoughts-thick-and-thin-clients-and-other-google-isms/ http://www.cantinaconsulting.com/2009/02/04/random-thoughts-thick-and-thin-clients-and-other-google-isms/#comments Wed, 04 Feb 2009 15:53:00 +0000 adam http://www.cantinaconsulting.com/?p=105 At Cantina, we use Google in practically everything we do. We make heavy use of Google Apps for Domains to manage our email, calendars, and internal documentation. YouTube is a constant distraction, er, research tool. Some of us share photos via Picasa. SketchUp can be a handy tool for working on game development. And every once in a while, we have to do a Google search (yes even we sometimes have to look things up).

As time marches on, it is becoming clearer that Google is focusing on the browser as the primary application development platform. This is evident with their release of Chrome, their first foray into the browser market which attempts to make browsing faster and more reliable, and even more clear with the more recent news that Google has managed to get Gmail to work offline, with the use of Google Gears.

While I find the ability to have a fully browser-based application running offline impressive, my first thought upon hearing such news is: why? I may be old fashioned, but I still use an actual email client to read my mail (Apple’s Mail application). I’ve been able to read my mail offline for as long as I can remember. Mail clients have been around for years (decades?) and have been admirably solving the problem of reading and writing email for a long time. I realize that web-based email simplifies the process of reading and writing email by not requiring you to have to configure an email program with the necessary settings. But what about the other issues that make it a challenge? Being a developer, my browser is always crashing (and sometimes it’s not even my fault). Flash 10 on the Mac, for example, is constantly having me reload my Firefox instance and trying to pick up where I left off. This makes the browser an undesirable place to keep my email open.

Beyond Gmail, I must say that I’ve been burned enough times in writing long form content, be it emails, or blog posts, or bug reports, you name it, that I’m cautious and reluctant to do that in a browser. I’m a keyboard shortcut guy, and on the Mac, many times the go to beginning of line, or go to end of line key commands actually force the browser to hit the back button. I’ve lost a lot of work this way (my own fault), but the key command is a system standard, and the browser breaks that. In fact, I’m writing this blog post in an offline application, to later cut and paste it into our blogging system.

I’d also put web-based instant messaging into the category of “why do we need this in browser as well”. There has been a proliferation of web-based instant messaging, with Google Talk and Facebook, which requires me to hunt down the appropriate tab in Firefox to see what people are writing to me. This makes the whole instant messaging process far less “instant”.

So while all of what I have just mentioned might make me an oddball in the Web 2.0 world, where many (most) people I know read their email in the browser and have a Facebook window open at all waking hours, I have to take a moment to realize the lesson here. If history has taught us anything, it has taught us that the most technically correct or appropriate solution is not always (or rarely is) the solution that ultimately becomes successful, or popular. Take MySpace for example. The user experience is arguably miserable, yet MySpace paved the way for large scale adoption of social networking. Just because I think that my trusty old email client, which I have been using for years, can already do what Gmail’s miraculous new offline feature can do, and better, I have to appreciate the significance to the throngs of people that use Gmail via the browser and have never looked back.

P.S.

In other Google news, I must say I was excited to find that the defunct JotSpot blogging platform, which has consumed by Google has made its way into Google Sites. I was a fan of JotSpot wikis back in the day, and Google’s transformation of the product seems like a great addition to the product line.

In other news, if you’ve ever used another one of Google’s acquisitions that goes by the name of GrandCentral, it’s coming back and I’m looking forward to see what has been done to it.

To round out the Google rumor round up, there have been hints of a Google Web Drive. This seems like a natural progression in their cloud-based computing offerings. I’m an avid user of Jungle Disk so I’m curious to see what Google can whip up.

]]> http://www.cantinaconsulting.com/2009/02/04/random-thoughts-thick-and-thin-clients-and-other-google-isms/feed/ 0 http://www.cantinaconsulting.com/2009/01/23/job-opportunity-at-cantina/ http://www.cantinaconsulting.com/2009/01/23/job-opportunity-at-cantina/#comments Fri, 23 Jan 2009 16:03:51 +0000 adam http://www.cantinaconsulting.com/?p=103 While I know some of us are sitting around waiting for our bailout checks, at Cantina we’re doing our part to stimulate the economy.  We’re looking for someone with incredible technical skills and a real passion for programming.  You’ve got to have the personal skills to please our clients and always over deliver.  You should know it’s not about your favorite technology, but the right technology for the job.  If you’re tired of the same old legacy projects and want to challenge yourself with a really talented team of individuals and create amazing web applications, than take a look at our job posting:

http://www.linkedin.com/jobs?viewJob=&jobId=647499

]]> http://www.cantinaconsulting.com/2009/01/23/job-opportunity-at-cantina/feed/ 0 http://www.cantinaconsulting.com/2008/12/10/sync-soup-or-another-case-for-unified-online-identity/ http://www.cantinaconsulting.com/2008/12/10/sync-soup-or-another-case-for-unified-online-identity/#comments Wed, 10 Dec 2008 19:12:52 +0000 adam http://www.cantinaconsulting.com/2008/12/10/sync-soup-or-another-case-for-unified-online-identity/ As a software engineer, I find that I apply basic software engineering principles to all aspects of my life, and a big one is the “don’t repeat yourself” philosophy, or DRY. Nowhere have I felt more pain on this lately than with trying to solve the problem of a unified email, calendar, and contact solution that is available to me wherever I am. Let me state the problem more clearly:

At Cantina, we make heavy use of all that Google Apps has to offer to provide a cost effective, yet extremely functional solution to email (both web-based and IMAP) and shared calendars. This, for the most part, suits our needs adequately and with minimal cost and maintenance. Now, throw into this scenario the fact that we are consultants, and as such end up making heavy use of our clients’ respective email and shared calendar solutions, most if not all of which are handled via Microsoft Exchange Server. There are a whole host of reasons why this is a good thing for our clients, however this presents a problem for someone like myself, who likes to keep everything in one place, depending on where I am:

1. If I’m at my desk, I want it on my Mac laptop and want all of my email managed via Apple’s Mail application, and all of my calendar managed through iCal
2. If I’m out and about, I want it all on my iPhone (you can see my brand allegiance here – not a fanboy just like low maintenance and high integration)
3. If I’m really in a pickle and don’t have my laptop or my iPhone (this is rare), but still have internet, it would be ideal to have a unified web interface to get to all of this stuff, perhaps via Google Apps. Again this is a rare case.

Now, there are a myriad of synchronization technologies and solutions out there that attempt to bridge the gaps between these various components, such as:

• IMAP: Apple Mail – Google Apps Mail & Gmail (works great apart from the lack of Label/Folder IMAP subscription)
• Apple Mail’s Exchange Support: Apple Mail – Exchange (still requires IMAP to be enabled, which isn’t always the case)
• Spanning Sync: Google Calendar/Contacts – iCal/Address Book
• Entourage with Sync Services: Exchange Calendar/Contacts – iCal/Address Book (issues with multiple exchange accounts)
• NuevaSync: Google Calendar – iPhone (over the air, doesn’t require cable, yet takes up your only Exchange account on the iPhone)
• Active Sync on the iPhone: Exchange – iPhone (over the air, but only supports one Exchange account at a time)
• And so on…

All of these little “bridges” spanning the gaps between various applications each have their own small set of problems and limitations which makes this whole sync ecosystem break down. What’s worse, is that sometimes, attempting to make this work can have unintended or potentially disastrous consequences (Imagine all your calendar events from one client syncing onto another client’s Exchange server).

So there’s the problem, but what is the solution? For many people, a single Exchange or Mobile Me account will do the trick, but for me (a consultant using multiple services), it does not. Sure, there are some glimmers of hope. Apple is bolstering their Exchange support in their applications following the introduction of Active Sync to the iPhone. Sure, there might be a day soon when the iPhone supports multiple Exchange accounts and can subscribe to CalDAV on Google.

These are all patches to a solution that lacks a holistic view of the problem. Where have we seen this before? How about a unified login? OpenID attempts to solve the real and very present problem of managing separate authentication credentials across the vast ocean of sites requiring registration on the web. Though it’s not quite a homerun yet, there’s progress being made. Any standard will run into this issue, even HTML.

The questions here are these: Can we extend this concept of online identity beyond logging into sites? Can we aggregate our various online presence (including email & calendars) to our one true e-self? I think the answer is yes, but in time, and I think Apple’s lowly Address Book application, the humble servant of contact management on the Mac may serve as an example. You see, in Address Book, there is a particular contact card that is designated as “Me”, the current user. In this contact card, I can add any number of phone numbers, fax numbers, etc., but more importantly I can add multiple email addresses and IM screen names, which all are identified as “Me”. This means that no matter what email address in Apple Mail I use to send or receive email, if it’s in my “Me” card, the system knows it’s “Me”. I think that this very basic approach can be extended to aggregate online identity at a much higher and more meaningful level, across the various services I might use as a result of my online existence. Now we just have to agree on what that will look like, and if history has taught us anything, it won’t happen fast.

Thoughts?

]]> http://www.cantinaconsulting.com/2008/12/10/sync-soup-or-another-case-for-unified-online-identity/feed/ 2 http://www.cantinaconsulting.com/2008/11/18/while-weve-got-your-eyes/ http://www.cantinaconsulting.com/2008/11/18/while-weve-got-your-eyes/#comments Tue, 18 Nov 2008 19:42:35 +0000 chris http://www.cantinaconsulting.com/?p=61 take a look at our potential logos as they unfold. let us know what you think, and feel free to submit comments or rate the submissions.
]]> http://www.cantinaconsulting.com/2008/11/18/while-weve-got-your-eyes/feed/ 3 http://www.cantinaconsulting.com/2008/11/18/specious/ http://www.cantinaconsulting.com/2008/11/18/specious/#comments Tue, 18 Nov 2008 19:37:54 +0000 chris http://www.cantinaconsulting.com/?p=58 Here comes a cat out of a bag – we’re in the process of building out our brand. Every growing company faces this challenge at some point, and so Cantina finds itself in the thick of it.
As purveyors of tech that, at least in theory, increases social interaction and the power of community, we’ve decided to walk our walk and dip our toes in a bit of the crowd-sourcing pool and see what kind of logo we could fish out. There are a number of these services available, we’ve chosen to give Crowdspring a day in court. The results thus far have been wide-ranging; clearly this crowd is a heterogenous one.
What’s been really interesting, from my POV, is the controversy this approach stirs amongst those in the design community. The rub seems to lay not in crowd-sourcing, but rather in the notion of speculative work, or “exert your effort and maybe I’ll bite”. Imagine using this approach for other day to day transactions? Having someone paint your house *before* paying them? “No, sorry, I don’t like it. Thanks anyway.” After a chef has prepared your dinner? “That looks tempting enough, but I think I’ll pass.” Turns things upside down a bit no?
A designer and colleague of ours, Kurt Zinser of Method Bureau, says, spec work is “harmful to the profession, encourages sub-par work and turns the practice into a commodity,” and pointed me to this statement from AIGA: 
“AIGA believes that doing speculative work seriously compromises the quality of work that clients are entitled to and also violates a tacit, long-standing ethical standard in the communication design profession worldwide. AIGA strongly discourages the practice of requesting that design work be produced and submitted on a speculative basis in order to be considered for acceptance on a project.” They even provide a sample response letter that further explains their position.
I’m sure there are those skeptics out there who will naturally counter that of course AIGA would seek to protect itself and the interests of its members; what representative organization wouldn’t? Beyond the obvious then, I think the AIGA argument has merit. Many specialized crafts have and are dealing with these same pressures – the commoditization of one’s long honed skill.
Andrew Hyde has some strong feelings too, particularly regarding Crowdspring itself:
It appears the controversy is tied to the idea of speculative work versus the notion of crowd-sourcing. Is there a better way, a solution with positive impact for both sides of the divide?
]]> http://www.cantinaconsulting.com/2008/11/18/specious/feed/ 0 http://www.cantinaconsulting.com/2008/11/11/joining-cantina/ http://www.cantinaconsulting.com/2008/11/11/joining-cantina/#comments Tue, 11 Nov 2008 20:46:43 +0000 adam http://www.cantinaconsulting.com/?p=52 I thought I would sit down and write my first post by thanking the team at Cantina for the opportunity to work with them. I’ve only been here two weeks and I already know I’m working with the best teams on the planet. As I met with many of their clients over the last few weeks, I’ve heard nothing but praise for the work they do.

As we face the challenges of the coming year, with a tough economy, it’s good to know that you’re with a group of people that can really get the job done. My wish for the next few months is to take on the task of supporting each of our clients as they try to navigate our current financial situation, but also find new opportunities and business; so the team here can continue to do what they do best, deliver amazing applications on time and under budget.

]]> http://www.cantinaconsulting.com/2008/11/11/joining-cantina/feed/ 0 http://www.cantinaconsulting.com/2008/11/06/carm-huntress-joins-cantina-as-a-business-development-principal/ http://www.cantinaconsulting.com/2008/11/06/carm-huntress-joins-cantina-as-a-business-development-principal/#comments Thu, 06 Nov 2008 20:16:33 +0000 matt http://www.cantinaconsulting.com/?p=41 Please join me in welcoming Carm Huntress, the newest partner at Cantina Consulting, as a Business Development Principal.

With a deep passion for technology, new business innovations and web applications, Carm brings insight and creative ideas to any project. Leading Sales and Business Development, he works to match client needs directly with the right team at Cantina.

We’re excited to have Carm as a partner as Cantina continues to grow.

Feel free to read Carms’ bio in the About section.

]]> http://www.cantinaconsulting.com/2008/11/06/carm-huntress-joins-cantina-as-a-business-development-principal/feed/ 0 http://www.cantinaconsulting.com/2008/10/31/election-tech/ http://www.cantinaconsulting.com/2008/10/31/election-tech/#comments Fri, 31 Oct 2008 21:11:06 +0000 chris http://www.cantinaconsulting.com/?p=37 Here it is, the spookiest night of the year and the prospect of another election day debacle is about as frightening a prospect as any. And why shouldn’t we be scared? What’s really changed in the past 8 years in regards to the process of voting? In 2000, the death of the chad pappy, the paper ballot, was all but assured. Now we’re 8 years later, the iPod of then is now the doorstop of today, we’ve got touch-based computing in our pockets, we can sign, seal and deliver nearly every bit of life’s required documents digitally and yet… The voting process is still antiquated and unsolved. How is it that we can file our taxes – transmitting uber-sensitive data over the ether, yet can’t send a simple authenticated vote? Where is the open source movement to solve this issue? Clearly we can’t allow one or two vendors (the Republican Voting Company… err Diebold comes to mind). Surely this is a problem that can be solved.
]]> http://www.cantinaconsulting.com/2008/10/31/election-tech/feed/ 0 http://www.cantinaconsulting.com/2008/10/24/gorm-multiple-datasource-access/ http://www.cantinaconsulting.com/2008/10/24/gorm-multiple-datasource-access/#comments Fri, 24 Oct 2008 16:19:41 +0000 matt http://www.cantinaconsulting.com/?p=36 It appears that the limitations of Grails object relational mapping (GORM) – only allowing connections to a single datasource – has been resolved with a new plugin from Burt Beckwith. This feature which allows application architects to design systems that can shard data across federated databases has been around for awhile in ActiveRecord – Rails object relational mapping framework. So it is good to see someone has addressed the issue. I hope to try it out soon.
]]> http://www.cantinaconsulting.com/2008/10/24/gorm-multiple-datasource-access/feed/ 0 http://www.cantinaconsulting.com/2008/10/24/adobe-releases-flash-10-player/ http://www.cantinaconsulting.com/2008/10/24/adobe-releases-flash-10-player/#comments Fri, 24 Oct 2008 13:17:47 +0000 chris http://www.cantinaconsulting.com/?p=35 Flash 1… 2… 3… 4… 5… MX… MX 2004… 8… 9… … … and now? Just “10″. nice and easy.

The latest and greatest from Adobe includes support for native 3D (bring on more carousel views), “inverse kinematics“, jointed assets that react intelligently to each other when animated (see PrayStation circa ‘99?). Additionally, they promise advanced text rendering and control (again), dynamic sound gen, and an yet another “advanced” drawing API. How about animating rounded corner masks? What will this all bring? The resurgence of the intro skip or further along the never ending path to a “richer experience”. we’ll see…

]]> http://www.cantinaconsulting.com/2008/10/24/adobe-releases-flash-10-player/feed/ 0 http://www.cantinaconsulting.com/2008/10/21/pivot-ui-toolkit-10-released/ http://www.cantinaconsulting.com/2008/10/21/pivot-ui-toolkit-10-released/#comments Tue, 21 Oct 2008 19:00:33 +0000 adam http://www.cantinaconsulting.com/?p=34 Our good friend and former colleague Greg Brown has just recently launched the first official 1.0 release of the open source Pivot Toolkit. The Pivot Toolkit provides Java developers a great new way to build applications with rich user interfaces that can be easily deployed both to web users and to desktop users.

Pivot harnesses the power of the Java2D API and packages it in a toolkit that offers these benefits:

• MVC architecture to separate controller logic from the view layer
• XML-based markup (WTKX) to design views including CSS-like style definition
• Easy integration with remote web data services
• Built-in charting capabilities based on JFreeChart

Check it out: http://pivot-toolkit.org/

]]> http://www.cantinaconsulting.com/2008/10/21/pivot-ui-toolkit-10-released/feed/ 1 http://www.cantinaconsulting.com/2008/09/01/fitting-grails-into-an-ant-build-environment/ http://www.cantinaconsulting.com/2008/09/01/fitting-grails-into-an-ant-build-environment/#comments Mon, 01 Sep 2008 17:41:54 +0000 adam http://www.cantinaconsulting.com/?p=33 I’ve been working on a project that involves rolling a Grails-based application into a much larger build process, one which ties together several Java components and test suites through an Ant build process. This integration involves Ant calling the Grails command line tasks (clean, test-app, war, etc). The standard build.xml that is found after creating a new Grails application currently uses the exec task to invoke the command line tasks. While this works, it takes you out of the world of Ant (and consequently out of the world of Java).

Fortunately, for a little while now, the Grails distribution has been packaged with an Ant macro, graciously contributed by LinkedIn, which allows you to more tightly integrate Grails tasks with an Ant build. You can find the script here:

http://svn.codehaus.org/grails/trunk/grails/src/grails/grails-macros.xml

This macro sets up a Java environment using the GrailsStarter and GrailsScriptRunner bootstrap classes to startup a Grails environment and execute the given Grails Gant script. This is similar to the way the Grails command line batch/shell scripts function, however the macro does it within an Ant java task, which allows us to add additional information to the JVM as it executes, such as additional classpath information, system properties, and JVM arguments to name a few.

You can use this macro by importing it into your Ant build script and invoking it as follows (assuming your GRAILS_HOME environment variable is set properly):

<import file="${env.GRAILS_HOME}/src/grails/grails-macros.xml" />

<grails command="clean" />
<grails command="war" args="mywarfile.war"/>
...

This is certainly handy but doesn’t offer much beyond using Ant’s exec task. However, once we look at what we can pass into the macro, the added value becomes more apparent. The macro accepts several argument attributes and elements to augment the way the macro executes. The example below shows how we can add additional system properties and classpath items to a run-app command.

<grails command="run-app">
  <sysprops>
    <sysproperty key="server.port" value="9999" />
  </sysprops>
  <extend-classpath>
    <pathelement location="SOME_OTHER_LIB_LOCATION/foo.jar"/>
    <pathelement location="SOME_OTHER_LIB_LOCATION/bar.jar"/>
  </extend-classpath>
</grails>

This example shows that we can add in system properties to specify to things like the server.port value for the run-app command. In this example it is hardcoded, however in most non-trivial Ant build processes, this would be specified via properties file or some other mechanism to provide values that are specific to the build environment in question (e.g., development, test, integration, production).

What’s more interesting in this example is that we’ve added additional elements to the classpath which then get passed along to the Ant java task. This provides tremendous flexibility to include items in the classpath that do not appear in the standard Grails locations like these:

• GRAILS_HOME\dist
• GRAILS_HOME\lib
• PROJECT_HOME\lib

This flexibility allows for other build artifacts in an Ant build process to be dynamically included into the Grails runtime from other locations in the build process.

It should be said that I’ve had to make some modifications to the macro in order to tailor it to my needs as well as to get it working properly across environments. You can see the changes I’ve made here.

]]> http://www.cantinaconsulting.com/2008/09/01/fitting-grails-into-an-ant-build-environment/feed/ 0 http://www.cantinaconsulting.com/2008/05/01/chris-lamothe-joins-cantina-as-user-experience-principal/ http://www.cantinaconsulting.com/2008/05/01/chris-lamothe-joins-cantina-as-user-experience-principal/#comments Thu, 01 May 2008 16:33:40 +0000 adam http://www.cantinaconsulting.com/2008/05/01/chris-lamothe-joins-cantina-as-user-experience-principal/ Please join me in welcoming Chris Lamothe, the newest partner at Cantina Consulting, as a User Experience Principal.

Chris brings nearly 10 years of experience in a variety of aspects of user-centric design and interactive development, with specific areas of focus in e-learning and Rich Internet Application (RIA) design and development.

Both Matt and I have worked alongside Chris in the past, during consulting engagements at Molecular as well as a variety of side projects over the years. We’re thrilled to have Chris a partner as Cantina continues to grow.

Feel free to read Chris’ bio in the About section.

]]> http://www.cantinaconsulting.com/2008/05/01/chris-lamothe-joins-cantina-as-user-experience-principal/feed/ 0 http://www.cantinaconsulting.com/2008/04/22/gotchas-in-using-backgroundrb-in-ruby-on-rails/ http://www.cantinaconsulting.com/2008/04/22/gotchas-in-using-backgroundrb-in-ruby-on-rails/#comments Wed, 23 Apr 2008 03:02:12 +0000 adam http://www.cantinaconsulting.com/2008/04/22/gotchas-in-using-backgroundrb-in-ruby-on-rails/ I’ve been working on a bit of code to perform audio and video encoding for media files uploaded to one of our client’s sites and I was thrilled to come across BackgrounDRb, a Rails plugin that allows developers to build scheduled background tasks, similar to the OpenSympony’s Quartz for Java. The plugin also allows you to allow user actions to initiate long running processes by spawning worker threads from controllers (or other places).

Of particular interest to me was the ability to spawn (fork) worker threads from user actions, or in this case, ActiveRecord callbacks which were called when the user action caused my model object to be saved. The basic order of operations is this:

1. User uploads an audio file
2. Uploaded file data is loaded into an attachment_fu model object
3. Model object is saved
4. Model object’s after_save callback is called
5. The after_save callback determines whether the uploaded file requires encoding, and spawns a BackgrounDRb worker process if it does

In this process lay many issues. I’ve attempted to describe some of them below.

Close your connections

This may be obvious to many, but I figured with all that ActiveRecord does for you, that if I do some work with ActiveRecord in a BackgrounDRB worker process, my database connections would be closed automatically. This was not the case, however it can be quickly remedied by adding the following after all your code is done doing what it needs to do:

ActiveRecord::Base.connection.disconnect!

Don’t try to pass entire ActiveRecord objects to workers from Rails

I started building a simple call to spawn a new BackgrounDRb worker from an ActiveRecord lifecycle callback method (see below), and starting running into errors like these:

undefined method `[]' for #<DRb::DRbUnknown:0x2501bd4>

I found a number of postings online indicating that simply adding the following to my model objects would clear this up:

include DRbUndumped

Doing so did not fix my undefined method problems, so when I came across this on another blog, I decided to cut my losses and just pass the database ID.

When passing arguments from Rails to BackgrounDRb workers, don’t pass huge ActiveRecord objects. Its asking for trouble. You can easily circumvent the situation by passing id of AR objects.

From: BackgrounDRb best practises

One thing that I didn’t think I’d be dealing with in coming to Rails from a Java background is serialization issues, but there we have it.

Don’t create new workers from new record callbacks

This may have been common knowledge, but I had to discover this the hard way. The after_save callback in ActiveRecord model objects is called before the save transaction has been committed. The implication this has is that if I pass an ID of an ActiveRecord object to BackgrounDRb for further processing, strange things can happen.

In the case of my after_save callback being called on a newly created object, I found that most of the time, by the time the BackrounDRb process starts working and tries to retrieve the object using the ID I have passed, my original object.save() transaction has not yet committed, so I get errors indicating the record could not be found, even though I check the database no more than a second later and the record is there and intact.
It seems that I’m not the only one that was looking for a post-commit callback:

• Proper cache expiry with after_commit
• A good thing to know: after_save sits inside the transaction
]]> http://www.cantinaconsulting.com/2008/04/22/gotchas-in-using-backgroundrb-in-ruby-on-rails/feed/ 0 http://www.cantinaconsulting.com/2008/02/07/happenings/ http://www.cantinaconsulting.com/2008/02/07/happenings/#comments Wed, 06 Feb 2008 18:33:10 +0000 adam http://www.cantinaconsulting.com/2008/02/07/happenings/ There’s been a bit of radio silence on our blog lately, and it’s for good reason!  We’ve been busy on several Rails and Grails-based projects lately which is why we’re very excited about the releases of both Rails 2.0.x and the first full 1.0 release of the Grails framework. 

The Grails release in particular is significant as the framework has finally emerged from "in development" status which removes one more barrier for web project teams and IT departments to using the framework.  We’ve had success with the Grails framework particularly due to the fact that it sits very well in the Java enterprise ecosystem, including the relatively straightforward integration of existing Java-based Hibernate models.  This integration with Hibernate, which is a key factor in Grails’ ability to be a contender for new IT projects with teams that are Java EE and Spring/Hibernate-oriented, is a fairly straightorward process that involves dropping in your existing mapping XML and Java POJOs.  As if by some magic, you get all the benefits of GORM on your existing Java POJO data model, including dynamic search methods and the criteria builder DSL.

• Groovy on Grails 1.0: http://grails.org/1.0+Release+Notes
• Groovy/Grails Zone on DZone: http://groovy.dzone.com/
• Ruby on Rails 2.0: http://weblog.rubyonrails.org/2007/12/7/rails-2-0-it-s-done

 

]]> http://www.cantinaconsulting.com/2008/02/07/happenings/feed/ 0 http://www.cantinaconsulting.com/2007/12/08/amazon-ec2-first-impressions-mounting-s3/ http://www.cantinaconsulting.com/2007/12/08/amazon-ec2-first-impressions-mounting-s3/#comments Fri, 07 Dec 2007 19:18:28 +0000 adam http://www.cantinaconsulting.com/2007/12/08/amazon-ec2-first-impressions-mounting-s3/ We’ve got a small internal project at Cantina that aims to make use of the Groovy on Grails framework and some of our Grails plugins, and we plan on using S3 as the persistent storage for the project.  We decided to test out a small EC2 instance at Amazon to use as an integration point for the project for a couple reasons:
• EC2 instances are very quick to setup
• They are not charged for data transfer to S3
• They are presumably the closest you can be to your S3 storage in terms of network latency

Setting up our initial EC2 instance was incredibly easy.  There’s a wealth of pre-built Amazon Machine Images, or AMIs, out there with various configurations for different application servers, including Apache, MySQL, JBoss, Tomcat, and, our new favourite, Red5.  I was able to get one up and running fairly quickly with the packages I needed (I love yum). 

Actually, I was floored by how fast I had a brand new server up and running, considering I’ve had requests submitted to fairly large enterprise grade hosting companies for such intensely complicated things as, say opening a new port in the firewall, take over a week.  I guess the landscape is changing, but I digress…

In order to use Amazon S3 as the backing store for our new EC2 instance, we seemed to have a few options:

1. Code our application to manage the transfer and synchronization of files to S3, perhaps via our Amazon S3 Grails Plugin
2. Utilize an S3-aware file synchronization tool such as the jets3t Synchronize tool, or the Ruby s3sync tool
3. Mount S3 as a filesystem in the EC2 instance

Since we’ve already been doing #1, and #2 isn’t exactly real-time, we decided to give #3 a go.  To do so, we enlisted the help of a couple of tools:

• JungleDisk: A multi-platform tool that provides a local WebDAV interface to S3, suitable for mounting as a filesystem from the Mac OS X Finder, or from Linux using…
• davfs2: Linux filesystem driver that will mount a WebDAV URL to a mount point in the local filesystem

JungleDisk is a great tool in general for interacting with an S3 account, and I’ve been using it for a little while now for my own backup purposes on my Mac development laptop.  The Linux version provides a standalone command line program (in addition to the GUI that comes on all platforms) which can be run as a daemon and scripted to startup on boot. 

The setup was surprisingly simple.  To get JungleDisk running from the command line client, you need to provide a configuration file, commonly called jungledisk-settings.ini.  The documentation says that you should run the GUI first to generate the file before running the command line version, but I was able to copy over the file from my Mac laptop and update the values for the EC2 instance.  Here’s an example of the configuration file:

LoginUsername=
LoginPassword=PROTECTED:
AccessKeyID=XXXXXXXXXXXXXXXXXXXXX
SecretKey=PROTECTED:XXXXXXXXXXXXXXXXXXXXX
Bucket=default
CacheDirectory=/var/cache/jungledisk
ListenPort=2667
CacheCheckInterval=120
AsyncOperations=1
Encrypt=0
ProxyServer=
EncryptionKey=PROTECTED:
DecryptionKeys=PROTECTED:
MaxCacheSize=1000
MapDrive=
UseSSL=0
RetryCount=3
FastCopy=1
WebAccess=0
LogDuration=30
ArchiveFlag=5
ArchiveDuration=60
PasswordPrompt=0

I setup jungledisk to startup on boot using a really handy /etc/init.d script from the JungleDisk forums found here.

Once JungleDisk was configured and running, I had a local WebDAV server running at http://localhost:2667.  This could be used in the KDE to browse the filesystem, but since I’d like my web application to be able to access it via the filesystem, the next step was to get davfs2 running.

The EC2 instance did not have davfs2 installed by default (at least not the AMI I chose, which was based on the default AMI), so I simply downloaded the source distribution and compiled locally on the EC2 instance.  The base AMI I was using did not have gcc or the neon development libraries (Neon is a WebDAV library that davfs2 uses for communicating with WebDAV servers).  Luckily yum was installed on the EC2 instance so getting these dependencies was pretty straightforward.

davfs2 can be configured to run by non-root users, or by root.  The configuration of davfs2 depends on your choice here as some configuration options are intended only for system wide davfs2 configuration started from root.  I opted to take this approach, setup my /usr/local/etc/davfs2.conf file with the following configuration options:

dav_user        mydavuser
dav_group       mydavgroup
kernel_fs       fuse
ask_auth        0

Since JungleDisk provides WebDAV access to localhost only, and does not require authentication, setting ask_auth to 0 is useful to prevent davfs2 from prompting for a password when mounting the WebDAV URL.  Last but not least, I added an entry to /etc/fstab to configure the mount:

http://localhost:2667 /mountpoint davfs nolocks,noaskauth,rw

Voila!  Now my S3 instance is mounted to the local Linux filesystem on my EC2 instance.  I have not done any performance testing or cache tuning, but this article over at Right Scale looks promising.  Once we have our application and up and running, I’ll post back with some more information on how this configuration is working.

 

 

 

 

]]> http://www.cantinaconsulting.com/2007/12/08/amazon-ec2-first-impressions-mounting-s3/feed/ 2 http://www.cantinaconsulting.com/2007/12/04/one-step-closer-to-grails-10/ http://www.cantinaconsulting.com/2007/12/04/one-step-closer-to-grails-10/#comments Tue, 04 Dec 2007 15:18:22 +0000 adam http://www.cantinaconsulting.com/2007/12/04/one-step-closer-to-grails-10/ Graeme and the Grails community have been hard at work lately getting Grails ready for a 1.0 release, and the latest release candidate, RC2 is quite indicative of their labors.  There are some impressive additions to this release, including a initial pass at a full set of reference documentation, Spring 2.5, and over 140 bug fixes and improvements.  This is truly a herculean effort, and I can’t wait to start testing our plugins in RC2. 

You can check get the latest and greatest, as always, at grails.org.

 

]]> http://www.cantinaconsulting.com/2007/12/04/one-step-closer-to-grails-10/feed/ 0 http://www.cantinaconsulting.com/2007/11/20/red5-plugin-for-grails/ http://www.cantinaconsulting.com/2007/11/20/red5-plugin-for-grails/#comments Mon, 19 Nov 2007 20:59:58 +0000 matt http://www.cantinaconsulting.com/2007/11/20/red5-plugin-for-grails/ Continuing with my Grails plugin love fest, I spent several 3-4 AM nights digging into how to integrate Red5 RTMP streaming into my Grails Video plugin. The two options I came up with were:
1. Leave the Red5 functionality as a separate WAR and use a shared directory which the video plugin would deposit the encoded movies
2. Copy the war artifacts into the Grails plugin so the Grails app embeds the Red5 functionality within the WAR

I opted for the latter because I would like to have the Red5 application code use GORM to read meta data about the Movie asset. Additionally, to have a tight integration with Spring Security I would like to have the artifacts share the same application context. Finally, it is easier to debug code (btw, IntelliJ IDE rocks) if you don’t have to manage the startup of two different WARs. I’d like to say developing this plugin was easy, but in all honesty, it was a totally pain in the bum, and at the time, it seemed overly complex. In hindsight though, I realize that the reason for the “pain in the bum” was my lack of understanding of the life cycle of the context loader in Spring.

Once that hurdle was jumped, due to the tight Java/J2EE integration, the rest of the plugin development, installation scripts, custom artifact, etc. was ridiculously easy. The work was mostly setting up Spring configuration for the plugin. Because of how elegant the plugin architecture is, I think stitching together tiny pieces of functionality that is packaged in plugins is the best way to grow functionality base of Grails.

With this in mind I decided to release the Red5 integration work as a separate plugin and have the Video plugin depend on that for the RTMP streaming. So if one person doesn’t want to use all the Video plugin functionality they can at least use the Red5 Integration functionality. If you’d like to check it out please find it in the grails plugins section of our site. One thing to note is the Red5 plugin comes packaged with the source code for Red5.

I am going to send an email to the Red5 team and see if they will keep me abreast of new functionality as it comes down the road so I can maintain the plugin. I’ll keep folks posted on what they say. Finally, I’d like to thank, the Red5 team for the their 0.6.3 WAR release of the Red5 server and Alexander zhukov who created Red5-minimal. The fact that Alexander was able to accomplish what he did let me know it was “in theory” possible to incorporate the functionality in a plugin and gave me inspiration during the dark times. If you become the next youtube with this Grails plugin, throw a brother a couple bucks…. do the right thing

]]> http://www.cantinaconsulting.com/2007/11/20/red5-plugin-for-grails/feed/ 0 http://www.cantinaconsulting.com/2007/11/10/sweet-potato-pie-a-video-plugin-for-groovy-on-grails/ http://www.cantinaconsulting.com/2007/11/10/sweet-potato-pie-a-video-plugin-for-groovy-on-grails/#comments Fri, 09 Nov 2007 20:49:55 +0000 matt http://www.cantinaconsulting.com/2007/11/10/sweet-potato-pie-a-video-plugin-for-groovy-on-grails/ Hi All, adding to the new found obsession we have for Groovy on Grails, we ripped out a Video Plugin to convert and display flash videos. Hopefully it will give folks something fun to play with on the weekend

You can find information about the plugin on our Grails Video Plugin Page.

And as with the Amazon S3 Plugin, this is a very preliminary version, and we’re hoping to get some good feedback from the Grails Community and you on what we can do better. However, there may be some bugs that we haven’t quite gotten to yet.

Feel free to leave comments regarding the plugin on this posting. We know we have a lot more testing to do and features to add, so any feedback is most welcome.

]]> http://www.cantinaconsulting.com/2007/11/10/sweet-potato-pie-a-video-plugin-for-groovy-on-grails/feed/ 0 http://www.cantinaconsulting.com/2007/11/06/hot-off-the-press-an-amazon-s3-plugin-for-groovy-on-grails/ http://www.cantinaconsulting.com/2007/11/06/hot-off-the-press-an-amazon-s3-plugin-for-groovy-on-grails/#comments Mon, 05 Nov 2007 18:22:44 +0000 adam http://www.cantinaconsulting.com/2007/11/06/hot-off-the-press-an-amazon-s3-plugin-for-groovy-on-grails/ We’ve released our first ever plugin for the Groovy on Grails web application framework!  You can see the details over on our new Grails Plugins page. 

In short, we wanted to build something that would manage static file assets such as images, movies, audio, Flash, and perhaps down the road, site backups, on the Amazon Simple Storage Service (S3). 

This is a very preliminary version of the plugin, and we’re hoping to get some good feedback from the Grails Community and you on what we can do better.  However, there may be some bugs that we haven’t quite gotten to yet. 

Feel free to leave comments regarding the plugin on this posting.  We know we have a lot more testing to do and features to add, so any feedback is most welcome.

]]> http://www.cantinaconsulting.com/2007/11/06/hot-off-the-press-an-amazon-s3-plugin-for-groovy-on-grails/feed/ 0 http://www.cantinaconsulting.com/2007/10/31/red5-wicked-cool/ http://www.cantinaconsulting.com/2007/10/31/red5-wicked-cool/#comments Wed, 31 Oct 2007 16:37:04 +0000 matt http://www.cantinaconsulting.com/?p=16 I have been playing around with Red5 Media Server, the open source flash server. I have to say – wicked cool. I’d never be able to afford a working version of Flash Media Server but always wanted to play around with the functionality.

I’m amazed at the way the Red5 developers have been able to reverse engineer the protocol for the RTMP by observing byte streams – who wooda thunk. Check it out at – http://osflash.org/red5/discovery or check out this email discussion thread – http://osflash.org/pipermail/red5_osflash.org/2005-September/000134.html

Anyway, for anyone unfamiliar with the Red5 technology the server is built in Java (Ruby version to come soon???) and the install was fairly easy. You can install both as a standalone server (Mac OSX) and deployed as Tomcat app (series of WARs). The standalone version uses Tomcat under the covers.

The demo flash apps included in the install were:

An app acting as as video broadcaster
An app that records a video stream to the server using flash
An app that is a chat room
An app that uses Shared Objects
A couple others…

They all worked fairly well, however, I ran into two problems. The first problem was not related to Red5 but that Flash did not recognize the video drivers (using an Intel MacBook Pro) and I had to change the preferences for Flash movies to use the USB Video Class.

The second problem was that the video quality was a little rough for the video recorder. Still working on the issue, please leave a comment if you have any ideas.

Finally, I found a great video tutorial site that covers some basics to setting up the Red5 server. It also, helped me setup a free development environment for Flash movies. Check it out – http://www.flashextensions.com/tutorials.php

Some of the videos are really basic and geared towards actionscript developers – i.e., setting up Eclipse – but I found some of the others pretty useful.

]]> http://www.cantinaconsulting.com/2007/10/31/red5-wicked-cool/feed/ 0 http://www.cantinaconsulting.com/2007/10/29/how-healthy-is-grails/ http://www.cantinaconsulting.com/2007/10/29/how-healthy-is-grails/#comments Mon, 29 Oct 2007 16:22:35 +0000 matt http://www.cantinaconsulting.com/?p=15 One question we get a lot at Cantina is that of whether Grails is a passing fad, or if it is something that has some staying power. We have gotten that question (in some form or another) quite a bit, so it might help to explain where we’re coming from.

I agree with Adam’s thoughts in his previous post and have been very impressed with the activity in the Grails community. I subscribed to the user mailing list. Each day I receive from this list anywhere from 40-60 emails from users running into various issues on projects and folks from the Grails community providing their suggestions or troubleshooting tips. The activity of user/developer mailing lists is one of the most important benchmarks in determining the health of an open source framework – along with supplied functionality (obvious), core technology, the architects driving the vision, commercial support, documentation, check-in velocity and discussion in the blogosphere. To give an indication of the acceleration of activity in the Grails community, in October 2006 the same mailing list was averaging around 5-6 emails – almost a 10 fold increase in one year.***

Also, last week on the Grails user mailing list, there was some spirited debate on the level of Grails documentation (or lack of it) and whether it was appropriate for the release level of the framework. The amount of documentation right now doesn’t really concern me. What struck me the most about the dialog was the intensity of the debate. It shows the community is excited about what has been developed, are passionate to help out in whatever way they can, and care deeply about the frameworks success. And the community’s passion/enthusiasm for Groovy/Grails is clearly indicative of the framework’s ability to meet a need and fill a gap, something the community is looking for. IMHO this enthusiasm will be the driving force of success and perpetuate Grail’s momentum. And while more formal documentation is sure to come down the road, I’ve found the answer to most of the issues i’ve run into by querying the mailing list. It has been an excellent source of living documentation. – http://www.nabble.com/codehaus—grails-f11860.html

Of course with every new open source project there is always a lot of user/developer mailing list activity in the beginning. The question always becomes: Does this activity last, does it have staying power? With over a year and half of Grails development under their belt, a pending 1.0 release, and the clear need for a rapid application development framework in the J2EE architecture landscape, I have the feeling Grails is here to stay. Now I’m just trying to find the best way to support the growth…

That being said, one of our goals here at Cantina will be to leave some tips/issues that we run into as we develop plugins for the framework. Although it will not be formal documentation – we get our kicks from developing functionality – there may be some issue/tips that we run into that can be helpful to you. And please feel free to weigh in by leaving a comment if you know a better approach.

*** fyi, this calculation was performed with a VERY informal last year inspection of the mailing list on Nabble

UPDATE – 10/31/2007

I guess I should be been paying attention to the email threads a little better… Two email threads -

http://www.nabble.com/number-of-people-companies-using-Grails-tf4721318.html

and

http://www.nabble.com/Mailing-lists-statistics-tf4693805.html#a13416495

also discuss the growing activity of the mailing list.

]]> http://www.cantinaconsulting.com/2007/10/29/how-healthy-is-grails/feed/ 0 http://www.cantinaconsulting.com/2007/10/26/what-i-like-about-groovy-on-grails/ http://www.cantinaconsulting.com/2007/10/26/what-i-like-about-groovy-on-grails/#comments Fri, 26 Oct 2007 16:35:51 +0000 adam http://www.cantinaconsulting.com/?p=14 First let me congratulate all the folks that have been going crazy getting the Groovy on Grails (grails.org) framework to version 1.0 (almost there!). Just when I think my 0.5.6 version is going to be around for a while, they start releasing more versions, with a fury.

We’ve used Java here at Cantina on innumerable projects with a great deal of success. The toolset is very complete and Spring and Hibernate have been a godsend for allowing us to focus on the intellectual "meat" of a project. Then, in an effort to explore some new technology for a couple prototypes we were working on we found Grails.

I think the first thing that drew us (me) to Grails was the mantra that I heard over and over again at a talk given by Venkat Subramaniam at Sun a while ago regarding Groovy on Grails have more "signal to noise". Less syntactical noise, more code signal (i.e., the "meat"). In his talk he threw together an AJAX enabled form in about 10-15 minutes with all the CRUD and validation you need.

Once we started using Grails in house, it quickly became apparent how deep the mantra of having a greater "signal to noise" went. We love Spring and Hibernate but we hate XML configuration. Yes, XML is ubiquitous, very readable, and supported everywhere, but, as technologies like Spring and Hibernate put more of our application structure into XML, it makes it very hard to debug all of our application when some of the structure sits in very static XML.

Grails provides a great approach to this. Through the Grails BeanBuilder, you specify all of that lovely Spring configuration within a very readable and debuggable Groovy syntax. This makes for a much more powerful way to configure the structure of your application as well as allows you to actually step through parts of your configuration with a debugger.

Of course, Grails does a whole lot more than that (including a lot of the auto-wiring in Spring so that you don’t have to do any configuration), and here are just some of the things that caught our eye:

• GORM (Grails Object Relational Mapper): as if Hibernate wasn’t powerful enough, Grails adds some useful methods of querying and mapping your object model that go above and beyond Hibernate. With dynamic methods, you can query against properties of your object model classes (domain classes) via methods that you never have to write, like this:
  
  // Assuming you have a domain class called "Person"
  // with a name property and a type property that
  // can be "employee" or "customer"  

  def allPeople = Person.findAll() 
  def onlyEmployees = Person.findByType("employee") 
  def howManyEmployees = Person.countByType("employee")

  I didn’t have to write any of these find* or count* methods, they come free of charge with GORM which makes the simple queries a lot easier to manage.

• Auto-reloading: one thing that has always plagued us as Java developers is the development cycle of fix -> deploy -> start -> test. There are certainly ways to reduce this cycle in Java, but sometimes the project just doesn’t allow for it. Grails is built with the mindset that changes to most code assets should be reflected instantly in the running application, thus reducing the time it takes to test code changes
• TagLibs: Creating GSP (analogous to JSP) tag libraries requires much less code and no configuration to get your tags and and running
• Intellij IDEA Integration: I love TextMate as much as the next guy, but code completion and debugging are things I’ve just gotten too used to (call me lazy). The Groovy/Grails plugin for Intellij IDEA has come a long way towards making Grails a first class IDE citizen.
• Legacy Integration: A lot of the projects we work on involves an existing Java application and SQL database. There is often business logic already implemented in Java classes (Spring or otherwise) that really don’t need to be rewritten. Since, at the end of the day, Grails is Java, we can make use of the existing codebase in a way that is much more seamless than if we were to introduce another web technology. Also, the fact that it’s all Hibernate under the hood makes it easier to adapt a set of domain classes to an existing database schema. This makes Grails an easier sell on those technical re-architecture projects in the Java world.

Beyond the technology, there’s just a lot of momentum in the Grails community. Within the last year that I’ve been watching, Grails has gone from a 0.4 to just about 1.0 (I’ve been using PHP frameworks that haven’t bumped the minor version number in over 2 years). There’s a healthy and growing list of plugins (grails.org/Plugins) that seem to be addressing the core needs of new application development.  We’re really looking forward to the next Grails project and experiencing a lot more signal and a lot less noise.

]]> http://www.cantinaconsulting.com/2007/10/26/what-i-like-about-groovy-on-grails/feed/ 0 http://www.cantinaconsulting.com/2007/10/19/benvenuto/ http://www.cantinaconsulting.com/2007/10/19/benvenuto/#comments Thu, 18 Oct 2007 19:57:16 +0000 adam http://www.cantinaconsulting.com/?p=6 Greetings and salutations to all, and welcome to the very first blog post at Cantina.

First things are always first, and in the spirit of blogging as a new form of journalism (not http://en.wikipedia.org/wiki/New_Journalism) let’s get the main questions that any reporter would ask out of the way:

Who

We’re a new boutique internet technology shop specializing in whatever it takes to effectively produce web things (see About section).

What

What do we do? Well, sometimes it involes banging our heads against the wall, but at the end of the day we make great web sites and applications using best of breed practices and technologies (yes, you can read Web 2.0 in there).

When

We’ve been doing this for over 15+ years combined, but the blog starts today.

Why

We often ask ourselves that same question, but in the end, we love what we do!

How

Using some of these: agile methodologies, iterative design and development, rapid development frameworks and lots of testing.

In the process of doing what we do, we end up figuring some things out, and as part of the open source credo of “share what you know” (which sometimes comes in the form of “patch it if it’s broken”), we decided to start blogging about our little victories against buggy code. We hope that you find at least something that we’ve written here useful, and who knows, maybe someday we can do business together.

]]> http://www.cantinaconsulting.com/2007/10/19/benvenuto/feed/ 0