We’ll have a room with a projector dedicated to lightning talks and the rest of the space will be free for mingling and socializing. There will be beer and food. Doors open at 5:30 and we’ll stick around until 7ish; if people are still hanging out we’ll migrate elsewhere for more drinks. Carbon Five is located at 171 2nd Street Floor 4 (map), above the Tempura House.

Lightning talk topics on the docket thusfar:

• Alon will demo C5 Story Mapper
• Corey will discuss http-pulse, a node.js application for monitoring http
• Alex will discuss Wrong – a minimal assertion library for Ruby
• Christian discusses the outcome of a recent MongoDB development spike
• Jon discusses the Mission Artists United website
• Jonah will discuss an iPhone widget he built over the weekend at the iphone deve camp

Please RSVP below if you’re coming.

See you Thursday!

For example Embracing NoSQL – Your First Cassandra Project is an extension of the talk Mike gave at the Los Angeles NoSQL meetup a couple of months ago. The ultimate goal of the session is to NOT just “digg” (pardon the pun) into why many real-time social sites have started using Cassandra and other non-traditional storage systems, but to have you walking out with code to bootstrap your own projects with.

Similarly, in Get Your Act Together: Build Better iPhone Apps, Jonah plans on demonstrating the agile iOS development patterns he’s been documenting here on our blog. You’ll learn how you can continue to rapidly deliver (and have Apple approve) builds of your app while meeting the higher quality expectations of the maturing app marketspace.

Finally, Alon is bringing to Austin the quite literally interactive session of Play at Work: Agile Games for Productive Teams, which he presented earlier this year in San Francisco. By having you actually play through games we use every day such as “Planning Poker”, you’ll get a much better sense of how they can be incorporated into your own agile development efforts than any simple presentation could provide.

Of course, we don’t just want to talk about our experiences, but want to hear about yours too, either at the sessions or over a drink later that day! So if you’re interested, please click the links above and vote for our panels, as your voice is an important factor in SXSW’s panel selection process.

And if you see any of us at Austin next year or sooner, don’t hesitate to say “Hi”; we’ll take you up on those drinks!

Running unit tests with GTM
I have been using GTM to run iPhone unit tests as part of the build process for a “Unit Tests” build target (see Alon’s post on our iPhone Unit Testing Toolkit). Running these tests with a TeamCity build agent just requires a command line build runner which calls the `xcodebuild` command and specifies the project, built target, and configuration to build.

Ad-hoc builds
Ad-hoc builds run with a similar command:

Now my ad-hoc builds are produced automatically, always up to date with my working code changes, and available as an easy download from my TeamCity server. TeamCity will also save the artifacts for each build so I can easily retrieve the dSYM for a particular ad-hoc build to symbolicate a crashlog for that build on any developer’s machine.

Future improvements
If necessary I can run tests on actual iPhone hardware by changing the sdk (`-sdk iphoneos4.0`) but I am not yet sure how I could specify which one of multiple devices would run the tests. It would be nice to eventually be able to choose between multiple devices so I can deliberately run some tests on a device with a specific OS version or feature set.
With my current configuration TeamCity can only report a pass/fail status for iPhone tests. I need to consider modifying the GTM test runner script or switching to GHUnit or Cedar to get per-test results and then be able to build up a history of individual test failures.
I also need to add a build configuration which uses agvtool to automatically increment the project’s build number as part of every ad-hoc build.

Much like shared github access I need to be able to specify which ssh key a particular project’s connections to heroku should use. Since I want to use client side checkouts I can’t specify a private key within TeamCity but I do know that all my compatible build agents are local so I can add a new entry to `~/.ssh/config` and define a host which will allow me to connect to Heroku with a particular key.

# Heroku for #{new_project}
Host heroku-#{new_project}
HostName heroku.com
User git
ForwardAgent yes
IdentityFile /home/teamcity/.ssh/teamcity_#{new_project}_rsa


Add a ssh key to the Heroku account
Now I need to add this new key to the Heroku account for this project by installing the heroku gem in my project’s gemset and using the `heroku` command line to add the key. Heroku stores the account credentials used in `~/.heroku` and the user account running my build agents might need to connect to many different heroku accounts. I could switch my heroku credentials, upload a key, and have different projects deploy using different accounts. However since I find it useful to be able to run the heroku command line (see below) I found it preferable to have a single `teamcity` heroku account added to every project as a collaborator.
If you find it necessary to switch between Heroku accounts frequently this tool from Aeonscope might be useful: managing multiple heroku accounts

Now I can add a key to the current project’s Heroku account.
heroku keys:add ~/.ssh/teamcity_#{new_project}_rsa

Deploying to Heroku
Now I can add a simple TeamCity build configuration which pushes code to Heroku once a particular revision passes the tests.

A project's deployment build configuration

I found that I need to add a delay between turning on maintenance mode for the app and pushing to heroku. Attempting to push immediately fails with the error `Heroku push rejected, your slug is currently being compiled. Please try again later.` Even with a significant delay I still see this error occasionally and have to rerun the deploy build but at this point I don’t know of a way to make sure heroku can handle a new revision before attempting to push changes.

Now I can use TeamCity to automatically deploy changes to Heroku as soon as my project’s tests pass.

1. Create a key for github access
> ssh-keygen -t rsa -C "#{project_name}"
Upload the public key to github as a deploy key for the project so that the build agent can pull from the github repository.

2. Setup rvm and a gemset for the project
> rvm install ruby-#{version}-r#{patch level}
> rvm use ruby-#{version}-r#{patch level}
> rvm gemset create #{project name}
> rvm gemset use #{project name}
> gem install bundler

This could probably all be automated as part of the project’s .rvmrc file.

3. Setup a ssh config for the project
The keys used by many of the services we interact with are unique and tied to an account so we need to have TeamCity use different ssh keys when connecting to projects under different accounts. Add a new entry to ~/.ssh/config to alias a host to use a specific ssh key

# GitHub for #{new_project}
Host github-#{new_project}
HostName github.com
User git
ForwardAgent yes
IdentityFile /home/teamcity/.ssh/teamcity_#{new_project}_rsa


Connections to `github-#{new_project}` will now default to use `teamcity_#{new_project}_rsa` rather than the default `id_rsa`. By specifying the key in the ssh config file we’re able to use client side checkouts which will be useful when deploying using git. For projects able to use server side checkouts we can specify a private key to use in TeamCity’s VCS settings.

4. Create a new TeamCity project
On projects with multiple build steps using the same build runner we could create a template to avoid repeating these settings in each build phase. Unfortunately TeamCity 5.1 templates do not support running multiple types of build runners so projects with both command line (`bundle install`) and rake runners (`rake spec`) require some repetition.

Client checkouts have a full git repository while a server side checkout performs a git pull and then copies the resulting files but not the full git work-tree to the build agents leaving the agents unable to easily run git commands. A client side checkout is therefore preferable when using `git push` to deploy a project.

If using a template set the `rake.tasks`, `rake.opts`, and any other configuration parameters the template uses. Each build configuration based on the template can specify its own configuration parameters but cannot override the rake task and command line parameters directly.

To use the project’s RVM ruby and gemset add the following environment variables with appropriate paths:

Now I can finally build a set of build configurations for a project which will all use the project’s RVM settings to isolate it from other projects on the TeamCity server.

JetBrains appears committed to adding RVM support to TeamCity and added the `RVM Gemset` property to rake tasks in TeamCity 5.1.3 so hopefully we’ll see additional RVM support in future releases.

Agile software development provides a number of discrete practices to help you be a better programmer and a great provider of programming services to your clients, internal or external to your business. The continuous daily rigor of testing, refactoring, pairing and integrating is a great path to producing quality software. The process of defining short development iterations with regular delivery and review with your client encourages collaboration and ensures that you are defining and meeting expectations along the way. We’ll describe the agile development and planning practices that we have found to be most effective in our work over the last 10 years and hope to hear from the group what is working for you.

The event is full, but there’s a waiting list… go ahead and sign up if you’d like to join us. Hope to see you there!

Updated! Slides…

The Applications

• Snowballs

  Snowballs is a video game that was mostly designed by my 7 year old daughter, Ada. She started with a drawing that contained a maze filled with dots, a player and some monsters, and she explained how you throw snowballs at the monsters and build walls to block them. I convinced her we could get roughly the same effect by freezing the monsters instead of blocking them, and then I began developing. We started iterating, and she continued to contribute ideas which, somewhat surprisingly, always made the game more fun. The arrow keys move the player, and the spacebar launches a snowball. It’s implemented as a single Canvas tag using a JavaScript interval as a run loop. The maze, players, monsters, and snowballs are all drawn with JS functions using the Canvas drawing API. Since this application uses the Canvas tag, it won’t run in Internet Explorer or older versions of other browsers.

• Flashcards

  I wrote Flashcards one evening when Ada’s teacher suggested using flash cards to help her memorize the words she shouldn’t need to sound out. The idea is that the parent clicks the spacebar when the child reads the word and they work together to reduce the time needed to read all the words. The application doesn’t need any graphics (other than some external images at the end), so it doesn’t use any HTML 5 features (browser compatibility is unknown).

• Timetest

  Like Flashcards, I wrote Timetest to help Ada with her schoolwork. In this case, she was getting frustrated with a lesson on analog clocks, so I wrote this application to make it more of a game. The goal is to answer as many questions as possible in the given time. The test turned out to be more difficult than it really needed to be, so I created an easier version (accessed by adding #easy to the URL). Since this application uses the Canvas tag, it won’t run in Internet Explorer or older versions of other browsers.

• Arithmetic

  Arithmetic is another educational application designed to drill addition that uses carrying. It provides spaces at the top, which you can click to mark a carry from the previous column. It doesn’t have any fancy HTML 5 features, but it does have a lot of stats.

• Surround

  My wife and I had designed a fireplace surround and mantel for our living room, but when it came to actually buying the materials and building the thing, we realized we didn’t know exactly how to scale it. Since the design was entirely composed of rectangles, I realized it would be possible to build a simple one-off CAD program to help us agree on some dimensions. The application makes use of the Canvas tag and the new HTML 5 slider inputs (which aren’t currently supported in Firefox). It translates between pixels and feet/inches constrained to an 8th of an inch, in order to make the measurements easier to use in the shop.

The goal of these exercises was to produce something simple and quick, but not entirely without polish. All the applications except Snowballs took only an evening or two. Each application (also excluding Snowballs) ended up under 300 lines of HTML, CSS, and JS combined.

Developing without a JavaScript framework

Limiting the applications to a single page means no importing jQuery or Prototype. This might seem like a big constraint in an application written entirely in JavaScript. But these frameworks really only help out with DOM traversal/manipulation, event handling, animation, Ajax, form validation. All the applications make do with a small amount of HTML, so it’s easy enough to grab elements by ID, and a few visits to Quirksmode gave me some reasonably cross-browser event-handling code. Animation isn’t really that hard in JS, and I needed it to be more custom than frameworks allow anyway. The rest I didn’t need. The truth is, I never miss having a framework (though I’m not about to stop using jQuery when working on client’s sites).

Advantages and disadvantages

• They’re quick to start. Since it’s a single page, there’s no setup and no integration.
• They’re easy to deploy. It’s only one relatively small file, so you can e-mail it to friends, and you can host it anywhere. If you want to spend a little time making it touch-screen compatible, you can get it on all the smarter smart phones without bothering with app stores. On the other hand, there is no way prevent people from stealing the application or the code if you were developing it commercially, since the source is always just a right-click away.
• HTML+CSS is a powerful display framework. Although it lacks built-in support for some of the fancier UI widgets, there is no GUI framework that I’m aware of (and I’ve developed with quite a few) that provides the same level of design control with the same ease of development as these technologies. Of course, I’ve been swimming in HTML/CSS for years, so this opinion is a bit biased.
• Canvas has a powerful vector graphics API. I had done a fair amount of Cocoa programming prior to these projects, so this didn’t come as a surprise. The real power of Canvas lies in its transformation functions. I’d like to find an application for some more advanced spline generation. The downside is that Canvas and HTML don’t really mix, so you can have great text layout in HTML and sophisticated text animations in Canvas, but not both at the same time.
• JavaScript is a capable if not optimal language. No one is going to make the case that JavaScript is the greatest language ever designed, but what it lacks in performance and language features, it partially makes up in powerful fundamentals and simplicity. JavaScript is neither a great functional language nor a great object-oriented one, but it is sufficiently powerful to develop in either of these paradigms. Snowballs, for example, acts a lot like a simulation and benefited from stateful objects. The other applications required less state and I found several uses for higher-order functions, though I wouldn’t consider any of them properly functional.
• Single-page applications are fun. These exercises have reminded me that, once the responsibilities of software engineering are stripped away, there is a joy to be found in coding for coding’s sake.

All of these applications are available on GitHub, but it’s probably easier to right-click on the page and choose view source.

Check out our jobs page (http://www.carbonfive.com/jobs) for additional detail.

The frame of a view is given in the coordinates of its superview so a view controller’s view’s frame will include offsets for the status bar, navigation bar, or tab bar. The bounds of a view are given in the view’s own coordinate system which does not include these elements.

In addition the frame property’s values are undefined if the view has any transform other than the identity transform. Rotating a view into landscape mode applies a transform to the view so it is not safe to rely on frame values for an app in landscape mode.

When a transform is applied to a view it does not apply to any subviews. A UIViewController or custom UIView subclass is therefore free to adjust the frames of its subviews to reposition them regardless of the device’s orientation. For example a UIView class can change the frames of its subviews within its layoutSubviews method no matter what transform might have been applied to the parent view.
Each view’s frame will position it relative to its parent view so an origin of (0, 0) will always place a subview in the top left corner of its parent view.

See the images below for examples

This view controller's view has a frame of (x:0.00 y:20.00 width:320.00 height:460.00) and bounds of (x:0.00 y:0.00 width:320.00 height:460.00). Its subviews are positioned relative to their parent views and not relative to the overall window.

This view controller's view has been transformed and its frame is therefore undefined and should not be used. Its bounds are (x:0.00 y:0.00 width:480.00 height:300.00). Its subviews have not been transformed so their frames can be used to position them relative to their parent views.

I just discovered a neat hack in Douglas Crockford‘s popular json2 parser/serializer which obviates the need for any server side support. So simple, yet so effective. Check out the first line of  http://www.json.org/json2.js:

  alert('IMPORTANT: Remove this line from json2.js before deployment.');

Neat, eh?

We’ve got a good range of perspective and experience to draw from. Maria Giudice from Hot Studio is our user-centered designer, Rob Spiro from Aardvark is our user-centered product entrepreneur, Darren David from Stimulant is our multi-touch and NUI innovator, and I am our Agile software developer.

This event seems to have really caught on to the growing energy in the entrepreneurial community around strategies and techniques for creating products that people really want. Eric Ries is giving the keynote on Tuesday just one year after his first big conference presentation at Web 2.0 2009 and Steve Blank is giving the keynote Thursday. Both of these guys and the growing community around them have been inspiration to me and our work at Carbon Five over the last year for the answers they provide about how software development serves the goal of creating successful businesses and products.

Event Page

Networking (and pizza) starts at 6:30 and we’ll get down to business at 7:00. The night starts with a short talk about Agile Java by Bjorn Freeman-Benson, of New Relic fame.

If you’re still doing Java and you’re curious about Spring MVC, come join in the fun.

Our goal is to give attendees a taste of some of the novel activities we use to encourage collaboration, communication and fun while engaged in the messy business of creating web software. The session is intended to be interactive – we want attendees to try some of this out with us – which should be interesting given that the conference organizers chose to put us in the Grand Ballroom, the same room used for the conference keynotes. “Gather around, everyone!”

Resources

Here are some follow up resources for attendees who are intrigued and want to learn more.

Effective User Stories for Agile Requirements
http://www.mountaingoatsoftware.com/presentations/52-effective-user-stories-for-agile-requirements
This series of slides by Mike Cohn is a good introduction to user stories as a means of capturing project requirements. We often use this presentation to introduce folks new to agile to the ins and outs of user stories.

Agile Estimating and Planning
http://www.mountaingoatsoftware.com/books/1-agile-estimating-and-planning
This book by Mike Cohn is an excellent guide to the planning side of agile software development and what you do with those user stories.

Art of Agile
http://www.amazon.com/Art-Agile-Development-James-Shore/dp/0596527675
This book by James Shore covers the breadth of agile practices, both in planning and development, and includes many activities like those we cover in this session for helping your team collaborate and communicate effectively and efficiency.

Tasty Cupcakes
http://blog.tastycupcakes.com
Tasty Cupcakes is collection of games and activities designed to help illustrate the value and effectiveness of different agile practices. Rather than being specific techniques used in running an agile project, they are more targeted at teaching agile practices and values with short illustrative games.

The Manifesto for Agile Software Development
http://agilemanifesto.org
This is a historic document (2001) in the Agile software movement where a group of folks advocating new values and practices in software development came together to recognize their shared goals and values.

We are uncovering better ways of developing
software by doing it and helping others do it.
Through this work we have come to value:

Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan

That is, while there is value in the items on
the right, we value the items on the left more.

First, in order to do this, you need to embed your video using the swfobject javascript library. Next, you have to create a div that has an id (swfobject requires you to pass an id string for its initialization) – this div will be replaced by swfobject with a video object. The convention we’re using is to use an id of video-XXX, where XXX is the id of the video in vimeo‘s system. Finally, the div needs to be given a size (using CSS) so that the embedded video will end up being the correct size.

The code is structured as a jQuery plugin, so of course you will need jQuery. However, there is not a strong dependency on jQuery so with a little restructuring, I’m sure the jQuery dependency could be dropped.

Here it is:

2. Install dependencies

sudo yum install gcc
sudo yum install gcc-c++
sudo yum install zlib-devel
sudo yum install openssl-devel
sudo yum install readline-devel
sudo yum install sqlite3-devel


3. Build ruby from source

cd ruby-1.8.7
./configure --with-openssl-dir=/usr/lib64/openssl
make
sudo make install


4. Download rubygems source

wget http://rubyforge.org/frs/download.php/69365/rubygems-1.3.6.tgz
tar -zxvf rubygems-1.3.6.tgz
cd rubygems-1.3.6
sudo ruby setup.rb


5. Install gems

sudo gem install rake
sudo gem install rails
sudo gem install sqlite3-ruby (optional)


We use Pivotal Tracker to manage our feature backlog and the day-to-day activities of tracking a feature from estimation through delivery and acceptance. However, we find it easy to lose the big picture in the detail-oriented view Tracker provides.

Story Mapper uses your project data from Tracker to provide a higher level view geared toward release and milestone planning. This view is based on Jeff Patton’s story mapping techniques and provides the ability to see how the different components of your project will evolve across successive milestone.

All you need in order to use Story Mapper is a Tracker project with a backlog of stories and a subset of labels that represent user activities or components of your system. If you have a large project and have not been using labels in this way, you may have some work to do in Story Mapper before you have a story map that makes sense.

Try it out, let us know what you think, and tell us how to make it better. Comment here so others can see your thoughts or by contacting us directly.

I was telling Ada how video games are made one night, and she ask me if I could make a game. I said yes, we could make one together, and she bugged me all night to get started. I told her to start by designing a game on paper. She drew something that looks surprisingly like pacman (given that she’s never played the game), but she told me the dots were snowballs and that you could throw them at the monsters and use them to build walls. I started programming it as an SPA using canvas. She came up with all the rules, with some suggestions from me.

It may be that I’ve just been doing a lot of JS lately, but building a game like this in JavaScript felt really comfortable and extremely rapid. I had a basic version working with about 200 lines of code, but the details have tripled that. I went through a couple of major refactors, neither of which were troublesome in textmate.

The game is completely un-optimized, but it runs fast enough on my macbook. I know lots of ways to speed it up if I had to. It’s a little rough in a lot of areas, but it’s getting close enough to present.

Play Snowballs

Instructions

Load in Firefox or Safari. The arrow keys move your character, the spacebar launches snowballs (which you have to collect). Hit a monster 5 times to freeze it, then touch it to collect it.

- (void) testViewBinding {
	TestableSimpleViewController *viewController = [[TestableSimpleViewController alloc] initWithNibName:@"TestableSimpleViewController" bundle:nil];
	[viewController loadView]; //It is not strictly necessary to call loadView for this test as we access the view property which will call loadView if view is nil
	assertThat(viewController.view, isNot(nilValue()));
	assertThat(viewController.button, isNot(nilValue()));
}
 
- (void) testUIButtonActionBinding {
	TestableSimpleViewController *viewController = [[TestableSimpleViewController alloc] initWithNibName:@"TestableSimpleViewController" bundle:nil];
	[viewController loadView]; //Here we must call loadView since we have not accessed the controller's view property to trigger view loading from the nib
	assertThat([viewController.button actionsForTarget:viewController forControlEvent:UIControlEventTouchUpInside], onlyContains(@"testAction", nil));
}

Testing View Reloading
View controllers should be able to unload their views if the application receives a memory warning while the view is not visible and then reload the view when it is needed again. We can reproduce that same sequence of messages in a test. For a non-trivial controller we would add additional assertions to test that any other view dependent properties were correctly released and recreated as the view was unloaded and reloaded.

- (void) testViewUnloading {
	TestableSimpleViewController *viewController = [[TestableSimpleViewController alloc] initWithNibName:@"TestableSimpleViewController" bundle:nil];
	[viewController loadView];
	assertThat(viewController.view, isNot(nilValue()));
	[viewController didReceiveMemoryWarning];
	assertThat(viewController.button, is(nilValue())); //Note that while viewController.view is nil here we cannot test that directly as accessing view will trigger a call to loadView. Instead we can only test that our outlets have been released as expected.
	[viewController loadView];
	assertThat(viewController.view, isNot(nilValue()));
}

Testing Switching Between View Controllers
View controllers frequently have dependencies on other view controllers. If those dependencies are tightly coupled it becomes very difficult to test the behavior of a single view controller. Instead we can expose those dependencies and replace them with mock objects in order to isolate the controller we are currently testing. Here we have a simple table view controller which presents a detail view controller when a table cell is selected. By mocking both the navigation controller used to present that detail view and the detail view itself we can capture and verify the table view controller’s behavior.

- (void) testSelectingACellPushesADetailView {
	id detailViewController = [OCMockObject niceMockForClass:[GenericDetailViewController class]];
	NSDictionary *data = [[NSDictionary alloc] init];
	UINavigationController *navController = [[UINavigationController alloc] init];
	id navigationController = [OCMockObject partialMockForObject:navController];
 
	TestableTableViewController *viewController = [[TestableTableViewController alloc] initWithNibName:@"TestableTableViewController" bundle:nil];
	viewController.detailViewController = detailViewController;
	viewController.modelData = data;
 
	[navigationController pushViewController:viewController animated:NO];
	assertThat(viewController.navigationController, isNot(nilValue()));
 
	[viewController loadView];
	[[detailViewController expect] setModelData:data]; //expect that the detail view will be given some data to display
	[[navigationController expect] pushViewController:detailViewController animated:YES]; //expect that the detail view will be pushed onto the nave controller
	[viewController tableView:viewController.tableView didSelectRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
	[detailViewController verify];
	[navigationController verify];
}

So what makes test-driven controllers different?
I certainly could have written these example controllers without any tests around them. However by writing tests I was encouraged to make a couple of changes to the way I structure my code.

• My controllers expose dependencies that might otherwise remain buried in their implementations. In the example above I exposed the detail view controller my controller used so that I could replace it with a mock object. That made it possible to test that the expected data was passed to the detail view but it will also make it easy to switch to a different detail view controller in the future.
• By focusing on testing just one class at a time I am encouraged to create well defined interfaces and a clear set of responsibilities for each class. That in turn leads to more modular code which is easier to maintain and reuse.
• I write bugs but if I write a test to reproduce them and then prove that they are fixed I shouldn’t ever see the same bug twice. It is much easier to catch a missing nib binding because a test failed than it is to see the app crash when displaying some view and have to track down that exc_bad_access error in the debugger.
• Most importantly by writing tests I can have confidence that my code works as I expected, not only when I first write it but also every time I run my tests (which happens every time I build the app). With that feedback I can change one controller without fearing that I might have broken something somewhere else in the app.

For those of you who caught it last week at the SDForum, here are the links people requested:

• Maven plugin for Javascript Unit Testing with Rhino/ScrewUnit (from C5)
• The current code for the “wizardize” example we walked through.
• Blue Ridge (Rails integration tool)
• ScrewUnit
• JResig’s Presentation on JS Testing
• The slides we used

To sign up for next Wednesday, go to the EBig site.

I’m looking forward to participating in a panel Is Canvas the End of Flash? this month at SXSW on the role the new HTML Canvas element is playing in web development and how it compares to Flash. Much of the perspective I have for this panel comes from my long history working with Flash and from our recent work with Canvas for Isilon Systems on InsightIQ.

The panel has been organized by Greg Veen of SmallBatch, Inc., creators of TypeKit and includes Chet Haas from the Adobe Flex team, Nathan Germick from social gaming start up Wonderhill and Ben Galbraith from Palm and Mozilla, also lead of the ambitious Bespin project.

Come check us out if you’re going to be in Austin.

Also check out some of the presentations by friends of Carbon Five at SXSW:

From Dinosaurs to Digital: A Museum Convergence Success Story from Maria Giudice of Hot Studio on her work with Jonathon Denholtz of the California Academy of Sciences.

Social Search: A Little Help From My Friends a panel on social search organized by Brynn Evans that includes CEO Max Ventilla from our recently acquired client Aardvark.

Beyond the Desktop: Embracing New Interaction Paradigms a panel on interactions that go beyond keyboard+mouse includes Nathan Moody of Stimulant, masters of the multitouch Microsoft Surface and NUI design.

The teaser for it… Recent evolutions in JavaScript testing frameworks now allow creating test suites, test-driving development, and running tests on a continuous integration server. This allows us to support more complex JavaScript, have confidence in the implementation, and push more of the logic from the server into the browser, reducing the load on the server…

Hope to see you there.

<plugin>
    <executions>
        <execution>
            <goals><goal>javascript-test</goal></goals>
        </execution>
    </executions>
    <groupId>com.carbonfive.javascript-test</groupId>
    <artifactId>javascript-test-maven-plugin</artifactId>
    <version>1.0-beta1</version>
    <configuration>
        <includes>
            <include>src/test/javascript/suite*.html</include>
        </includes>
    </configuration>
</plugin>

You will probably also need to add Carbon Five’s public repository so that maven will know where to grab the plugin:

<pluginRepositories>
    <pluginRepository>
        <id>c5-public-repository</id>
        <name>Carbon Five Public Repository</name>
        <url>http://mvn.carbonfive.com/public</url>
    </pluginRepository>
</pluginRepositories>

The <configuration> section contains standard maven <include> and <exclude> tags to allow you to specify any Screw.Unit test suite html files you would like to include in your build.

Now when maven executes its test phase, it will include your javascript tests as well. Any test that fails will halt the build. When the test phase is complete the target directory will contain a ‘screw-unit’ directory that contains the test reports. There will be two files for every file included in the test execution The first is an XML file named TEST-dir1.dir2.dir3.filename.html.xml that contains the test results for that file in a reasonable approximation of JUnit’s xml format. The other file will be named dir1.dir2.dir3.filename.html and will contain a sort of snapshot of the test suite’s html at the time the tests completed (the javascript will be removed and the css will be baked in).

Like Blue Ridge, the javascript-test-maven-plugin relies on the excellent env.js project and the less-excellent Rhino project to emulate a browser in Java. Unfortunately this combination creates the possibility of discrepancies between the browser and build results, and the probability of relatively slow test execution. To keep the simulation as realistic as possible, javascript-test-maven-plugin recreates the test environment for each Screw.Unit html file, so the more tests you can cram into a single file the faster your builds will run.

There are a few directions for future work. I’d like for the plugin to handle other browser-based javascript testing frameworks. Screw.Unit is popular, but seems suboptimal in many respects. The only limiting factor here is the plugin’s ability to interpret the results. If env.js could run in javascript interpreters other than Rhino, I’d like to give the the plugin the capability to fork out to spidermonkey for better compatibility and performance. Modifying the plugin would be relatively easy, but env.js appears to have some significant dependencies on Java.

Check it out if you have a need for this kind of thing and let us know if you have any problems or suggestions.

Among other initiatives, Carbon Five worked with DNA Direct to roll out their first release of, as founder and CEO Ryan Phelan describes it, “the first genetic guidance program for a top five health plan with Humana, facilitating prior authorization and providing clinical services to ensure appropriate testing with lower out of pocket costs from the right lab.”

I’ve been eyeing solid state disks for the last year or so, speculating that they could have a huge impact on developer productivity once all of the major gotchas were worked out. I specifically though that pairing a decent laptop with an SSD would be awesome, since laptops generally have significantly slower hard disks than workstations. They’re also a bit slower across the board (cpu, memory bus, etc), so I thought the IO boost from an SSD might even things out.

In December I decided to end the speculation, so I bought an 80G Intel x25m (Gen 2) SSD for my 15″ Unibody MacBook Pro.

As it turns out, the SSD is faster than the 7200 RPM disk that was in my laptop by every measure. Though, for most of the day-to-day tasks that I benchmarked, it wasn’t that much faster. For my Java and Rails projects, building (Java only of course) and running test suites ran between 5-25% faster. Deploying Java apps was about 5-10% faster. Reindexing a whole project in IntelliJ IDEA was about 40% faster. These are real improvements, but they’re not the knock-your-socks off speed improvements I thought I might get.

There are some benchmarks that were way-way-way faster. Running migrations on a database: super fast. I just don’t do those things that often. When you read about SSD performance, you see charts that make them seem 10-20 times faster. They are in some cases, just not for most of my regular usage patterns.

I learned that the real benefit wasn’t really speedier builds or faster tests. An SSD simply makes the machine zippy all the time. Applications launch as fast as they do once they’re already cached by the operating system, even when they’re not. In fact, the difference between a warm and cold start for all apps is nearly gone. Spotlight is essentially instantaneous. Opening new windows, web browsing, pulling up preferences, switching between apps… it’s all snappier. Even when you think it shouldn’t be — because the data has to already be in memory — it feels just a tiny bit faster.

You know that feeling when there are two apps vying for the disk at the same time? Everything just slllooooowwwws down as the drive hops from one section of the disk to another, multiple times each second as it fetches disparate data. Yeah, that doesn’t happen anymore. Heavy disk IO and multitasking aren’t a drag. For example, I don’t notice when Time Machine is running anymore because it doesn’t effect my work at all, even when I’ve got a number of my own disk heavy tasks going.

Sounds awesome, right? Well, where prices are now you’re paying about 20 times more per storage unit than normal drives. That’s way better than the 50x from 18 months ago, but it’s still a lot more.

Is it worth it? Since I could get away with buying an 80G model (~$260), I totally think it’s worth it. If I needed a bigger drive than I wouldn’t have been able to bite the bullet in principle ($500 for a 160G drive is crazy). Luckily, it will become an easier decision later this year when the 3rd generation drives hit the market. They’ll been even faster, offer more capacity, and come with a slightly more reasonable price tag.

If you’re thinking about it, get educated because there are drives that are good (Intel x25m) and many others that are not. AnandTech is a great resource for benchmarks and all kinds of information related to SSDs. While most of the major gotchas have been worked out, it’s a good idea to make sure your hardware, operating system, and future SSD will be friendly.

In the end, I’m not getting tons more stuff done than before, but it’s certainly more fun to code when things are always snappy.
Christian

PS: You can check out my limited development-centric benchmarks here.