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.

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.

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/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/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/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/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