Frank Carver's Punch Barrel

I’m still collecting resources for a potential Sinatra/Redis project and this looks like a useful tutorial:

Building a Twitter Filter With Sinatra, Redis, and TweetStream @ DigitalHobbit.

I’m not really an eager version-watcher, but I do have a soft spot for the ruby web framework Sinatra. It’s nice to see that the Sinatra team are confident enough to give it a “1.0″.

Deceptive Simplicity: Sinatra Turns 1.0

I have been doing a lot of work with virtual machines recently. It’s a great way to sidestep machine-specific issues (Windows, I’m looking at you) and set up a consistent development/deployment environment.

However, downloading, installing, updating and setting up each new image has been increasingly tedious. Vagrant looks like a brilliant idea to enable automation of the whole process. I would try this out immediately, except that most of my Ruby development environments are already running inside a Virtualbox VM, and it’s not very likely that one will fit inside another

I originally chose to work in Ruby for its ease of deployment to low-cost shared hosting services, but as time has progressed I have become more comfortable with the language and a selection of tools and libraries. One that I like a lot is the Sinatra web framework. Interestingly it now appears that if I wanted, I could run Sinatra applications in a Java web container such as Tomcat, Resin, or Jetty using Warbler, which bundles JRuby and an application into a standard war file for drop-in deployment.

This is an interesting challenge to my own pure-Java Mojasef framework, which offers several similarities with the approach taken by Sinatra. Sinatra wins on documentation, though

A good guide to getting started with Sinatra and Warbler can be found at Sinatra on Java | Coreguardian.

I’m currently on my fourth or fifth project using the Sinatra web framework. Each project has taught me more about Sinatra, and Ruby, and all the other little things that go into making a web application using these tools. One thing which has been puzzling me, though, is how best to structure the directories and files which comprise each project.

I have been developing Java web applications for so long that I have a familiar and generally useful project structure which I can quickly build from memory. With these new tools I’m not so confident that I would not be storing up problems if I attempt to create my own structure.

So I was intrigued to encounter Monk recently. A system for generating project starting points for projects using a lot of the tools I have come to enjoy. It’s presumably aimed at the simplicity of starting a Rails project, but for a different set of tools.

On my Ubuntu system it was a bit tricky to get going. The documentation just recommends “sudo gem install monk” but this required some extra installations and some general fiddling around. Once installed it happily generated a project structure, which (after a few more installs) would run its tests using rake and start up a server serving “Hello, World” if asked.

I’ll give it a try on my next project, and see if it helps. I might even use the recommended No-SQL storage engine Redis instead of Sqlite or PStore which I have used in the past.

Read some more at » Monk – Quickstart Sinatra Projects Gittr.

Like many teams, I’m sure, we are trying to squeeze every drop of effectiveness out of our time. Manual build and deployment not only takes up valuable time, but also acts as a drag on the development process. Anything which pulls developers out of “the zone” is a bad thing for productivity.

We usually use the familiar “ant” build tool for building deployable artefacts, but have found it increasingly fiddly as our expectations have grown. And ant is hardly useful at all for real-world deployment tasks.

It may be the time to re-consider other build and deployment options.

Thread.current.to_s: Let’s use real languages for builds

Now this is an interesting result. It appears that even when running in a virtual machine, Linux can be a faster development system than the Windows the VM is running on!

Linux VirtualBox vs Windows for Rails Dev – James Crisp.

This looks very interesting, although it is at an early stage right now. A system for building and managing cloud-hosted applications, using XMPP as a communication subsystem.

InfoQ: Engine Yard Releases Cloud Management Framework Vertebra

A conference presentation from RubyFringe, designed to be contentious. There are some good points, particularly about the way that different approaches to testing can complement each other, but I think he misses the point about TDD when he lumps it in with developer unit testing and ignores the design aspects of the technique.

InfoQ: Testing is Overrated.

I’m a strong believer that manual steps should be automated wherever possible. One of the areas of our current product which seems to require an inordinate amount of manual “faffing” is provisioning and deployment.

Chef, a ruby system for distributing and automating just these kinds of tasks seems an interesting solution.

Home – Chef – Opscode Open Source Wiki.

It’s a long-running argument. Are modern, dynamic, languages such as Ruby and Python really much more concise than more mainstream languages such as Java? What constitutes “big” in each case? Stephan tries to flush out some hard facts, and gets a lot of comments.

Comparing Java and Python – is Java 10x more verbose than Python (LOC)? A modest empiric approach at Stephans Blog

I develop almost all my code these days using Test Driven Development (TDD). By taking this approach I never bother about unit test code coverage, but some developers seem very concerned by it.

One thing that I have never considered doing is retroactively adding tests just to increase some code-coverage metric. Dan Manges has written in interesting explanation of why that might be, using some examples in Ruby.

Dan Manges’s Blog – Increasing Code Coverage May Be Harmful

So the question is: are dynamic-typed languages (ruby, python, smalltalk, etc.) easier or harder to maintain than static-typed languages (Java, C#, etc.)? It seems there are arguments both ways.

On the one hand, dynamic languages tend to be a bit more concise, and reducing code size is a great way to simplify maintenance. On the other hand static languages typically support better and more intelligent tooling, which is also a great way to simplify maintenance.

Ola Bini has some thoughts, but has so far been unable to come up with any hard data one way or another. is there any?

The Maintenance myth | Ola Bini: Programming Language Synchronicity

A thoroughly enjoyable presentation from RubyFringe, one of the best I have ever watched.

It starts with a few minutes of demonstration of a reasonably cool music tool, but the real meat is in the presentation which follows – a fast paced, insightful and downright humorous rant about a wide range of topics from Leonardo daVinci to mountain lions, web applications and venture capital.

InfoQ: Archaeopteryx: A Ruby MIDI Generator

I guess this a bit old by now, but I hope they continue with this at least for the moment: a roundup of some of the interesting things going on in the Git world.

InfoQ: Git/Github Roundup: Ruby Books, Gems, Gitjour

My current work is centred around Java, and all our applications are deployed in java containers. It might one day be useful to deploy JRuby applications, and in particular rails apps, to these same containers. Here’s a list of things to beware of in such situations.

Antagonistic Pleiotropy

When I first saw this it looked great: a ruby REST wrapper which supports a lot of useful test and integration possibilities. However, the deeper I looked, the more disappointed I became. I’m now saddened to believe that this is based on yet another misunderstanding of what REST is.

As far as I can tell, the ActiveResource concept, on which this approach is based, is merely an attempt to impose a constrained CRUD data-model over HTTP. There is no concept of content negotiation – all data is XML according to pre-assumed schemas. There is no support for automatic discovery and use of hrefs between resources. There is even the suggestion that it’s a good idea to casually extend the HTTP protocol with extra custom methods.

All of these are typical problems found in projects which use the name REST without the key bits which make it really work. The end result is just another fragile, application-specific RPC protocol. Sigh.

nutrun » Blog Archive » Testing web services with ActiveResource

Even though this article uses the term “web 3.0″, it’s still worth reading. The idea of moving from specific “cloud computing” implementations to a more generic and pluggable approach is a neat idea. Using ruby as a scripting language for “agents” and Erlang for the infrastructure seems a good balance, too.

InfoQ: Vertebra: EngineYard’s Next Generation Cloud Computing Platform

Although I don’t do much with Erlang or Ruby at the moment, I really like the approach taken in this article of connecting applications using the Jabber protocol. It looks as if it really has a lot to offer as a messaging infrastructure, a potentially key component as yet unexplored for “rosebud”.

nutrun » Blog Archive » Distributed programming with Jabber and EventMachine