• Levenshtein distance
• Jaro-Winkler distance
• N-gram

Reader-writer locks naturally fit together with caches, as caches are only effective if reads far outnumber writes.

Here is a general pattern for using a reader-writer lock with a cache:

1. Acquire a reader lock.
2. Check the cache for the value. If it exists, save the value and go to step 8.
3. Upgrade the reader lock to a writer lock.
4. Check the cache for the value. If it exists, save the value and go to step 7.
5. Calculate the value (expensive, otherwise we wouldn’t cache it)
6. Insert the value into the cache.
7. Release the writer lock.
8. Release the reader lock.
9. Return the value.

The reason why we have to check the cache for the value again in step (4) is because of the following possibility (assume step 4 doesn’t exist):

Thread 1                         Thread 2
============================     ===============================
- Acquire reader lock            - Acquire reader lock
- Check cache for value          - Check cache for value
  with key A (not found)           with key A (not found)
- Upgrade to writer lock         - (block)
- Calculate value (expensive)
- Insert value into cache
- Release writer lock
- Release reader lock
                                 - Upgrade to writer lock
                                 - Calculate value (expensive)
                                   (We are paying this cost
                                   twice)
                                 - Insert value into cache
                                   (We are inserting two values
                                   with the same key, which may
                                   be fatal)

With step 4 it becomes:

Thread 1                         Thread 2
============================     ===============================
- Acquire reader lock            - Acquire reader lock
- Check cache for value          - Check cache for value
  with key A (not found)           with key A (not found)
- Upgrade to writer lock         - (block)
- Calculate value (expensive)
- Insert value into cache
- Release writer lock
- Release reader lock
                                 - Upgrade to writer lock
                                 - Check cache for value
                                   with key A (found)
                                 - Release writer lock
                                 - Release reader lock
- Return value                   - Return value

If the user has provided multiple parameters with the same key in the query string, HttpRequest.QueryString[key] will return all the values concatenated together with commas.  If you would rather process the values individually, use HttpRequest.QueryString.GetValues(key), which will return an array of all the provided values.

For example:

URL: http://example.com?a=1&a=2
HttpRequest.QueryString["a"] = "1,2"
HttpRequest.QueryString.GetValues("a") = { "1", "2" }

The balloon tooltip appears to be a Windows tooltip common control with the TTS_BALLOON style.

To replicate this functionality, I decided to write a function called ShowMsgBalloon() which, given a control and the various balloon tooltip parameters, creates and shows the balloon tooltip below the control.

The key insight to making ShowMsgBallon() work as intended was to use the TTF_TRACK option to create a tracking tooltip. This will immediately show the tooltip without requiring the user to position the mouse over the control. The main downside to using TTF_TRACK is that the tooltip will not move with the control if the window is moved; you need to manually move the tooltip using TTM_TRACKPOSITION as required. One could probably make this automatic by subclassing the tooltip’s parent control and handling WM_WINDOWPOSCHANGED messages.

Here is the source code to ShowMsgBalloon(). When you are done with the balloon, call DestroyWindow() on the returned HWND. Note: you may want your application to use comctl32.dll version 6 as it will lead to a nicer visual style, including a close button.

Update 2008-11-01 3:08PM: If you are targeting comctl32.dll version 6 or later, I recommend using the EM_SHOWBALLOONTIP message.  Comctl32.dll version 6 or later also automatically shows the caps lock warning balloon for edit boxes with the ES_PASSWORD window style.

In XPath, strings must be delimited by either single or double quotes. Given a quote character used to delimit a string, one can’t represent that same quote character within the string. This means that if you decide to use single quotes to delimit your XPath string, you couldn’t represent the string O'Reilly; use double quotes, and you can’t represent "Hello".

However, given a quote delimiter, you can represent the other quote character. We can use this observation along with the concat XPath function to devise a general quoting rule for XPath strings. It’s easiest to show this via a series of examples:

Below is a piece of C++ code which implements these quotation rules:

Usage looks like:

For more information, please read what the W3C has to say about ISO 8601 style date and time formats.

If you create a child process using fork(), you must either:

1. Explicitly retrieve the child process’s exit code using one of the wait() functions (e.g. waitpid())
2. Tell the system that you aren’t interested in the child process’s exit code by using either:
   1. sigaction() with the SA_NOCLDWAIT parameter (preferred)
   2. signal(SIGCHILD, SIG_IGN); (for systems which do not support sigaction())

As I fixed this bug, I realized I hadn’t looked at tcpconndbg in 5 years. My how programming style changes…

Update 2008-01-30 10:52PM: Here’s the equivalent “one-liner”:

Beware: the Mandelbrot set is computationally expensive and may appear to lock up your web browser. If a “Stop running this script?” dialog pops up, please click no to allow the calculations to finish.

Silverlight 1.0 Mandelbrot Set Control

Here is a Silverlight 1.0 control which draws the Mandelbrot set. Left-click to zoom in on a particular region.

Source Code

The source code to the Silverlight Mandelbrot set consists of the following pieces:

• SilverlightMandelbrot.js — The code for instantiating the Silverlight Mandelbrot control and binding it to a div
• SilverlightMandelbrotEvents.js — The event handlers for the Silverlight Mandelbrot control, including the drawing code itself (performed on canvas load)
• mandelbrot.xaml — The XAML which defines the visual layout of the control
• Silverlight.js — the Silverlight code itself

Notable Findings

• Overall responsiveness is rather slow, especially on the mousemove event. Perhaps I’m pushing Silverlight too hard too early, but this slowness makes me highly reluctant to adopt Silverlight yet.
• I can’t figure out how to do progressive (e.g. line-by-line) rendering to give the user feedback.
• There is no facility for directly painting an individual pixel within Silverlight. Instead, you must draw 1 by 1 colored XAML rectangle controls. Because individual XAML rectangles are quite heavyweight, I coalesce multiple pixels of the same color in the same row into one rectangle.
• I wanted to use right-click to zoom out, but there doesn’t appear to be a way to capture the right click event from within Silverlight.

About the Mandelbrot Set

For more information on the Mandelbrot set, see its Wikipedia article.