When you want both Open Source and consistent results
Open Source doesn't sit and wait. More fun to just do something than to set up a repeatable, sharable system such as a language or a package or a framework or methodology.

Keel developers are intimately familiar with the chaos of Open Source, so we try to set up a system or framework to control the inevitable anarchy.

But any new attempt at control can produce its own negative pattern: Tail wags dog. A new system can create as many problems as the ones it solves. Rather than freeing us from the chaos, it just adds another layer.

What follows is a summary of Anti-Patterns we don't wish to repeat.

Keel solutions to anti-patterns attempt to hit a midpoint, between the chaos at one extreme, and the Tail Wags Dog pattern at the other..

Anti-Pattern: Tight Coupling

Tight coupling to objects
Tight coupling to vendors or contributors
Tight coupling to APIs, standard or not standard.

Tightly coupled code is like a damp box of broken peanut brittle - sticky, hard, glommed together, and tough to bite into, all at the same time. Maybe not as bad as procedural code, but the promise of OO isn't as great, once the code gets to be a big ball of mud.

Solution:
Keel addresses this by using the framework, a set of patterns and practices designed to keep software loosely coupled - and very functional.

Anti-Pattern: Not Integrated

Servers are for business, and that means you need lots of standard functionality integrated to work together. Problematical when everyone does it themselves in their own non-standard way. Most of us use the same 80% of functionality anyway. But when we do it individually, any two packages usually work fine, but each addititional package increases the challenge exponentially. This is definitely the wrong place to have the Not Invented Here disease.

Solution:
Following the pattern set in the terrific framework, Keel is a collection of packages already integrated to work with each other. You don't have to integrate the core collection of business server functionality, it is already there, and most importantly, working.

Anti-Pattern: RDBMS not taken seriously

If there was a dirty little secret to the IT world, it would be this: The relational database is the core of virtually every serious server application written. Yet it is typically dealt with as an afterthought. The abstraction layer is often inadequate or non-existant, and solutions are often hard coded to proprietary rather than generic databases.  Straight JDBC and ODBC are often used where an object relational layer would be much more powerful.

Solution:
Keel follows the Expresso pattern, and makes secured, generic, object relational layer the very core of its services. Just as importantly, Keel lets you switch between database vendors almost as easily as changing your clothes.

Anti-Pattern: Un-even Security

Security was a network specific problem, until the web came along. Now, everything needs it. But does everything have it? And in a universally useable way?