<cfscript>
string = "The catapult bifurcated the bearcat.";
fancyString = REReplaceCallback(string, "(\w*)(cat)(\w*)", doit, "all");
function doit(match) {
  if (match[2] EQ "") {
    return '#match[2]#<b><i>#match[3]#</i></b>#match[4]#';
  } else {
    return '<u>#match[2]#<b><i>#match[3]#</i></b>#match[4]#</u>';
  }
}
</cfscript>

As you'd imagine, the 'doit' function is invoked for each match of the regular expression (in this case looking for a literal "cat" surrounded by any number of word characters).  It then does a check on match[2] (the leading word characters) to see if it's empty and then forks based on that result (either underlining or not).  The 'match' array, as you might surmise, contains the matched expressions.  The first index is the entire expression, and an additional index is added for each subexpression in the regular expression.  In this case, there are three subexpressions, so the 'match' array will have length 3 + 1 = 4.

This particular conditional can be performed without a callback.  Here are a pair of REReplace calls that do it:

<cfscript>
string = "The catapult bifurcated the bearcat.";
fancyString = REReplace(string, "(\W|^)(cat)", "\1<b><i>\2</i></b>", "all");
fancyString = REReplace(fancyString, "(\w+)(cat)\w*", "<u>\1<b><i>\2</i></b>\3</u>", "all");
</cfscript>

The first one takes care of words starting with 'cat', the second words with 'cat' inside or at the end.  Note that this only works because the result of the first replace does NOT put word characters next to 'cat' in the replacement string.  If it did that, we'd be screwed, because the two replaces happen sequentially, not in parallel.

In this particular case, neither one of them is very readable.  :)  With a little cleanup and a well-named temp variable, I'd say the callback version has the potential to be more readable, but the pair of REReplaces is pretty much stuck as-is.  As things get more complicated, however, the callback approach becomes dramatically clearer.

The big win, of course, has nothing to do with conditional replaces.  Rather, it's the ability to execute arbitrary CFML code to generate the replace string based on the matched string.  Your callback can do anything you want: go hit the database, shell out to a web service, go grab a dynamically selected bean from ColdSpring and get a value from it, etc.  The sky's the limit.

Here's the REReplaceCallback UDF itself:

<cffunction name="REReplaceCallback" access="private" output="false" returntype="string">
  <cfargument name="string" type="string" required="true" />
  <cfargument name="pattern" type="string" required="true" />
  <cfargument name="callback" type="any" required="true" />
  <cfargument name="scope" type="string" default="one" />
  <cfscript>
  var start = 0;
  var match = "";
  var parts = "";
  var replace = "";
  var i = "";
  var l = "";
  while (true) {
    match = REFind(pattern, string, start, true);
    if (match.pos[1] EQ 0) {
      break;
    }
    parts = [];
    l = arrayLen(match.pos);
    for (i = 1; i LTE l; i++) {
      if (match.pos[i] EQ 0) {
        arrayAppend(parts, "");
      } else {
        arrayAppend(parts, mid(string, match.pos[i], match.len[i]));
      }
    }
    replace = callback(parts);
    start = start + len(replace);
    string = mid(string, 1, match.pos[1] - 1) & replace & removeChars(string, 1, match.pos[1] + match.len[1] - 1);
    if (scope EQ "one") {
      break;
    }
  }
  return string;
  </cfscript>
</cffunction>

Lots of stuff going on in there, but it's basically just doing a REFind with returnsubexpressions=true, ripping apart the string to pass the pieces to the callback function, and then reassembling the string afterwards.  It'd be trivially easy to make a REReplaceNoCaseCallback function, but I haven't done.  I've implemented the function with CFFUNCTION/CFARGUMENT tags so that I can have an optional fourth parameter on CF8, but the body as CFSCRIPT so that if you want to use the UDF in pure CFSCRIPT on CF9, you only have to rewrap the body (not reimplement).

This particular implementation differs from what you might expect in that the callback gets substrings instead of position/length tuples (i.e., the way REFind works).  I opted for this approach for two reasons: first it removes the need for the callback to have access to the raw string, and secondly all you do with the len/pos is rip the string apart to get the characters so why make every callback do it.

Why did I write this?  Just for fun?  No, not at all.  I needed a way of doing rich inline markup with tags that could be implemented via plugging for a project (you get one guess), and after playing with a couple formats I concluded that porting WordPress's shortcodes was as close to an optimal solution as I was going to get.  The shortcode implementation requires this sort of conditional replace operations, so I built this UDF.  If you do PHP, it's basically equivalent to preg_replace_callback but with CFML argument ordering.

Yes, I'll be sharing the CFC that implements shortcodes (complete with a port of the WordPress unit tests from PHPUnit to MXUnit), but not right this second.

A pointing pair is easier to see than a pointing triple, but necessitates making the definition slightly tighter: if a block contains only two potential cells for a given number and they're in the same row or column, then that number cannot exist in any other block's cells of the same row or column.

Of course, if you crank it down one more step (to a "pointing single"), you have the definition of a known cell (either a given or one already solved for).  But enough prose, on to the code:

boolean play(Board board) {
  def madePlay = false
  board.blocks.each { b ->
    (1..9).each { n ->
      def cells = b.findAll {
        it.hasMark(n)
      }
      if (cells.size() >= 2) {
        if (cells*.col.unique().size() == 1) {
          // all in one col
          cells[0].col.each {
            if (it.block != b) { // different block
              madePlay = it.removeMark(n, this) || madePlay
            }
          }
        }
        if (cells*.row.unique().size() == 1) {
          // all in one row
          cells[0].row.each {
            if (it.block != b) { // different block
              madePlay = it.removeMark(n, this) || madePlay
            }
          }
        }
      }
    }
  }
  madePlay
}

This is the longest strategy so far, but it's pretty straightforward.  For each block, consider each number.  Find all the candidate cells, and if there are two or more, see if they're all in a single column.  If so, loop over the column and remove the number from each cell not in the current block.  Then do the same check for rows.

Using Groovy's getAt (bracket) notation, I could have wrapped the col and row checks into a single loop to reduce some duplication, but I haven't here.  You'll see that technique in some of the later strategies, however.

Finally, you'll notice that the whole board is iterated over and potentially many plays are made before the method returns.  As such, using each iterators wasn't a big deal.  This is probably somewhat wasteful, because a pointing pair can potentially do a lot of elimination (and therefore falling back to the GameRulesStrategy would be useful), but I haven't done it here.

The raw source (including the test cases) is available at PointingPairStrategy.groovy, should you be interested.

This is a simple answer to derive: just average the ratings of every movie the actor was in, and whichever actors have the highest average are the favorites.  Here it is expressed here in SQL:

select actor.name, avg(rating.stars) as avgRating
from actor
  inner join movie_actor on movie_actor.actorId = actor.id
  inner join movie on movie_actor.movieId = movie.id
  inner join rating on movie.id = rating.movieId
where rating.subscriberId = ? -- the ID of the subscriber whose favorite actors you want
group by actor.name
order by avgRating desc

The problem is that – as an example – Tom Hanks was in both Sleepless in Seattle and Saving Private Ryan.  Clearly those two movies appeal to different audiences, and it seems very reasonable that someone who saw both would like one far more than the other, regardless of whether or not they like Tom Hanks.  The next problem is if they've only seen one of those movies, the ratings are going to paint an unfair picture of Tom Hanks' appeal.  So how can we solve this?

The short answer is that we can't.  In order to solve it, we'd have to synthesize the missing data points, which isn't possible for obvious reasons.  However, we can make a guess based on other datapoints that we do have.  In particular, we know the average rating for all movies for a user, so we can bias "small" actor samples towards that overall average.  This will help mitigate the dramatic effect of outliers in small sample sizes when there aren't enough other datapoints to mitigate them.

In other words, instead of this:

we can do something like this:

This simply takes the normal average from above, and "scoots" it towards the overall average based.  The denominator is a constant picked by me (more later) raised to the power equal to the number of samples we have.  This way as the number of samples goes up, the magnitude of the correction falls rapidly.  Here's a chart illustrating this (the x axis is a log scale):

With only one sample, the per-actor average will be scooted 87% of the way towards the overall average.  With four samples the correction will be only 57%, and by the time you get 32 samples there will be only a 1% shift.  Note that those percentages are of the distance to the overall average, not any absolute value change.  So if a one-sample actor happens to be only 0.5 stars away from the overall average, the net correction will be 0.465.  However, if a different one-sample actor is 1.5 stars away from the overall average, the net correction will be 1.305.

Of course, I'm not Netflix, so my data was from PotD, but the concept is the identical.  The "1.15″ factor was derived based on testing on the PotD dataset, and demonstrated an appropriate falloff as the sample size increased.  Here's a sample of the data, showing both uncorrected and corrected averages ratings, along with pre- and post-correction rankings:

In particular, model #33 sees a huge jump upward because of the number of samples.  You can't see it here, but the top 37 models using the simple average are all models with a single sample (a 5-star rating), which is obviously not a real indicator.  Their corrected average is 3.3391, so not far off the leaderboard, but appreciably lower than those who have consistently received high ratings.

For different size sets (both overall, and expected number of ratings per actor/model) the factor will need to be adjusted.  It must remain strictly greater than one, and is theoretically unbounded on the other end but there is obviously a practical/reasonable limit.

Is this a good correction?  Hard to say.  It seems to work reasonably well with my PotD dataset (both as a whole, and segmented various ways), and it makes reasonable logical sense too.  The point really is that if you don't care about correctness, you can do some interesting fudging of your data to help it be useful in ways that it couldn't otherwise be.

Being the idiot I am, I figured I may as well upgrade K2 (since it would have those same fixes I made, along with other related ones I didn't catch), and that went horribly.  Their 1.0.3 release pretty much failed, and is even more bloated than before.  So now, with an again-broken site, I went theme shopping.

Fortunately, I'd just received a couple recommendations on a K2 replacement, and Theme Hybrid with the Life Collage child theme appeared to be relatively close to what I wanted.  So after tossing that in, I again had a non-broken site.  After another hour or so of CSS hackery atop the Life Collage CSS (but just the Hybrid HTML), I again have a site I'm relatively happy with.  Unfortunately WordPress doesn't let child themes extend other child themes (only "root" themes), so I couldn't get all the Life Collage HTML goodies (at least without copying), but no great loss there, I don't think.

As an added bonus, the theme supports dropdown menus for the top nav (based on subpages), which is something I've wanted for my project list for a while, but never got around to building with K2.  So one less project I have to do, and that's always a good thing.

The only remaining major issues are that there doesn't seem to be a no-comments template for pages (which is unfortunate, I think), and WP apparently did away with the recent posts sidebar widget (no idea why). [ed. They didn't get rid of it, they just changed it to be a 'postbypost' archive widget.] I'm not sure I'm going to stick with Life Collage's base styling, but I'll probably stick with Hybrid as a root theme.  Both are a little id-heavier than I could wish for, but they've got pretty solid markup which makes styling pretty straightforward.

Just for the sake of completeness, the other couple suggested theme replacements were WP Framework by Ptah Dunbar and Thematic by Ian Stewart.  Of the three, Hybrid looked the best out of the box, I thought, though they were all very similar.  It also happened to have prepackaged child themes, which was a win for me with the state of my site at the time.  But even without that, I think I'd still have picked Hybrid.

UPDATE: apparently WordPress not only deprecated `attribute_escape`, they also changed it's functionality (despite it's widespread use in the app) to no longer correctly process arrays.  I don't know.  In any case, replacing a couple instances of it within K2 with an `array_map` application of `esc_attr` fixed it.  The actual problem was that the BODY classes weren't being correctly generated, thereby throwing off all the CSS selectors.

UPDATE 2: I've been wanting to get away from K2 for a while.  It was awesome, but now it's kind of broken.  And upgrading to 1.0.3 left me with all kinds of weirdness.  So I kicked it to the curb, and am going to be starting afresh.  Should be good.

UPDATE 3: So I've obviously reskinned.  For an hour of hakcing a previously-unknown theme's CSS I'm pretty happy, but definitely still pretty rough around the edges.  But it's good enough, so now it's time for dinner.

With this latest update, there is now an optional fifth parameter to 'putFileOnS3' named 'isPublic'.  It defaults to false (to retain backwards compatibility).  If you set it to true, the 'public-read' ACL will be placed on the object you're PUTting, making it immediately publicly available for retrieval.  There is a corresponding change to the private 'getRequestSignature' method for accepting headers on requests to sign per Amazon's CanonicalizedAmzHeaders format.

As always, the CFC itself is available (amazon.cfc.txt) and the project page is the place to get latest info/releases.

class HiddenSingleStrategy implements Strategy {

  static getTests() {
    [
      new Test(
        '0' * 9 + '000200000' + '0' * 9 + '000060000' + '0' * 9 + '000080000' + '0' * 9 * 2 + '000002000',
        {
          def cell = it.getCell(5, 5)
          cell.isKnown() && cell.value == 2
        }
      )
    ]
  }

  boolean play(Board board) {
    for (h in board.houses) {
      for (n in 1..9) {
        def cells = h.findAll {
          ! it.isKnown() && it.hasMark(n)
        }
        if (cells.size() == 1) {
          // we found a hidden single
          cells[0].setValue(n, this)
          return true
        }
      }
    }
    false
  }

}

As you can see, the test is a little different than for GameRulesStrategy.  Before I just supplied a board and a successful test was when the board is solved.  In this case I'm just checking for if cell (5, 5) is known and it's value is 2 (no need to solve the whole board).

The strategy itself is pretty simple: for every house, for every number, see if any cell is the ONLY cell in the house that can contain the number, and if so, set that cell to that number.  Once we find a cell to set, the method exits (returning true) and does not continue the search.  This is the reason for the 'for' loops instead of the Groovy 'each' iterator.  This lets GameRulesStrategy "clean up" the board before continuing the search.  In this case it's probably not a big deal, but with the more complex strategies this is an essential optimization.

Euler's Identity (at different sizes):

Gravitational Constant:

Force due to gravity:

Inline also works (e.g., ).

If you use shortcodes within a paragraph (e.g., ) instead of the inline notation, you'll get a block. (This is a custom mod.)

Finally, if you put an inline in its own paragraph, it'll do this:

Unless you explicitly state that it is a block:

The reverse of that, as you'd expect, lets in-paragraph shortcodes work too (e.g., ).

If you want to see the raw LaTeX, it's in the tooltip/title of the image.  WordPress.com provides the encoding service, though the plugin supports a local/third-party image service as well.

The first problem is due to Adobe's seemingly mindless choice to require the use of Application.cfc for per-request settings (datasource, mappings, ORM config, etc.), rather than doing it the right way with tags (in the style of the CFAPPLICATION tag).  With Application.cfc being the only place you can define any of this, you cannot use Application.cfc for an individual frontend, since it has to be shared across ALL frontends.

Consider a prototypical blog.  It has a public side (where the public reads), and an admin side (where authors write).  Two separate front ends; one single application.  If your front controller is bound to Application.cfc, you're forced to either run two separate applications or a single dual-purpose frontend.  Either one is a mess, either reducing encapsulation or increasing duplication.  At the very least.

Now consider a different example: an app with a single frontend that also needs one, single, solitary, standalone page for something.  Maybe even just for a quick one-off test script.  You create 'test.cfm' in your directory (so it gets the proper Application.cfc context so you can do your ORM magic), and hit it in the browser.  Oops, your framework decided with it's onRequest handling that it's going to just do it's thing, completely ignoring your template.  Different manifestation, same problem, though this one can be mostly addressed by overriding onRequest with custom behaviour that conditionally invokes super.onRequest.

Like the majority of places where inheritance is used, the proper solution is composition.  Rather than having your Application.cfc extend the framework, let your application compose the framework into itself.  That way it happens on the application's terms, rather than the framework's terms.  I understand that just extending the framework is desirable for ease of initial setup, so I'm not saying you can't do that, just you (as a framework author) should provide an alternative (like Fusebox's fusebox5.cfm).  Then I (as the application developer) can decide how the framework should be used.

Just to be clear, the problem with using inheritance where composition is the correct choice rests on both the shoulders of Adobe (for making request settings part of Application.cfc, rather than composed in with tags), and framework authors (for requiring Application.cfc to extend the framework).  Addressing either of these problems would handle the first manifestation (paragraph 3), but only the framework authors can deal with the second manifestation (paragraph 4).

Bottom line, don't wire yourself in so you can self-invoke, let me invoke you when and where I want you.

Migration was mind-numbingly simple:

1. download and unzip Tomcat 6.0.24
2. change server.xml so the HTTP connector listens on 8082
3. copy everything from the JRun webroot to the Tomcat webroot
4. update Apache's config to proxy to Tomcat's port number (8082) instead of JRun's (8300)
5. start Tomcat, stop JRun, restart Apache

Since I'm running CF8, nothing else is required.  If I were running CF9, I'd need JTA (from http://java.sun.com/javaee/technologies/jta/index.jsp) so Hibernate would work, since Tomcat doesn't bundle it (it's a web container, not an app server).

If you looked carefully at the graphs you'll have noticed two "Tomcat" series, rather than one.  I neglected to increase the MaxPermSize when I first set it up, so the "swap" at about 8:45am was making that change.  The "LCYSA" process is another Tomcat running a pair of Magnolia instances (in different context), "Apache" is Apache HTTPD, and "MySQL" is the MySQL 5.0 server I store everything in for all apps.

The charts are generated by a simple CF app that parses `ps v -A O-v` output into a database, and then builds Google Charts from the data. You can view the app, or check out the source. It's not elegant, refined, maintainable, or really even very functional, and I had no intention of sharing until magnus asked in the comments. But I also prefer transparency, so there it is.  A crontab runs `capture_mem_state.sh` every 10 minutes, and then the CFML reads in the files it generates.