Link Details

who gives a sh!t what martin fowler thinks, that washed up old hack

Whoah...!!
Pretty strong statement!
I obviously - as most of the rest of the intelligent world's developers - insanely disagree...!
You're talking about the guy who *invented* (more or less) O/RM dude...!

Martin's work is fine, but he didn't "invent" object-relational mapping. He described some of the patterns around how to make it work, but that's a description of things people were doing for around a decade before.

mf is incredibly overrated
i mean, come on
all he did was take credit for other people's work and was very loud about it

yes, and no effort to actually tackle the issue - just insult Fowler.

Whether or not MF is the greatest thing since sliced bread, the issue of rules engines being overused is a reasonable point. It's not uncommon for unfettered developers coming up with fantastic database-driven rules engines that could be effectively written in about half as much code (and even less data). "Smart data, dumb code" I believe is the catch-cry - reasonable in its own right, but there has to be a balance.

Fowler comes down in favour of Business Readable DSLs, which I kind of agree with. A purpose-built "little language" as a subset of an application's implementation language is generally more extensible than building a rule interpreter using your own rules model. There's a little bit of that in Zed Shaw's 'The ACL is dead' monologue - in his case expressing access policies directly in Ruby was a lot cleaner and simpler than a whole bunch of ACL 'rules'.

I don't understand the fetish for rules engines. Well, I do actually - having originally programmed in Prolog and reimplemented (badly) something akin to predicate calculus in just about every language I've played with. Not knowing Erlang I find Frank Carver's comment about it being "largely a rules engine" is intriguing. Maybe it satisfies an innate need for us to be able to express parts of our coding solutions as a set of axioms - separate from expressing things declaratively, or as objects. This is where Prolog let me down, though I was lucky enough to use an environment that mixed Smalltalk and Prolog together.

Point is, rules engines impose their own grammar that is generally external to the language you are implementing in. And I'd rather try to debug "rules" written in the same language as the rest of the app than an arbitrary language built on top of an arbitrary interpreter, especially if the interpreter needs debugging itself.


,