Friday, 24 January 2014

CFML: where Railo is better than ColdFusion

I regularly find myself making comment about or mentioning in bug reports where Railo handles CFML functionality better than ColdFusion does. Railo undersells this stuff, so here's a list of points where Railo demonstrates itself to be better that Adobe at their own game.

The engineers are responsive

Just have a look at the posts on the Railo Google Group: those fellas Micha (Michael Offner) and Igal that regularly (and I mean multiple times daily) answer people's questions? They're the lead engineers from Railo. Now search the Adobe ColdFusion Forums for mention of Rupesh's name. Not a single post. Ever. Some first-line support dudes (who often don't know WTF they're talking about) answer occasionally. And some of the other ColdFusion team member participate once in a blue moon. But on the whole the Adobe ColdFusion Team do not help their community.

Railo is just easier to use

Ages back I wrote this "Comparing installations: CF10, Railo and OpenBD". To even install ColdFusion one needs an Adobe login (and you know where your password will end up...), perform a 347MB download (thanks to Andrew, Marcin & Richard for digging that info out for me), and an arcane install process which requires over a dozen steps. To install Railo, it's a 64MB download, unzip, run. This is a significant reduction in "barrier to entry" for people wanting to try CFML. Of course if one does want to "Try CFML", Abram's got a site for that: (and Russ has too). But this does not detract from the main point: Railo's easier to get hold of, and up and running.

Railo's faster than ColdFusion

Every time I have timed something on both engines, Railo is a lot faster than ColdFusion. If you want to improve your application's performance, possibly one of the easiest things to do is to switch engines (obviously fully regression test first, as there are some sideways-compatibility issues).

Railo's easier to manage than ColdFusion

Railo has both a per-website and per-server admin UI. This means in a shared hosting environment, one still gets access to an administrator UI, instead of having to contact customer support to get anything changed.

Railo fixes (and releases) bugs as soon as practical

Often when I raise a bug I find in Railo, Micha's got it fixed later the same day, and it's in the next release (which won't be two years hence, it'll be in the next few weeks). Check out the clarity of Railo's release history here: "Patch History". This means that if I have a bug, I get a fix for the version I'm on. I don't have to wait for two years, and I don't have to pay for an "upgrade" like I do with ColdFusion... basically Adobe charges us for them to fix their own bugs. Often these "bugs" are down to a half-arsed job being done in the first place (see the JSON point, below), so we're actually having to pay Adobe twice for some features: once to get the beta-quality version of it; once to get the production-ready version. There's bugs in everything, that's fine. But Adobe should shoulder the cost of making their stuff work, not expect us to pay for it.

Railo is open source

So Railo don't fix a bug you've found in a timely fashion? You can fix it yourself! See some weird behaviour in some CFML? you can look at the source code and see why things happen the way they do.

Railo can coherently serialise JSON

I dunno how many bugs I've raised with Adobe regarding the (de)serialisation process of JSON. They just can't get it right. They can't properly serialise numbers. They can't properly serialise strings. I'm not joking: do a search of the bugbase for "serializeJson" and see what I mean.

In every single situation I've had an issue on ColdFusion I have also tested it on Railo, and Railo just gets it right.

Railo has better OO

Railo has member functions on all its main data types. So instead of having to use procedural code like this:

numbers = [2];
arrayAppend(numbers, 3);
arrayPrepend(numbers, 1);
records = queryNew("");
queryAddColumn(records, "integer", numbers);

One can use OO code like this:

numbers = [2]

records = queryNew("")
records.addColumn("id", "integer", numbers)

Also note two other things here: dump() instead of writeDump(), and no semi-colons. Railo does not require semi-colons on the end of each statement.

In a trivial example like this, whether the code is procedural or OO is neither here nor there. But bear in mind that code like this will be amidst all yer other code, which is likely gonna be OO, so it makes more more readable and uniform code. And its not like if one wants to use the old-school procedural style one can't still do that. The first example - obviously - runs on both ColdFusion and Railo.

Railo doesn't pointlessly waste their engineers' time with inappropriate functionality.

Well I had to mention <cfclient> in this post somewhere, didn't I?

Railo is free

And it's not like when one observes that .Net is free too, but the cost to get an application to market is still cheaper in ColdFusion because the dev costs are lower. Railo's free, ColdFusion isn't. And the dev time is the same. Well it's quicker in Railo because they pay more attention to the developers' needs, so coding in Railo's dialect is faster than in ColdFusion's, and this is improving all the time.

Railo leads the way with innovation

There's a lot of good new features coming in ColdFusion 11, but a lot of them are Adobe playing catch-up with Railo.

Equally Railo are in a good position to see what Adobe have planned on their roadmap, and then consider if the features have merit. If they do, they can get them out the door a lot quicker than Adobe can.

Railo has financial backing from the CFML community

A few CFML shops that are concerned about the direction Adobe have taken ColdFusion have invested in Railo, so as to ensure it continues to do what it does. I have no idea how much input into the direction of Railo these companies have, but I do know they're enthusiastic CFML users. Contrast this to Adobe who only seem to maintain ColdFusion because they like the licence renewal money they get from enterprise / govt clients. Adobe definitely do not really care about ColdFusion beyond that.

Railo has 100% CFScript coverage

'nuff said.

Railo allows function expressions in tag-based code

This is something that let me down recently, in ColdFusion.

Railo didn't introduce function expressions in a half-arsed fashion in which one can only use them from CFScript. No. They can be used from tag code too (it has a coupla edge-case bugs, but they're minor, and Railo are on the case).

One can extend Railo one's self

Don't like the way a CFML tag or function is implemented? You can replace it with your own. Want to write your own CFML tags or functions, using CFML? You can do that too.

There's probably more (and I'm sure people will let me know). But, seriously... in an awful lot of important ways, Railo is just better than ColdFusion. I think this is worth pointing out.

Good work, Railo guys. Food for thought, Adobe guys?