Properties

Here’s a funny little class I’ve been playing with in some development work.

class Property[T](var value:T) {
  def get:T = value
  def set(newval:T) = {
    value = newval
    this
  }
  def :=(newval:T) = set(newval)
  override def toString = "Property(" + value + ")"
}
implicit def Property2value[T](prop:Property[T]) = prop.get

I think that’s just too neat. The property can be set with the (admittedly PL/1-ish) := operator, and the value can be extracted with a cast or assignment.

If I could override the assignment then I could make this very, very C++-ish-ish. Note that I could have written something like the following.

def `=`(newval:T) = set(newval)

But then I’d have to use this as follows.

scala> val p = new Property(12)
scala> p `=` 13

That’s just not the same thing. Scala does not allow overriding assignment; no copy constructor for you.

If you are willing to declare p to be a var, then you can do the following. But this is really not what you want since it creates a new property, and does not modify the value of the existing property.

scala> def ValueToProperty[T](value:T) = new Property(value)
 
scala> var p = new Property(12)
p: Property[Int] = Property(12)
 
scala> p = 171
p: Property[Int] = Property(171)

Watched Property

So what’s the point of having this mutable property class? Well, now that I have the above I can add code to watch the property.

trait Watcher[T,U] {
  def notify(value:T, data:U)
}
trait Watchable[T,U] {
  var watchers:Map[Watcher[T,U],U] = Map()
  def register(watch:Watcher[T,U], data:U) = {
    watchers += (watch -> data)
  }
  def notify(value:T) = {
    watchers foreach {
      case (watcher, data) => watcher.notify(value, data)
    }
  }
}
class WatchedProperty[T,U](value:T) extends Property(value) with Watchable[T,U] {
  override def set(newval:T) = {
    super.set(newval)
    notify(newval)
    this
  }
}

Now I have a watcher and a watchable. I mix in the watchable trait with the property, and presto! I have a watched property. It’s somewhat of a big deal for some work I’m doing now; this would have made my life much easier.

class See[T,U]() extends Watcher[T,U] {
  def notify(value:T, data:U) = {
    println("Value is now " + value + " and data is " + data + ".")
  }
}

Finally, we do some “work.”

scala> val see = new See[Int,String]
see: See[Int,String] = See@fab91
 
scala> val watch = new WatchedProperty[Int,String](1)
watch: WatchedProperty[Int,String] = Property(1)
 
scala> watch register (see,"watch")
 
scala> watch := 12
Value is now 12 and data is watch.
res22: Property[Int] = Property(12)
 
scala> watch := 31
Value is now 31 and data is watch.
res23: Property[Int] = Property(31)

Of course, I can also avoid new by declaring the companion object for WatchedProperty and adding a factory method. Life in Scala is pretty good (so far).

object WatchedProperty {
  def apply[T,U](value:T) = new WatchedProperty[T,U](value)
}

Cleaner Watched Property

There is a problem with the implementation of watched property, and it is the type annotation U. Why should the property have to know the type for the data? The data only exists for the benefit of the watcher. Worse, the watched property isn’t a drop-in replacement for property; it has two parameters instead of just one. Finally, everyone who wants to register must use the same data type U (or a subclass). Here are some alternatives.

1. The watcher can maintain a map from watched property to the associated data. The watched property can then send itself with the property change notification. This is bad. The watcher has to maintain the map. If it is watching a lot of properties then it may have to maintain a big map, and there is lookup overhead. We avoid that by having the property return the data with the notification.
2. We could treat the data as an Any. Then it is the responsibility of the watcher to correctly cast the value during notification. This is a nuisance because the compiler cannot catch type problems for us, but Java programmers should be used to that by now.

Let’s try the second approach.

trait Watcher[T] {
  def notify(value:T, data:Any)
}
trait Watchable[T] {
  var watchers:Map[Watcher[T],Any] = Map()
  def register(watch:Watcher[T], data:Any) = {
    watchers += (watch -> data)
  }
  def notify(value:T) = {
    watchers foreach {
      case (watcher, data) => watcher.notify(value, data)
    }
  }
}
class WatchedProperty[T](value:T) extends Property(value) with Watchable[T] {
  override def set(newval:T) = {
    super.set(newval:T)
    notify(newval)
    this
  }
}

That’s better, actually. Watched property is again a referentially-transparent replacement for property, and watchers can use any data type they want. What could be better than this?

Better Watched Property

Actually that whole “Any” value is the problem now. This implementation cleans up the design a bit with better information hiding and referential transparency, but it also musses up type safety a bit. The watcher knows the type of the data; why can’t it get back properly-typed data during notification?

Maybe we’ve been asking the wrong question. The issue is, I think, the Java-esque nature of the solution. Why does notify really have to be passed the data? Why not do something very different? In fact, why not get rid of the watcher trait altogether? Why do we need it? We really just want to invoke a function (or method) when the property is changed. Let’s just directly register the callback, and forget the middleman.

trait Watchable[T] {
  var watchers:List[(T) => Unit] = List()
  def register(notify:(T) => Unit) {
    watchers += notify
  }
  def notify(value:T) = {
    watchers foreach (notify => notify(value))
  }
}
class WatchedProperty[T](value:T) extends Property(value) with Watchable[T] {
  override def set(newval:T) = {
    super.set(newval)
    notify(newval)
    this
  }
}

Watcher is gone. The data item is gone. The funny type problem is gone. The code is simpler, and even more flexible, since anything can be a watcher, including lambdas.

scala> val prop = new WatchedProperty(21)
prop: WatchedProperty[Int] = Property(21)
 
scala> def see(x:Int) = println("Value changed to: " + x + ".")
see: (Int)Unit
 
scala> prop.register(see)
 
scala> prop.register((x:Int) => println("Lambda sees value: " + x + "."))
 
scala> prop := 413
Value changed to: 413.
Lambda sees value: 413.
res10: Property[Int] = Property(413)

Data Again

Well, what about data? The value for data can be captured in a closure. Here’s an example, where the data is a name for the property being monitored.

class ChangeWatcher {
  def watch[T](prop:WatchedProperty[T], name:String) {
    prop register {
      (value:T) => println(name + ": " + value)
    }
  }
}

Did you get all that? The above is a fully-generic watcher. You pass it a property and a name for the property. Whenever the property is changed, it notifies you. This works for any kind of property.

scala> val prop = new WatchedProperty(21)
prop: WatchedProperty[Int] = Property(21)
 
scala> val status = new WatchedProperty("okay")
status: WatchedProperty[java.lang.String] = Property(okay)
 
scala> val temp = new WatchedProperty(21.8)
temp: WatchedProperty[Double] = Property(21.8)
 
scala> val cw = new ChangeWatcher
cw: ChangeWatcher = ChangeWatcher@3da8bc
 
scala> cw.watch(prop, "prop")
 
scala> cw.watch(status, "status")
 
scala> cw.watch(temp, "temperature")
 
scala> status := "Danger!"
status: Danger!
res18: Property[java.lang.String] = Property(Danger!)
 
scala> temp := 73.2
temperature: 73.2
res19: Property[Double] = Property(73.2)

The important thing to note is that you don’t have to have data. Or you can have lots of data. Or whatever you want. The responsibility for data is all back to the watcher, and off the shoulders of the watchable. This seems (to me) to be the correct division of responsibility.

To sum up: Functional Programming + Objects = Good.

The Argument:
As far as the “birthers” go, common sense says if there wasn’t anything to hide, then nobody would be hiding anything, right?

My Answer:
There is a fundamental principle of inquiry – that is assuming one cares about the truth – that assertions should be based on evidence. The absence of evidence does not constitute evidence. So far as the courts and I can tell, nobody is hiding anything. To accept assertions on insufficient evidence risks making oneself a tool for evil hands.

By the way: The argument presented is a common fallacy.  The argument in the general form goes something like: If you haven’t done anything wrong, then you have nothing to hide. I assume everyone reading this can understand why this argument is not valid.  It always bugs me when I hear people say it, especially in this country where we have an enshrined right to privacy arising from the Fourth Amendment to the U.S. Constitution.

The Counterpunch:
But isn’t it a duty to show the evidence if a person is running for President?

My Answer:
Yes, it is. And this was done to the satisfaction of the U.S. courts more than once.

The Non-Sequitur:
And that is enough to satify a you?  Big difference between this and McCain, and you know it.

My Answer:
Yes, there is a big difference.

McCain was born in the Panama Canal Zone, a tenuous and temporary extension of the US and not a state of the union. If elected, McCain would have been the first US President to have been born outside the states. This was a serious legal matter that ultimately ended in a (nonbinding) Senate resolution and required real legal investigation by a bipartisan legal review. This is because “natural born” is not defined in the Constitution. While McCain would be very, very likely to prevail in a legal challenge, it is not assured. In short, the courts have not ruled on this matter.

Obama was born in Hawaii, our 50th state, and a state of the union. He has provided documentation of his birth adequate for all legal purposes. In addition, his original birth certificate has been examined by the director of the Hawaii State Department of Health who attested to its authenticity under oath. The Republican governor of the state, Linda Lingle, has also attested to Obama’s status. The US courts have ruled on this matter.

So, yes, there is a big difference. Obama’s status as a naturalized citizen is well established. McCain’s is not.

def show[T](implicit thetype:scala.reflect.Manifest[T]) {
  thetype.erasure.getMethods() foreach println
}
def help(x:AnyRef) {
  x.getClass().getMethods() foreach println
}

These silly little functions are useful – at least, to me. Now when I can’t remember the name of a method I can type something like the following at the Scala prompt.

scala> help(Map())
public scala.Option scala.collection.immutable.EmptyMap.get(java.lang.Object)
public int scala.collection.immutable.EmptyMap.hashCode()
public boolean scala.collection.immutable.EmptyMap.equals(java.lang.Object)
...

The output isn’t very Scala-ish, but I could format it if I weren’t so lazy.

scala> help(scala.runtime.RichString)
public int scala.runtime.RichString$.$tag() throws java.rmi.RemoteException
public final boolean scala.runtime.RichString$.scala$runtime$RichString$$parseBoolean(java.lang.String)
public final char scala.runtime.RichString$.scala$runtime$RichString$$LF()
public final char scala.runtime.RichString$.scala$runtime$RichString$$CR()
public final char scala.runtime.RichString$.scala$runtime$RichString$$FF()
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()

These functions aren’t in any way brilliant, or even clever, but they are short and ridiculously trivial to write.

Printable ASCII is roughly codes 32 through 126, or 126-32+1 = 95 characters.  There are 95 passwords of length one, $95\times 95$ passwords of length two, $95^3$ passwords of length three, etc.  This gives a grand total of:

\[\sum_{i=1}^8 95^i = 6,704,780,954,517,120\]

This is a lot of passwords.  A lot.  That’s well over 6 quadrillion passwords.  It includes the passwords ~ and ~~~~~~~~.

Not all those are available for use in most cases.  First, you typically have to do the following.

1. Choose a lower-case letter.  26 of those.
2. Choose an upper-case letter.  26 of those.
3. Choose a digit.  10 of those.
4. Choose punctuation.  Let’s call that “everything else” and say that space is punctuation.  Thus there are $95-26-26-10 = 33$ punctuation characters.

So that limits our choice on four characters.  Let’s try again!  Now there is a grand total of:

\[26\times 26\times 10\times 33\times \sum_{i=0}^4 95^i = 223,080\times 82,317,121 = 18,363,303,352,680\]

That’s over 18 trillion passwords.  That’s actually way, way down from the full potential!

How much memory is required to store every single stinkin’ password’s crypt, MD5, etc.  Well, if we do it stupidly (i.e., ignore collisions, ignore smart data structures, etc.), then for MD5 we need 16 bytes for each.  That’s approximately $16\times 17~\mbox{Tib} \approx 272~\mbox{Tib}$.  That isn’t as much as you might think.  A single terabyte drive costs about \$100 (US) right now, and we’d need 272 of them.  Let’s say 300, just to be safe.  How much is that?  $300\times \$100 = \$30,000$.  Overhead, installation, maintenance, etc., all add to that, but not that much.  In short, it is very cost effective.

Computing them all?  We’d need to compute a lot of hashes.  Let’s pick on MD5 (even though it is almost cracked).  Suppose it takes us one millisecond to compute one hash.  We still need to compute 18.4 trillion hashes.  Serially, that’s $18.4\times 10^{12}~\mbox{passwords}\cdot 1\times 10^{-3}~\frac{\mbox{sec}}{\mbox{password}} = 1.84\times 10^{10}~\mbox{sec}$.  That’s just over 583 years.  Whew!  We’re all completely safe.

Not even close.  Suppose I have a 1024 node machine (small by today’s standards).  That cuts three orders of magnitude from the result, since every hash can be computed independently of the others (though smart storage would cause some serialization).  Now we’re down to under 6 years.  And how fast can we compute MD5 hashes???

Smart folks are making MD5 very fast.  See http://www.faqs.org/rfcs/rfc1810.html.  That’s from 1995.  Well, md5 -t, on my little 32-bit Intel MacBook, reports a speed of 313,406,912 bytes per second.  Eight bytes should take just about $2.55\times 10^{-8}~\mbox{seconds}$.  Yes, there’s overhead at the end of each hash, but I can counter with the following: I can hard code the eight byte limit to get a more efficient algorithm.  I can do a smart iteration with single-byte modifications and hash updates instead of a whole new hash computation.  Plus, there are much faster processors and, I feel confident, faster implementations.  I’ve got some confidence in my machine’s performance as an upper bound.  So, back to our 1024 node machine.

\[\frac{18.4\times 10^{12}~\mbox{passwords}}{1024~\mbox{node}} \cdot 2.55\times 10^{-8}~\frac{\mbox{seconds}}{\mbox{password}} = 458 \frac{\mbox{seconds}}{\mbox{node}}\]

That’s under eight minutes.  I can’t even manage to make coffee in that time.  Even assuming we add two orders of magnitude for storage and overhead, that’s just 800 minutes, or a few days.

I’d be surprised if there isn’t a database somewhere of all 8-byte (or shorter) passwords and their crypt, MD5, SHA1, and what-have-you.  That is, I expect 8-byte passwords have been solved.  Think about that next time you log in to a site on the web, secure in the knowledge that your password is being sent encrypted.

Who could do this?  If I were highly motivated, I could.  I’d do better data reduction (to save on data warehousing) and maybe even ship everything up to be computed on one of the “clouds” at Google, Dell, or Amazon.  If I can do this sitting in my house at my laptop…

• A const reference.  I don’t want to copy it, but I promise not to modify it, either.
• A reference.  I might modify it.
• A copy.  I might modify my local copy, but not the original.  I’m getting a copy, after all.

Easy peasy in C++.  In Java?  Uh, I pass all objects by reference. The interface says nothing about modification.  Pass me a Map and maybe I’ll modify it, maybe not.  You don’t know, and you can’t enforce it.  Unless you pass me a Collections.unmodifiableMap().  Then my code might break!  There might be some odd little case left over where I do modify it, in spite of documentation comments to the contrary.  C++?  I declare it to be a const reference, and now the compiler will prevent me from modifying it.  I like that quite a bit.

I also like const methods, and you really can’t have const without const methods.  The Java way it to throw exceptions.  I’d rather have the compiler tell me something at compile-time than have the runtime system fail at runtime.  But I’m weird, I suppose.

Programming

I spend my time (recently) writing a mishmash of Python, C++, and Java. It’s interesting to switch back and forth.

What’s a good idea and what’s a bad (or dangerous) idea in computer language design? We’ve got a lot of candidates, and a lot of opinions.

I’ll list a few here, along with a few places where they show up. I’m not saying C macros are the same as, or even similar to, Lisp macros. Just trying to clarify the spectrum.

I’ve heard someone, at some point, say each one of the items below is a good idea / bad idea. Dangerous in the hands of a novice? Yes, but then so is any computer with a network connection.

• Preprocessors (C, C++)
• Macros (C, Lisp)
• Multiple Inheritance (C++, Smalltalk)
• Operator Overloading (C++, Python)
• Closures (Lisp, Haskell)
• Generics (Java, Ada)
• Template Metaprogramming (C++)
• Casts (C, C++)
• Strong or Weak Typing (Scala, Lisp, Python, ML)
• Fixed-Point Math (C# and COBOL)
• Fixed Integer Types vs. “Numbers” (C, Lisp, Python)
• Garbage Collection (Java, Lisp, ML)
• Manual Allocation / Deallocation (C, C++)
• Everything is an Object / Some Things are Primitives (Smalltalk, Java)
• Auto-(Un)Boxing (Java, C#)
• Indentation is Significant (Python)
• First-Order Functions (ML, Lisp)
• Lambdas (ML, Lisp, Python)
• Type Erasure (Java)

Did I leave out your favorite / most reviled language feature? Complain below. I included type erasure at the end of the list. Does anyone think this was a good idea for Java???

Sarah Palin

The Palin speech really is poetry. Read below. It makes me want to go to Alaska.

And getting up here I say:
It is the best road trip in America.
Soaring through nature’s finest show.
Denali, the great one,
Soaring under the midnight sun.
And then the extremes.

In the winter time it’s the frozen road
That is competing with the view
Of ice fogged frigid beauty.
The cold though.
Doesn’t it split the Cheechakos
From the Sourdoughs?

And then in the summertime,
Such extreme summertime.
About a hundred and fifty degrees
Hotter than just some months ago,
Than just some months from now,
With fireweed blooming
Along the frost heaves
And merciless rivers that
  are rushing
    and carving
      and reminding us that here, Mother Nature wins.

It is as throughout all Alaska
That big wild good life teeming
Along the road that is north
To the future.

I wonder who wrote it? It isn’t crazy-talk. “The cold though, doesn’t it split the Cheechakos from the Sourdoughs?” A cheechako is a newcomer to Alaska, while a sourdough is a long-time resident of Alaska. And “north, to the future?” That’s Alaska’s state motto. Denali? That’s the local Athabaskan name and official Alaskan name for Mount McKinley, and it means “The Great One.” It has greater bulk and rise that Everest, so it’s a good name.

Whatever else you might say about Palin, this part of the speech was directed to Alaskans, her constituency, and while people down here in the lower 48 might chuckle at it, it was actually a good political speech. It has nothing to do with the issue at hand — her resignation with a year and a half remaining — but then that is one of the hallmarks of a good political speech.

In short, don’t count Sarah Palin out. She may not get my vote, but if she learns to speak to the rest of America in this way then we can expect quite a bit from her in the coming years. After all, we’re suckers for poetry.

Programming

I recently heard about a Car Talk puzzler.  I don’t listen to Car Talk as much as I used to.  Anyway, you can read about the puzzler and the fellow who solved it here.  This is an excerpt.

During Christmas week on the popular National Public Radio show Car Talk, the weekly puzzler required listeners to find the longest English word that remains a valid English word as you remove its letters one at a time, but without rearranging any of the letters. For example: sprite, spit, pit, it, I. There are many such words, but, as Barr discovered, only one with 11 letters.

So, only one word with eleven letters: complecting.  Maybe.  I’m not convinced, but finding out is easy.

Recursion

Okay, so how would you know?  Well, suppose you had a list of valid words.  The statement of the problem suggests a simple recursive algorithm to find a solution.

• Put the words in a heap, ordered longest to shortest.
• Iterate until the heap is empty.
  • Take the next word $w$ from the heap, and perform $\mbox{search}(w)$

The procedure $\mbox{search}(w)$ works as follows.  It returns true if it finds a solution.

• If $w$ is the empty string, then return true.
• For each letter $l$ of $w$, do the following.
  • Drop $l$ from $w$, generating the candidate word $v$.
  • If $v$ is in the dictionary, then execute $r=\mbox{search}(v)$.
    • If $r$ is true, then write out $w$ and return true.
• The word $w$ is a dead end; drop it from the dictionary and return false.

Dropping the words from the dictionary, or otherwise marking them as dead ends in some other way is necessary to avoid re-searching them later.  The time complexity is roughly $O(n)$, where $n$ is the size of the dictionary to search.  If the average length of a word is $k$, then we can be more specific, and say the complexity is $O(kn)$, but $k$ is very small with respect to $n$, and does not vary much with the data size, so it can be safely ignored.

Iteration

The problem was explained to me in the reverse fashion.  Given a letter, generate words by adding a single letter at a time.  Every word must be in the dictionary.  Find the longest word you can generate from a single letter.  This suggests a different algorithm.

• Put the words in a heap, ordered shortest to longest.
• Mark the empty string as reachable and set $long$ to the empty string.
• Iterate through the heap, considering each word $w$.
  • For each position $i$ of $w$, do the following.
    • Drop the $i$th letter from $w$, generating the candidate word $v$.
      • If $v$ is marked as reachable, then mark $w$ as reachable by omitting $i$, and set $long=w$.
• While $long$ is not the empty string, do the following.
  • Write $long$.
  • Omit the character $i$ by which $long$ was reached, and set $long$ equal to the new word.

We can improve this by checking against the length of the longest word reached.  If we ever have $|w|>|longest|+1$, then we can stop the loop immediately, since we cannot reach any further words.  We can’t do that with the prior algorithm.

So… What’s the Longest Word?

The solution given was complecting, at 11 letters.  When I download the aspell dictionaries, and run the algorithm (the iterative one), I find the following derivation.

-> a
-> ah
-> ach
-> bach
-> banch
-> banchi
-> branchi
-> branchia
-> branchiae
-> branchiate
-> abranchiate
-> abranchiates

Ooh.  12 letters.  But, it’s a plural.  Does that count?  Well, complecting is a participle, so it seems it should.  Time to send a note to Tom and Ray?

So… Which Algorithm?

Well, I coded up the iterative one in Java, since originally I was asked how I would code it in Java.  Again, the question suggesting the solution.  I suspect there are a lot of long words that are not reachable, so it seemed better to use the trick to terminate the search when the current word is longer than the longest found (so far) plus one.  Plus, it isn’t recursive, and I don’t have to modify the data structure by deleting an item from the heap.

The Java

So… here’s the Java source.  Enjoy!

/**
 * Given some iterable object that provides strings, find the longest
 * string in the collection that can be reached from the empty string
 * by adding one character at a time such that every intermediate step
 * is also in the collection.
 *
 
 * For example, if the collection is {@code {@literal {}a,
 * at, cat, chat, chart, cart, car{@literal }}},
 * then the longst word is {@code chart}, and it's derivation is:
 * {@code a => at => cat => cart => chart}.  If there are multiple
 * longest words, then only one is detected.
 *
 
 * Note that if single letters are not in the collection, then no words
 * can be derived, and only the empty derivation is returned.
 *
 * @param strings    An iterable providing the strings.
 * @return    The derivation of the longest, from the shortest word to the
 *             longest.  If there is no longest word, then the empty
 *             derivation is returned.
 */
public List search(Iterable strings) {
    if (strings == null) {
        throw new NullPointerException("The string iterator is null.");
    }
 
    // Read each string from the iterable.  The strings assumed to be
    // single words, and the words are not assumed to occur in any
    // particular order.  We put the words we read into a heap, ordered
    // by length.  Our "heap" is a sorted map.
    //
    // Every entry in the map has an associated integer value, which
    // tells us the position of the last inserted character.  This can
    // be used to "unwind" the derivation of the word.  If there is not
    // (yet) any way to reach the word, then the word is mapped to -1.
    TreeMap heap =
        new TreeMap(new Comparator() {
            public int compare(String first, String second) {
                // Okay, we sort first by length, and then alphabetically.
                // This is necessary because of the way TreeMap tests
                // equality; it uses the comparator.  Thus we must only
                // return zero if the two are actually equal.  So, we
                // first order by length, and then for items of the same
                // length, we order using the natural comparator for
                // strings.
                int order = first.length() - second.length();
                if (order == 0) {
                    order = first.compareToIgnoreCase(second);
                }
                return order;
            }
        });
    for (String str : strings) {
        heap.put(str,-1);
    } // Add all strings to the heap.
 
    // Prime the pump by adding the empty string as "reachable."
    String longest = "";
    int length = 0;
    heap.put("", 0);
 
    // At this point the heap is constructed.  We now iterate over the
    // heap looking for connected words.  If we find one, we mark it.
    for (String str : heap.keySet()) {
        // Watch for a case where we skip a length.  If we do, we're done.
        if (str.length() > length+1) {
            break;
        }
        length = str.length();
 
        // Now we have a string, we need to find out if the string is
        // reachable from a previously-reached string.  We drop each
        // character, and then check if the resulting string is
        // present in the heap and is marked.
        for (int index = 0; index < str.length(); index++) {
            // Omit the character at position index.
            String test = str.substring(0,index) + str.substring(index+1);
            // See if the resulting test string is in the heap.
            Integer pos = heap.get(test);
 
            // Now there are three cases:
            // (1) The test string is not in the heap.
            // (2) The test string is in the heap, but not reachable.
            if (pos == null || pos < 0) {
                continue;
            }
            // (3) The test string is in the heap, and is reachable.
            // In this last case we know we can reach the current string
            // from the test string by adding the character at position
            // index, so put this in the heap.
            heap.put(str, index);
            // Note that whenever this happens, we might have just found
            // (one of) the longest words, so save it.
            longest = str;
            // We don't need to test any other positions.
            break;
        } // Construct new words by omitting each character.
    } // Search the heap for words.
 
    // Now we have (hopefully) found a long word.  We need to generate
    // the derivation and return it.
    List derivation = new LinkedList();
    while (longest.length() > 0) {
        // Get the insertion position from the heap.
        int pos = heap.get(longest);
        // Add the word to the derivation.
        derivation.add(0, longest);
        // Generate the prior string in the derivation.
        longest = longest.substring(0, pos) + longest.substring(pos+1);
    } // Build the derivation.
 
    // Done!  Return the derivation.
    return derivation;
}

The code isn’t optimal, but it is commented. I assume you are all capable of putting this in a class and feeding it a dictionary. Have fun!

Apple

For the record, here’s how I set the MAC address on my MacBook Pro. As I write this it is running Leopard 10.5.6 and this has been working successfully with every version of Leopard. In fact, it has worked so well I’d forgotten how I did it, so I’m basically writing this post so, if it ever stops working, I will know how to fix it. If it helps you, all the better. If it hurts you… well… don’t blame me.

Note that, for reasons obscure, I want to permanently set the MAC address to something other than the hardwired address. If that’s not what you want, this recipe might not be for you.

For the record I found the information on creating the startup item here.

First create a directory under the /Library/StartupItems folder.

sudo mkdir /Library/StartupItems/MACADDR

That’s MACADDR for MAC ADDRess, in case you’re wondering. I made it all caps so it would be more obvious to me in listings.

Next create the file /Library/StartupItems/MACADDR/StartupParameters.plist. I used VI, but that’s me. Use whatever editor you want.

sudo vi /Library/StartupItems/MACADDR/StartupParameters.plist

This file needs to have the following content.

<?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE plist SYSTEM "file://localhost/System/Library/DTDs/PropertyList.dtd">
  <plist version="1.0">
    <dict>
      <key>Description</key>
      <string>Set the MAC address for specified interfaces.</string>
      <key>OrderPreference</key>
      <string>None</string>
      <key>Provides</key>
      <array>
        <string>MACADDR</string>
      </array>
      <key>Requires</key>
      <array>
        <string>Network Configuration</string>
      </array>
    </dict>
  </plist>

I think the Requires part is correct; I stole that from looking at the configuration files for tun and tap, since this needs to happen before the network is brought up. It might be a better idea to specify an order, but I have not had trouble leaving it as None.

Next create the file /Library/StartupItems/MACADDR/MACADDR. I think this file needs to have the same name as the directory, so if you don’t like MACADDR be sure to use the same name for both the directory and this file.

vi /Library/StartupItems/MACADDR/MACADDR

This file needs to have the following content, where ADDRESS is replaced with the MAC address you want.

#!/bin/sh
. /etc/rc.common
 
##
# Configure the MAC addresses of network interfaces.
##
#
# This script will set the hardware MAC address for the specified
# interface(s).  The name of the interface (ex. en0) must be edited
# to match the interface.
#
# Typically the built-in ethernet card is en0, and the built-in
# wifi card is en1.
#
##
 
# The start subroutine.
StartService() {
  ConsoleMessage "Configuring MAC address"
  if [ "${MACADDR:=-NO-}" = "-YES-" ]; then
    # Make sure the wifi card has the correct MAC address.
    /sbin/ifconfig en1 lladdr ADDRESS
  fi
}
 
# The stop subroutine.
StopService() {
  return 0
}
 
# The restart subroutine.
RestartService() {
  # It might be nice to make this reset the address, but it's never come up.
  return 0
}
 
RunService "$1"

Again, if you change the name from MACADDR make sure to also change it in this file. Also, do not forget to replace ADDRESS with the MAC address you want to use.

These two files create a service that gets started when the Mac boots up. This “service” just sets the MAC address of the wireless card. Note that if you are running on Tiger you will probably need to use ether instead of lladdr in the ifconfig line.

If you find problems with new versions of OS X, or if I’ve done something boneheaded above, please add a comment below.