Laughing Meme » patterns

Yuiblog: Patterns for Designing a Reputation System

Kellan — Wed, 11 Jun 2008 15:07:50 +0000

Excellent, pragmatic, Christopher Alexander style patterns for building online community. With really cute graphic.

http://yuiblog.com/blog/2008/06/10/patterns-for-designing-a-reputation-system/

r0ml.net: History teaches us …

Kellan — Mon, 10 Sep 2007 15:19:49 +0000

r0ml explores the secret Catholic bias present in Java enterprise development. (in case the hair shirts weren’t a dead giveaway)

http://r0ml.net/blog/2007/09/08/history-teaches-us

Shirky: A Pattern Language for Moderation Strategies

Kellan — Thu, 09 Mar 2006 17:16:00 +0000

I love pattern languages, and this is an excellent start. E.g. main problems with community can be addressed by MakeIdentityValuable

http://social.itp.nyu.edu/shirky/wiki/

Fowler adds “rought cut” patterns on event collaboration and accounting to PoEAA

Kellan — Thu, 26 Jan 2006 19:31:00 +0000

See also Pattern Oriented Softare Arch., vol 2 for good enterprise event patterns

http://martinfowler.com/eaaDev/

Session “Flash” in PHP

Kellan — Thu, 08 Dec 2005 07:03:00 +0000

Doing some PHP hacking tonight, I was missing Rails’ “flash”. So I coded up a quick and dirty implementation of the read-once session status notification pattern. The code

As Seen in the Inbox

Kellan — Wed, 30 Nov 2005 23:40:00 +0000

my eastern reversible destiny; ebullient barnacle turkey y propitious zeiss novice, coverlet upsilon mausoleum remiss optoelectronic emblematic irritant sesame morphology. ambrosia shim grunt switchblade filigree gait amino caleb duration budge embargoes allied

Random gibberish, and yet 100,000 years of pattern matching expertise refuses to let it go that easily, finding primordial poetry, and humor.

Has anyone wondered what the extreme, cut throat Darwinian pressure of the spam wars might be evolving?

And what kind of AI could such a crucible produce I wonder? Vicious and deceptive? Slippery, polymorphic and rentless? Recent samples seem to suggest a cryptic, Delphian source of Zen koans.

Runt – Ruby Temporal Expressions

Kellan — Sat, 26 Nov 2005 05:45:00 +0000

an implementation of select temporal patterns by Martin Fowler

http://runt.rubyforge.org/

Lay out of a PHP application

Kellan — Tue, 15 Mar 2005 20:11:17 +0000

Solid advice. I do it a little differently (more structure), but following this advice will make your app better, and make you a better programmer

http://www.phpguru.org/static/ApplicationStructure.html

Rafe recommends “Head First Design Patterns”

Kellan — Tue, 15 Feb 2005 22:23:02 +0000

I’ve been boycotting it due to the cover

http://rc3.org/cgi-bin/less.pl?arg=6774

UI Patterns and Techniques

Kellan — Tue, 21 Sep 2004 05:02:08 +0000

Its all about patterns

http://time-tripper.com/uipatterns/index.php

Resign Patterns – Ailments of Unsuitable Project-Disoriented Software

Kellan — Wed, 25 Aug 2004 22:02:15 +0000

I’m using the Brig pattern right now.

http://www.agcs.com/supportv2/techpapers/patterns/papers/respat.htm

MySQL, and the CASE for Class Table Inheritance

Kellan — Sun, 15 Aug 2004 01:08:00 +0000

At work we’re using Class Table Inheritance to model the core data structures of our as yet nameless open source CRM. (actually it has a code name, but I don’t like it, so we’ll pretend it’s nameless)

This week as I learned both the name of this pattern, and the SQL to implement it efficiently in MySQL I thought I’d share some notes on what we’ve come up with.

Class Table Inheritance

CTI is a pattern where your schema hews closely to the your class hierarchy — you have a table for each class, and object attributes are stored as columns in the table for that class. This is as opposed to Single Table Inheritance, which stores all attributes for every member of an inheritance tree in a single table, or Concrete Table Inheritance which duplicates the inherited fields to each table.

We’re using CTI for a number of reasons, some excellent, and some because that is how our brains work. One key benefit is we get the ability to operate on heterogenous collections of object. (i.e. display a sorted list of contact objects irrespective of whether they are individuals, organizations, etc.) The fact that something as fundamental as polymorphism can be difficult to accomplish using other O/R techniques hilights the general difficulty and impedance mismatch of object to relational mapping.

There are, however a few challenges involved.

The Model

But quickly a trivial mock up of the data model to give us something to play with. In this model we have 3 classes, a base Contact class, and 2 types of contacts Individual and Organization which inherit from Contact. In the database we model this as a Contact table, with a primary id, and any fields which the Contact the parent class provides. Individual and Organization each get their own table, with class specific attributes, plus the primary id from Contact which is both the primary id, and a foreign key into Contact. For every contact stored in the database there is a record in the Contact table, and a record in either Individual or Organization.

Challenge 1:

How do you retrieve your data now that it is broken across multiple tables? The obvious (and obviously wrong) solution would be to first select against the Contact table, examine the resulting data, and select against the appropriate children tables. (remember this example is a drastically simplified data model)

Solution 1:

My current solution is to do a 3 way left outer join, and then instantiate the objects out of fields which aren’t null. It can look a bit ugly with large numbers of columns, but is actually pretty simple, and initial benchmarks against a test data set of 1.3 million records suggests it scales nicely.

SELECT 
  c.id as id, c.contactType,
  i.firstName, i.lastName,
  o.name as orgName
FROM
  Contact as c
LEFT JOIN Individual as i ON i.id = c.id 
LEFT JOIN Organization as o ON o.id = c.id

(And it’s pretty easy to coax the necessary SQL out of our modified version of DB_DataObject. I’ll demonstrate that in a future entry)

Challenge 2:

One of the good reasons (in fact the only concrete one I’ve given you) to go with CTI and its potential added complexity is the desire to sort a mixed list of contact types. But what do you do when you want to sort on an amorphous concept like “Name”? Individual might sort by “Lastname, Firstname”, while we just use “orgName” for an organization. Where is our polymorphism now?

One solution would be select all known records, and do sorting and slicing at the application level. (This is so wrong it makes my head hurt) Another solution would be store a field like “sortName” on Contact, which you could calculate and save on inserts and updates. This is on the right track.

Solution 2:

The solution (which Carl clued me into while we waited to get into the zoo), is to use the SQL CASE statement to calculate “sortName” on the fly. Below is our SQL from below with the new logic in green.

SELECT 
  c.id as id, c.contactType,
  i.firstName, i.lastName,
  o.name as orgName,
CASE 
 WHEN c.contactType = 'Individual' THEN CONCAT(i.lastName, i.firstName)
 WHEN c.contactType = 'Organization' THEN o.name
END as sortName
FROM
  Contact as c
LEFT JOIN Individual as i ON i.id = c.id 
LEFT JOIN Organization as o ON o.id = c.id
ORDER by sortName

This simply adds a switch statement to your field list conditionally setting the value of sortName.

There is nothing quite so satisfying as finding the right tool for the right job. I’m currently totally in love with the CASE statement, and think everyone should know about it. (hence this bit of evangelism)

Tip: don’t forget that ‘,’ after orgName, I keep forgetting it and wondering why my SQL isn’t working.

So concludes today’s edition of “Enterprise Development with MySQL” (“Kellan Learns SQL” didn’t sound as impressive). In the near future I hope to get a chance to write up some of the PHP libs we’ve been building/modifying to support object rich web development techniques, completing the picture. (OLamp anyone?)

Mixing Metaphors

Single, and Concrete TI both have their places, and the good news is you can mix these patterns without much difficulty. Still I’m happy with both the flexibility and “OO-ness” of Concrete Table Inheritance, and once again impressed by the speed, and power of MySQL. (N.B. we’re targeting 4.1.x, but these above examples all work with 4.0.16 and 4.0.20)

Single Table Inheritance

Kellan — Sun, 08 Aug 2004 06:49:19 +0000

The power of naming, transmuting bad relational design into a legitimate enterprise pattern.

http://martinfowler.com/eaaCatalog/singleTableInheritance.html

class HelloWorldEmphasizer extends HelloWorldDecorator

Kellan — Fri, 16 Apr 2004 00:47:45 +0000

Hello world in Patterns, a cautionary tale

http://www.phppatterns.com/index.php/article/articleview/103

Grooving Up Slowly

Kellan — Wed, 17 Mar 2004 19:24:00 +0000

I finally made it a SeaJUG meeting last night, Ted Leung speaking on Groovy proved to be an irresistible draw (and I was in town for once). This was also my first venture across the 520 bridge, into deepest, darkest suburbia (Bellevue). Wilhelm and Ted took pity on my carless state, and were great company

SeaJUG is a great group; smart, friendly, and intellectually curious. There are several vibrant subgroups including a Scheme group, a GoF study group, a regular language agnostic pair programming night, and a new Eclipse group (first meeting is first Tuesday in April, and I’ll be out of town, bah). I can also see that it would be an intimidating group to present to, especially bullshit, and this was confirmed by quiet evil laughter describing their last vendor visit.

Groovy

Groovy has fascinated me since I first heard of it. I’m a dedicated “scripting” language hacker. Life is too short, and there are too many interesting problems to solve to slave away in the service of the compiler. And yet I’ve definitely felt the pull for more rigor and structure at times (generally when I was having to work with someone else’s code). Much of Perl works by consensus, I agree to call a method just so, and you agree not to muck with my internal variables (or the symbol table). Java works by locks (and shotguns, according to Larry Wall). Groovy provides a gradient, I can be as dynamic, and loose, and experimental as I want, or as locked down and precise, and I can change my mind, over time, about which way to go.

Groovy is a Java compatible, dynamic language, built on the JVM. You can pare it down to something it will make a Perl programmer pause (no classes, no methods, objects defined at runtime as closures, no semicolons), or add structure, type declarations, and all sorts of baggage all the way up to Java itself. Code can be run interactively, or can be compiled to Java bytecode. (one wag even suggested you could write Groovy, compile, and then use a decompiler to get your Java code. This is not recommended)

The Groovy developers have done a lot of work adding the syntactic sugar which makes scripting languages fun. Primitives are auto-boxed, and collections have been instrumented with a variety of useful methods that will make your functional programmers feel right at home. They’ve also been building some powerful domain specific constructs for operating on tree structures (XML/Ant/GUI widgets), building web pages (as ugly as PHP on a bad day, should make it popular!), and marshalling data into and out a relational DB. And lastly they address the other thing life is too short for, reinventing the wheel (especially as they seem to get more square each time). Because Groovy is compiling down to Java bytecode you have total, native access to many many high quality Java libraries.

See Ted’s slides. (understanding of closures is highly recommended)

Would I Use It?

Not this month. Not next month either. The syntax is still somewhat influx (if you’re a language hacker, that makes now a great time to get involved), and there were part which seemed either undefined or ambigous never a good thing in a programming language. There also feels like there has been a lack of discipline, too many special cases in the syntax, and a sense that the designers are kids in a candy shop running amok borrowing syntax from all their favorite languages. Still I’m excited about it. Its about 6 months old. I think 6 more months will tell us how successful its going to be.

Ted

Ted is as smart, interesting, and informed as you would expect him to be reading his blog. He kept his cool in the face of hardware trouble, and a large contingent of the audience who weren’t buying it. As Ted said, “to fully buy into Groovy, you have to buy into some assumptions about how software should be developed, which is philosophical bordering on religious.” He is talking about agile software development, which I occasionally forget still has its detractors, and its unintiated.

Rabble Rousing

He ended by addressing the fact that much of programming is mechanical, and that far from happening accidentally, or improving over time this trend is getting worse. With top heavy, byzantine architectures like EJB, or the ever deepening W3C XML stack, you see the work of the large technology vendors who are interested in keeping entry difficult, work rote (and therefore cheaply offshore-able), and profits up. As he ended with “the big corporations are going to solve this for you, we need to solve this for ourselves” I had a brief moment of cognitive dissonance as my worlds collided and I couldn’t remember if I was at an anti-globalization meeting, or a software users group. This is the sort of stuff people should at least bring up at the next CATS meeting.

Chandler

It was fascinating to get an inside update on Chandler, a project I’ve watched with fascination since its early days. (Thankfully I’ve got a job I’m very happy with, and so I didn’t have to embarrass myself by pumping him for contacts as the OSAF.) I’m looking forward to Mitch Kapor’s keynote at next week’s PyCon (not that I’ll be attending)

Mixins

And he addressed the problem I’ve always had with mixins. (recently reinvented by the AOP crowd apparently as “static cross cutting”) You see when I hear mixins the first thing I think about (or the second, after I think about too many late nights struggling with Mailman) is ice cream from Herrell’s. Herrell’s is a Boston (and Northampton) ice cream shop that will pound your ice cream out flat, mix all sorts of wonderful things into it, and roll it up again. Turns out that that is the origin of the term. Back when it was Steve’s and the MIT hackers were working on the original Lisp machine. Wow.

Web Development with Perl.

Kellan — Wed, 11 Sep 2002 01:19:00 +0000

In preparation for doing the Protest.net re-write I’m doing some research on web frameworks. I find myself rewriting the same central dispatcher code, adding refinements, like a redirect method (similiar to the forward() method in servlets) and in general missing some of the refinements of Java’s web environments (servlets, Struts, bundles for i18n) while refusing to give up Perl, CPAN, and Template Toolkit.

This is my brain dump so far. Lots of questions, a few answers. The next step will be firing up the text editor and looking under the hood.

Steal from the Best

Applications I’m going to examine for ideas to steal, particularily framework ideas (error handling, inner loop, etc.)

Moveable Type – in my few glaces at the code its seemed intelligent, and well structured. Runs under mod_perl and CGI, handles some complex UI demands like pages that use redirects to update progress bars, and re-entrant forms.
Bricolage – based on Mason, I’ve been hearing good things about this CMS, particular about its clever Burners abstraction, hope to find other good things under the hood. Don’t really know much about Mason, not sure if that is going to be barrier
RT – popular, mod_perl and Mason, ticket tracking software. Also supports email, and command line interfaces.
Scoop – haven’t looked at Scoop in a while, but I remember it seemed well done (having just come from looking at Slashcode 1.0), I wonder if it will stand the test of time. Not expecting to find anything all that relevant, but maybe. Will probably do a quick skim of the CMS parade: Slash, Everything2, and maybe LiveJournal. Definitely want to look at LiveJournal’s embedding instructions.
?? Do you any Perl web applications you would consider examples of best practices??

Perl Frameworks

OpenInteract seems popular, and uses TT2, but leaves me cold, partially because I’m just not crazy about persistence layers. But I should probably spend some time looking at it. ?? Any expirences using it ??
Mason natively uses an embedded, page based execution model, which seems PHP-like to me, but Design Issues with Mason: What are Components For? seems to be simple guidelines for avoiding the siren calls. There is an Oreilly book coming out on it, which will be available online, but the author says, don’t expect it until mid-October.
Wombat is billed as an implementation of the Servlet API in Perl, but I can find exactly zero reference to anyone using it, never a good sign.
AxKit is a web framework built along the lines of Cocoon. I bet there are seriously cool ideas to steal in there, but I’ve been burned pretty badly playing with XSLT and don’t want to go back into that water right now.
OpenFrame also seems interesting. It has the request and response objects ala servlets, and acme is being paid to work on it, and it has a “Slot” concept which seems similiar to Brico’s Burner concept, and supports TT2. However it bills itself as an “open source application framework for distributed media applications.” Which isn’t really what we are building.
A few others are listed at Application Servers and Toolkits based on modperl. Also, Web Frameworks and their Template Engines is interesting.

Last time I was looking at this stuff there was JellyBean, which no longer seems maintained, and Iadio, which no longer exists.

I found a simple home-rolled framework that feels simliar to the one I did for Rockwood. It was mentioned in this interesting thread.

The book, Perl for the Web from New Riders, is freely available online and seems interesting if out of date.

Piecemealing with Modules

We’ll definitely be using Template Toolkit. Read Perrin’s classic article on Template engines. (the sequel to his classic article on building the eToys website.)

Apache::Session is a given. Not finding a good webpage on it, but it has great POD.

Cache::Cache is a given. The Perl Cache project is one of those tools, like TT2, that makes you never want to leave Perl.

DBI is an of course, and I think we’ll be avoiding the DBIx namespace in favour of having a peer layer with hand written SQL.

Many people are reccomending CGI::Application as an implementation of the central dispatchers. An article on using CGI::Application, and on using CGI::Application with Template Toolkit. I’ve looked at it before, and it was simpler to roll my own, but I’m going to check it out again. It runs cleanly under Apache::Registry, but isn’t really a full blown modperl app.
Data::FormValidator is recommended, and includes a tutorial, but some people prefer HTML::FormValidator, but I don’t really know what the difference is yet. Hmmm, they look like they might actually be the same module. ?? Any idea ??
?? Did I leave out your favorite module ??

UPDATE: After looking at the available options, and at Struts 1.1, I would go with Java if I didn’t know I would have an insurrection on my hands.