A Scheme Application Configuration Strategy

I've developing a Scheme app for a client, and of course, the people he's selling it to want customizations. Some of the customizations were pretty basic and I simply stored them in a prefab structure on disk.

Lately he's picked up a client that wants all sorts of random'ish customizations - from changes in labels on the screen to application functionality. Storing this information in a structure just wasn't going to work. I needed a more dynamic and scalable approach. Here's the rough idea I came up with.

First, every client can have their own customizer function. The implementation of each client's customizer is in their own scheme module. A customizer has the signature:

(define (foo-customer-customizer key default)
 ...)

We'll come back to how these arguments are used in just a moment. To make the customizer available to the rest of the code, I make use of a paramter, which is a kind of cleaner approach to global variables. At the beginning of my application, I effectively say:

(define the-customizer
  (make-parameter (match customer-name
                    ["foo" foo-customer-customizer]
                    ...)))

Finally, let's define a helper function so we don't need to see the-customizer throughout our code:

(define (cv key default)
 ((the-customizer) key default)))

OK, now we can get to the interesting stuff. Let's look at how this can be used. Let's say I want to customize a button on the Welcome screen, I can say:

(new button% [label (cv '(welcome-screen enter-button) "Welcome")] ...)

And suppose I'd like to change what happens when the hits the exit button:

(new button% [callback (lambda (b e)
                         (let ([f (cv '(application exit-button action) quit)])
                           (f)))] ...)

Or perhaps the customer likes to see people's name in all upper case:

 (define choices (map (cv '(format names) identity)
                          (get-user-names)))

You might need to customize the value based on some context, such as whether a row is odd or even:

(for-each (lambda (row-number row-value)
            ((cv `(ui table format ,row-number ,row-value) list) 
             row-number row-value))
          (get-row-numbers)
          (get-row-values))

Here's how this customer's customizer could be implemented:

(require scheme/match)
(define (foo-customer-customizer key default)
  (match key
    [`(welcome-screen enter-button) "Ahoy-hoy"]
    [`(application exit-button action) 
      (lambda () (ask-user "Are you sure?" ...) ...)]
    [`(format-names) string-upcase]
    [`(ui table format ,row-number ,row-value)
      (if (odd? row-number) (handle-odd-row row-value) (handle-even-row row-value))]
    ;; No match for our key, choose to return the default  
    [_ default]))

I realize that this isn't exactly rocket science, but there were a few aspects of this solution I was especially happy with:

• Adding in new configuration points using (cv ...) was easy to do
• The list notation for a key (ui table format ...) turned out to be both natural and extensible
• Having functions be first class values here absolutely makes all the difference. Instead of being limited to customizing strings, I can customize pretty much anything I want.
• The customer's customizer functions turned out relatively clean, with no need to try to account for every customized value in the system.
• The use of (match ...) was absolutely key, as it allowed me to skip writing a special parser for configuration values. The fact that it handles including values along with constant data, such as `(format ui table ,row-number) makes it especially flexible.

When it comes down to it, this solution could have been written in any language, yet it turned out to be quite naturally done in Scheme.