1. Back in 1961 people of color were called ‘Negroes.’ So how can the Obama ‘birth certificate’ state he is ‘African-American’ when the term wasn’t even used at that time?

2. The birth certificate that the White House released lists Obama’s birth as August 4, 1961. It also lists Barack Hussein Obama as his father. No big deal, right? At the time of Obama’s birth, it also shows that his father is aged 25 years old, and that Obama’s father was born in ” Kenya , East Africa “. This wouldn’t seem like anything of concern, except the fact that Kenya did not even exist until 1963, two whole years after Obama’s birth, and 27 years after his father’s birth. How could Obama’s father have been born in a country that did not yet exist? Up and until Kenya was formed in 1963, it was known as the ” British East Africa Protectorate”.

3. On the birth certificate released by the White House, the listed place of birth is “Kapi’olani Maternity & Gynecological Hospital “. This cannot be, because the hospital(s) in question in 1961 were called “KauiKeolani Children’s Hospital” and “Kapi’olani Maternity Home”, respectively. The name did not change to Kapi’olani Maternity & GynecologicalHospital until 1978, when these two hospitals merged. How can this particular name of the hospital be on a birth certificate dated 1961 if this name had not yet been applied to it until 1978?

So let’s consider this, and take it one piece at a time.

1. Back in 1961 people of color were called ‘Negroes.’ So how can the Obama ‘birth certificate’ state he is ‘African-American’ when the term wasn’t even used at that time?

Well, Obama’s “long form” birth certificate (released in April of 2011) does not state that Obama is an African-American.  It states that the father’s race is “African.”  The term “African” was used for native-born Africans, such as Obama’s father.  I really don’t think there is any reason to dig further here, given how obviously bad the next two claims apparently are.

2. Kenya did not even exist until 1963, two whole years after Obama’s birth, and 27 years after his father’s birth. How could Obama’s father have been born in a country that did not yet exist? Up and until Kenya was formed in 1963, it was known as the ” British East Africa Protectorate”.

Wow.  This required a trip to Wikipedia.

The British Empire established the East Africa Protectorate in 1895, known from 1920 as the Kenya Colony. The independent Republic of Kenya was founded in December 1963.

The East African Republic of Kenya has been called Kenya for a long time, apparently named after Mount Kenya.  (Aside: Have you watched The Ghost and the Darkness? Tasvo is in Kenya.)  While it didn’t get full independence from Britain until 1963, it was called Kenya, Kenya Colony, and The Colony of Kenya, and that is how Obama’s father would have identified it to the doctors, etc., especially since they were seeking independence at this time, to be achieved in 1963.  “Where are you from?”  “Kenya.”

Of course there is no reason to believe Wikipedia, but the conspiracy must be massive, because the name “Kenya” is everywhere prior to 1963.  A quick search on Google books turns up this book (The Akamba in British East Africa, by Gerhard Lindblom) from 1920 that talks about Kenya as if it were… well… Kenya.

Finally, here’s a map from 1950.  Have a look.  You know where Kenya is, right?  About halfway down the eastern side of the continent.

3. On the birth certificate released by the White House, the listed place of birth is “Kapi’olani Maternity & Gynecological Hospital “. This cannot be, because the hospital(s) in question in 1961 were called “KauiKeolani Children’s Hospital” and “Kapi’olani Maternity Home”, respectively. The name did not change to Kapi’olani Maternity & Gynecological Hospital until 1978, when these two hospitals merged.

I visit Wikipedia again, and find this.

In 1931, its name was changed to the Kapi?olani Maternity and Gynecological Hospital.

Of course there is no reason to believe Wikipedia.  But then it didn’t take long to call the hospital and ask about the name.  I have Sprint’s “everything” plan, so it’s also (relatively) cheap to call.  Apparently they do get asked, because I got the answer pretty quickly.  1931.  Others have been over this, too.  I won’t beat on this issue when others have covered it so extensively.

My Ubuntu 11.10 Desktop

At the risk of drawing universal hatred, Unity isn’t so bad once you set the icon bar to autohide. Very uncluttered, quite stable, and even with no hardware acceleration it has good performance. That said… I don’t like it.

So what to do? Everyone has been fleeing to Mint, but I’ve had stability problems, which is odd since it is basically just Ubuntu with some minor changes. I really like MintMenu, but Mint’s not an “approved” OS at work, so I need to use Ubuntu.

Here’s what I do to the stock Ubuntu 11.10 “Oneric” installation to make it habitable (for me – YMMV).

Most of this is taken from other web sites I’ve forgotten. A good resource is this one: http://www.webupd8.org/2011/10/things-to-tweak-after-installing-ubuntu.html

You can install MintMenu or GnoMenu in the Cairo dock and dispense with Gnome shell… but I actually like the “expose” feature when I hit the Window key, so I’m keeping Gnome shell for now.

Install Ubuntu 11.10. Log in with the Unity interface. Open a terminal and let’s do the following.

• Install Synaptic.
• sudo apt-get install synaptic
• Fix the scroll bars. This will give you real scroll bars, but you’ll really need to reboot at some point to be sure the evil overlay library is gone.
• sudo apt-get remove overlay-scrollbar liboverlay-scrollbar3-0.2-0 liboverlay-scrollbar-0.2-0
• Install Sun Java instead of OpenJDK.
• sudo add-apt-repository ppa:ferramroberto/java
• sudo apt-get update
• sudo apt-get install sun-java6-jdk sun-java6-plugin
• sudo update-alternatives --config java
• Now select the Sun JDK. If for some reason you didn’t get OpenJDK during the install, you won’t have any other Java versions to select, and that’s okay.
• Mint uses the Gnome Shell, so let’s install that and some settings managers.
• sudo apt-get install gnome-shell gnome-tweak-tool compizconfig-settings-manager dconf-tools
• Incidentally, at this point if you run ccsm you can actually turn off Unity! Don’t do that yet; let’s replace it with something else first.
• Make Gnome Shell the default for logging in.
• sudo /usr/lib/lightdm/lightdm-set-defaults -s gnome-shell

• Let’s install the old-style Gnome desktop, too.
• sudo apt-get install gnome-session-fallback
• Log out. Click the little gear and select “GNOME” and log back in. Now you’re running Gnome shell, and not Unity. Congratulations!  You can also select the Gnome with no fancy stuff, but then you have panels at the top and bottom (I’m going to add Cairo), and the default menu doesn’t allow typing names.
• Install the Cairo dock. I like docks, and Cairo (so far) seems to be the most stable and best option.
• sudo apt-get install cairo-dock
• Now, I like Alt+F2 to bring up the “run a command” dialog. Let’s enable that.
• Click your name in the upper right and select System Settings.
• Click Keyboard and then switch to the Shortcuts tab.
  Select System.
• Double-click the “Show the run command prompt” item. It should change from “Disabled” to “New shortcut…”
• Type Alt+F2.

Now, if you’re me, you want to install the following, with apt-get install.

• vim
• emacs
• eclipse
• g++
• cmake
• ant
• git
• subversion

I like to have Scala, but I don’t install it from the packages. They scatter it around a bit, and this confuses some software like the Idea IDE. Besides, you should keep it up to date with sbaz.

• To install Scala globally from a terminal do the following. Of course, you can install it for just you, and that might be what you want in some cases.
• wget http://www.scala-lang.org/downloads/distrib/files/scala-2.9.1.final.tgz
• cd /usr/local
• sudo tar xvzf ~/scala-2.9.1.final.tgz
• sudo ln -s scala-2.9.1.final scala
• cd bin; for file in ../scala/bin/* ; do if [ -x $file ] ; then sudo ln -s $file ; fi ; done
• The last command makes all the scala stuff visible to both regular users and to root, which is useful, since this lets root run sbaz. You can avoid all this by just installing scala under your home area and then adding its bin folder to your path. I assume you are all capable of that.
• sudo sbaz install scala-devel-docs scala-documentation

And that’s it!

Ooh!  See this.

The real issue with Gosu, however, is documentation.  A quick search for Gosu turns up http://gosu-lang.org/.  From this you can find a quick start guide and comprehensive documentation.  Great!  I read the quick introduction and then download the distribution.  It’s nice!  It comes with a lightweight IDE and an interactive “REPL” mode.  That’s what I like to see.  Next, I dig into the comprehensive documentation… but examples from the documentation don’t work!

For instance, the documentation of DateTime (here) says:

Gosu implicitly coerces the Gosu DateTime object from String in most formats. For example:

var date : DateTime = "2007-01-02"

Nifty!  I try that and I get:

program_.__Program__0

Errors: 

The type "java.lang.String" cannot be converted to "java.util.Date" [line:1 col:23] in
line 1: var date : DateTime = "2007-01-02"
Expected Type: Date
Line Number: 1  Column: 23

That doesn’t seem like automatic coercion to me.  Never one to give up without a fight, I post the following message to the Gosu forum:

The following code:

var date : DateTime = “2007-01-02″

taken directly from the Gosu DateTime page fails to compile with the
following errors:

Errors:

The type “java.lang.String” cannot be converted to
“java.util.Date” [line:1 col:23] in
line 1: var date : DateTime = “2007-01-02″
Expected Type: Date
Line Number: 1  Column: 23

This is also true if one tries “Jan 2, 2007″ as DateTime.
So… What am I doing wrong?

$ gosu -version
0.8.6.1-C

$ javac -version
javac 1.6.0_26

$ java -version
java version “1.6.0_26″

Java(TM) SE Runtime Environment (build 1.6.0_26-b03)
Java HotSpot(TM) 64-Bit Server VM (build 20.1-b02, mixed mode)

$ uname -rm
3.0.0-13-generic x86_64

Thanks in advance.

I expect something along the lines of “wrong version of Java,” or “you’re an idiot because.”  Instead, I receive this:

In the open source version of Gosu we don’t support the implicit string to
date coercion.  You’ll have to use the .toDate() method on String instead:
var date  = “2007-01-02″.toDate()

Cheers,
Carson

Okay, great.  Apparently there is an open source version of Gosu and a closed source version.  I google in vain for information on these, but none appears.  Searching the documentation for “open source” turns up nothing.  Everything I read says Gosu is released under the Apache license, and nothing seems to indicate otherwise.  So… Clearly the comprehensive documentation is either wrong or incomplete.  I’m not happy with either.

I did reply asking where the differences are documented.  I’ll post here whatever I hear back.  I’ve probably missed some obvious, glaring, probably blinking notice about the differences.

So no Gosu for us, at least for now.

(1) Use the singular they. Shakespeare did. It is far superior to the alternatives. Why should every unknown person be a he or a him?

“If a person wants to use the singular they, they should.”

(2) Split infinitives with singe words. This is an idiotic, idiotic rule created by idiots because they are too idiotic to know better. Idiots. Avoid the temptation to perhaps understandably, perhaps even defensibly and rationally, but still annoyingly, go crazy.

“Sentence diagrams are hard to easily do when you split your infinitives!”

(3) End your clauses with prepositions whenever you feel like it. See the previous comment. Note that the “prohibition” against this has never existed, except in the small, closed minds of amateur prescriptivism. Professional prescriptivisits know this. “P-stranding?” Having a fancy name for it doesn’t make it right.

“That’s where it’s at!”

(4) Coordinating conjunctions can join anything to anything. Syntactic importance be damned!

“I was going to have an example, and that’s when I thought, damn, I need an example. And so I wrote this. And here it is. Now what?”

(5) Dangle hopefully. We all know what you mean.

“Hopefully no grammarian’s head will explode when they read this.”

(6) Make up your own words. “Graphic” isn’t graphic enough for you? Try graphical! It’s twice the adjective!

“I admire the realisticism of your new poster. It’s like I’m literally there!”

Some things actually do bother me, but they tend to be in the “poor communication” category. That is, if you write something and folks cannot tell what you mean, you need help.

Don’t get me wrong. It is important to know the rules. Then you can know when you are breaking them, decide which ones to break, and still get your point across. Even with fragments.

Now I’m tinkering with Scala, and it occurred to me to write a Sudoku solver tonight.  So just over an hour later I have one, and I’m posting it here.  I make no claims about this being the right way to do things, or even a good way to do things.  In particular, it uses a dumb algorithm to solve Sudoku, and probably isn’t done The Scala Way.  In fact, I’m actually posting this so you can tell me where I’ve gone wrong, should have done things differently, etc.

Plus, if you want a Scala Sudoku solver, well, here’s one.  Enjoy!

Use this in one of three ways.

1. Compile it and run it from the prompt. Enter the board one line per row.
2. Load it into a running Scala REPL and use Board.init to interactively enter the board, one line per row. Use the search method to find a solution.
3. Put the board in a file and use Board.read from the Scala REPL to load the board. Use the search method to find a solution.

/**
 * Simple Sudoku solver.
 * 2010 by Stacy Prowell.
 * http://stacyprowell.com/
 */
package sjp.sudoku
 
/**
 * An exception indicating that the board has no solution.
 * @param msg  A message.
 * @author sprowell
 */
class BadBoardException(msg:String) extends Exception(msg)
 
/**
 * Helper class for search data.
 * @param fails  Number of failures detected so far during the search.
 * @author sprowell
 */
protected class SearchData(var fails:Int = 0)
 
/**
 * A ''board'' holds two items.
 * - The currently known cell values
 * - The set of possible values for each unknown cell
 * 
 * @author sprowell
 */
class Board {
 
  /** Size of board. */
  val N = 9
 
  /** Representation of an unknown cell. */
  val U = ' '
 
  /** Known values in the grid. */
  val known = Array.ofDim[Char](N,N)
  for (i <- 0 until N; j <- 0 until N) known(i)(j) = U
 
  /** Allowed possibilities for each cell. */
  val possible = Array.ofDim[Set[Char]](N,N)
  for (i <- 0 until N; j <- 0 until N) possible(i)(j) = '1' to '9' toSet
 
  /**
   * Generate a string representing the current state of a cell.
   * There are two possiblities.
   * - `(5,4)=9` if the cell value is known
   * - `(5,4) allows {3,9}` if the cell value is now known
   * @param row  The zero-based row.
   * @param col  The zero-based column.
   * @return  The cell representation.
   */
  def cellToString(row:Int, col:Int) = {
    require(row >= 0 && row < N)
    require(col >= 0 && col < N)
    (row,col) +
      (known(row)(col) match {
        case U => " allows {" + possible(row)(col).mkString(",") + "}"
        case c => "=" + c
      })
  }
 
  /**
   * Set a cell to the given value.  This also updates the set of possible
   * values for each cell.
   * @param row  The zero-based row.
   * @param col  The zero-based column.
   * @param ch  The character, 0-9.
   * @return  The updated board.
   */
  def set(row:Int, col:Int, ch:Char):Board = {
    /**
     * Tiny local function to exclude a value from the possibilities for
     * a cell.
     * @param rr  The zero-based row.
     * @param cc  The zero-based column.
     * @return  True if the cell is solved, false if it is not.
     * @throws  BadBoardException  There is no longer any viable solution.
     */
    def exclude(rr:Int, cc:Int, ex:Char) = {
      if (possible(rr)(cc) contains ex) {
        possible(rr)(cc) -= ex
        possible(rr)(cc).size match {
          case 0 => throw new BadBoardException(cellToString(rr,cc) +
            " has no possibilities")
          case 1 => true
          case _ => false
        }
      }
      false
    }
 
    // Check the arguments.
    require(row >= 0 && row < N)
    require(col >= 0 && col < N)
    require('1' <= ch && ch <= '9')
 
    // The proposed value must be allowed for the cell.
    if (known(row)(col) != U && known(row)(col) != ch)
      throw new BadBoardException(cellToString(row,col) + " cannot be " + ch)
    if (!possible(row)(col).contains(ch))
      throw new BadBoardException(cellToString(row,col) + " cannot be " + ch)
 
    // Record any cells that get solved along the way.
    var also = List[(Int,Int)]()
 
    // Cannot have same value in row or column.
    for (i <- 0 until N) {
      if (i != col && exclude(row,i,ch)) also = (row,i)::also
      if (i != row && exclude(i,col,ch)) also = (i,col)::also
    } // Exclude in row and column.
 
    // Cannot have same value in block.
    val (brow,bcol) = (row/3*3,col/3*3)
    for (i <- 0 to 2; j <- 0 to 2) {
      val (rr,cc) = (brow+i,bcol+j)
      if (rr != row && cc != col && exclude(rr,cc,ch)) also = (rr,cc)::also
    } // Exclude in block.
 
    // Fix up the cell.  Set known and the set of possibilities.
    known(row)(col) = ch ; possible(row)(col) = Set(ch)
 
    // Done.  Now check to see if we discovered any other values.
    // If so, then set those now, recursively.
    also foreach {
      case (rr,cc) => set(rr,cc,possible(rr)(cc).head)
    } // Set each discovered solved cell.
    this
  }
 
  /**
   * Create a duplicate of this board.
   * @return  An independent clone of this board.
   */
  override def clone = {
    val cl = new Board()
    for (i <- 0 until N; j <- 0 until N) {
      cl.known(i)(j) = known(i)(j)
      cl.possible(i)(j) = possible(i)(j) 
    } // Duplicate known and possible.
    cl
  }
 
  /**
   * Initialize a row.  This is only intended to be used from the
   * companion object's init.  The provided string can be any length;
   * only the first N or fewer characters are used.
   * @param row  The zero-based row.
   * @param vals  A string of the values in that row.
   * @return  The updated board.
   */
  private def init(row:Int, vals:String) = {
    require(row >= 0 && row < N)
    require(vals.length <= N)
    var col = 0
    vals.foreach{ch => if (ch != U) set(row,col,ch) ; col += 1}
    this
  }
 
  // Import used below.
  import java.io.{Writer,FileWriter}
 
  /**
   * Write the board to the given writer.
   * @param writer  The writer to get the output.
   */
  def write(writer:Writer) {
    writer.write(known.map(row => row.mkString("")).mkString("\n"))
    writer.flush()
  }
 
  /**
   * Write the board to the given file.
   * @param file  The file name.
   */
  def write(file:String) {
    write(new FileWriter(file))
  }
 
  /**
   * Pretty-print the board.
   * @return  String representing the current known state of the board.
   */
  override def toString() = {
    def rts(row:Int) =
      known(row).slice(0, 3).mkString("") + " | " +
      known(row).slice(3, 6).mkString("") + " | " +
      known(row).slice(6, 9).mkString("") + "\n"
 
    var str = ""
    for (rblock <- 0 until N by 3) {
      if (rblock != 0) str += "----+-----+----\n"
      for (roff <- 0 to 2) {
        str += rts(rblock+roff)
      }
    } // Format all blocks.
    str
  }
 
  /**
   * Search for a solution.
   * @return  Solution, if one is found.
   */
  def search():Option[Board] = search(new SearchData(0))
 
  /**
   * Search for a solution.
   * @param sd  Search data block.
   * @return  Solution, if one is found.
   */
  private def search(sd:SearchData):Option[Board] = {
    // Get the cells that are currently unknown, and get the possibilities
    // for each.
    def unknowns = {
      for (i <- 0 until N; j <- 0 until N if known(i)(j) == U)
        yield (i,j,possible(i)(j))
    }
 
    // If all cells are known... We are done!
    if (unknowns.length == 0) {
      printf("Solution found:  fails=%d\n", sd.fails)
      return Option(this)
    }
 
    // Randomly choose an unknown
    val (row, col, choices) = unknowns(scala.util.Random.nextInt(unknowns.length))
 
    // Try each choice for the unknown cell.
    choices foreach {
      ch =>
      // Copy the board and set the value.  Then recursively seek a
      // solution.  If we find one, we are done.
      val newboard = clone
      try {
        newboard.set(row, col, ch)
        val soln = newboard.search(sd)
        if (soln.isDefined) return soln
      } catch {
        case e:BadBoardException => sd.fails += 1
      }
    } // Trying each choice.
    None
  }
}
 
/**
 * Companion object to the board class.  Provides methods to make and
 * initialize a board.
 *
 * @author sprowell
 */
object Board {
 
  /**
   * Convenience method to make a new board.
   * @return  A new board.
   */
  def apply() = new Board()
 
  import scala.io.Source
 
  /**
   * Read a file into a new board.  The file should consist of nine lines,
   * with each line a sequence of digits and unknown markers (typically a
   * space).  This designates the initial board.
   * @param file  The file path.
   * @return  The new board.
   */
  def read(file:String):Board = read(Source.fromFile(file))
 
  /**
   * Read a file into a new board.  The file should consist of nine lines,
   * with each line a sequence of digits and unknown markers (typically a
   * space).  This designates the initial board.
   * @param source  The source providing the data.
   * @return  The new board.
   */
  def read(source:Source):Board = {
    val board = new Board()
    var row = 0
    for (line <- source.getLines) {
      if (line.length > 0) board.init(row, line)
      row += 1
    } // Read all rows.
    board
  }
 
  /**
   * Interactively initialize a board by requesting nine lines of text
   * from the user.  Each line should consist of digits and unknown markers
   * (typically a space).  This is the initial board.
   * @return  The new board.
   */
  def init:Board = {
    val board = new Board
    for (row <- 0 until board.N) {
      val line = Console.readLine("Row %d: ", row)
      board.init(row, line)
    } // Read all rows.
    board
  }
}
 
/**
 * Application entry point when run from the prompt.  Initialize a board
 * using user input, solve it, and print the solution.
 *
 * @author sprowell
 */
object Sudoku {
  /**
   * Entry point when run from the prompt.
   * @param args  Command line arguments (ignored).
   */
  def main(args:Array[String]) {
    Board.init.search() match {
      case None => println("No solution.")
      case Some(b) => println(b)
    }
  }
}

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…