Rails (etc) patterns
Arti is, in large part, a "pattern recognition network".
That is, it is a network (ie, a graph) of processing nodes
(implemented as ActiveRecord
Most of these nodes recognize and report on instances of patterns.
plugin keeps track
of managing these nodes and their results.
This leaves the Arti Project, however,
with the task of defining the recognition software.
The word "pattern
" is highly overloaded, particularly in computing circles.
For our purposes, a pattern defines a characterizing collection of attributes and/or relationships.
Ideally, this collection can be defined specifically enough
that instances can be mechanically recognized.
Many forms of information, including both "convention" and "configuration",
may be useful in this process.
Some of the patterns Arti recognizes are built into specific software,
including Ruby, Rails, Plugins, Databases, and other associated software.
Other patterns are more abstract,
having to do with stability of data,
strength and transitivity of relationships, etc.
Finally, many of the patterns are imprecise,
looking more like heuristics
and some of the resulting (meta)data
may seem more like informal tags
than formal types
Learning these patterns may help the user
to understand the application under study;
it will certainly help the user in using Arti effectively.
However, users are largely free to ignore these patterns, if desired;
Arti will do its job regardless of whether the user knows or cares how it does so.
"I believe no such thing, my good friend. ...
However, I am told that a horseshoe will bring you good luck
whether you believe in it or not! ..."
Niels Bohr, Horseshoe Logic
Will Code for Patterns
We are always
happy to hear of new patterns,
even if we aren't always able to implement them immediately
(or at all, unless we can figure out an implementation :-).
Curious programmers are welcome to peruse our HowTo
which serve as exploratory design documents.
The first (and most chancy) stage, however,
is recognizing that a pattern exists.
Once it has our attention,
we can try to figure out what it's good for,
how to recognize instances of it, etc.
So, if you think of an interesting or useful pattern
which the Arti Project doesn't support (or even know about),
please say so!
Ideally, you should first scan this section for a discussion
of the pattern.
Bear in mind, however,
that we may have thought of the pattern in a different way.
Alternatively, we may use different terminology than you do.
If you don't find anything,
it means that either or
(a) we didn't know about the pattern
(b) these pages need to be improved.
In either case, we'll be delighted to hear about it.
As noted above, most patterns have to do
with a particular type of software and ultimately,
a particular implementation of that type.
The following lists are a start at categorizing generic (aka "vanilla") patterns,
along with popular and/or interesting specific patterns.
Some patterns, however,
have to do with more general attributes of data, graphs, etc:
This wiki page is maintained by Rich Morin
an independent consultant specializing in software design, development, and documentation.
Please feel free to email
comments, inquiries, suggestions, etc!