I’ve been watching political debates today, on This Week, on the web, on the news, and in the blogosphere. The Fourth Estate in this country seems to be in a bad state.  Surely Blitzer is no Cronkite, but what of the others?  What do we as a people value in our news?

Well, TV Guide has a list of highest-paid news anchors.  Top of the heap?  Matt Lauer, at $21.5 million.  Next in line?  Bill O’Reilly, at $15 million.  So these are the pinnacle of “news anchors,” and they aren’t really news anchors, are they?  In at number three is an actual news anchor: Brian Williams, at $13 million.  Read the list yourself here.  Oh… and Jon Stewart?  $16 million.  Take that, Brian Williams!

You know who I miss?  Baghdad Bob.  There was s certain kind of honesty to his dishonesty that I now find refreshing.  It was as if everything he said was followed by a wink.  Yes, I know that you know that I know this is not true, so this isn’t really a lie.  He wasn’t trying to deceive us, he was just doing his job – which involved making grossly untrue statements – honestly and to the best of his ability, and in a way that’s admirable.

Muhammad Saeed al-Sahhaf wasn’t really talking to us, of course.  His job was to repeat what he was told – propaganda for Iraqis.  And he probably wasn’t lying – I believe him when he says he was told what to say by very reliable sources.  As reliable as you can get in a totalitarian state, of course.

So what became of him?  Well, coalition forces captured him and briefly interrogated him in 2003, but then let him go.  After all, he wasn’t really a bad fellow… just misinformed and employed by a homicidal dictator.  He wasn’t part of Saddam’s inner circle, and was really in an impossible situation.  He currently resides in the UAE with his family living a quiet – and let’s hope happy – life.  He’s working on a book, because that’s what you do when you retire – or are retired – from public life.

Some called him Comical Ali, some Saddam’s Optimist, but to me he will always be Baghdad Bob.  Best of luck to you, Bob.  And happy trails.

I don’t post personal information – my posts can’t be said to be informative in any legitimate sense – so I’m not concerned about that. What I do get from Facebook is a mix of humor (some seriously offensive), exposure to ideas and people with whom I agree and sometimes deeply disagree, recipes for lemon squares and tiny cakes, videos of adorable animals and parkour-gone-bad, and a host of other, less definable social buzz.

I don’t read the newspaper – who does? How else am I to know about the new Buddhist video game or the iPhone 6? I read books (on my phone), read the Economist (on my phone), watch a limited quantity of TV, read certain blogs (on my phone), and listen to the radio (on my phone). Facebook fills that hole left in me that craves news about Ted Nugent running for president and the latest exploits of grumpy cat.

More importantly, Facebook keeps me in touch with people I like and miss, and does so in a funny, asynchronous way that melds into my daily life. And therefore though it has never put a scrap of gold or silver in my pocket, I believe that Facebook has done me good, and will do me good; and I say, God bless it!

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.

Skepticism

So far I’ve managed to strongly disagree with folks on the following topics.

• Obama was born in Kenya.
• The 9/11 disaster was staged by the United States government.
• Cell phones cause cancer.

I assert that we do not have enough evidence to accept any of the above statements.  I don’t claim they are false, just that there is not sufficient evidence to conclude that they are true… or even likely.

The above are all possible. People are born in Kenya. The United States government has staged events. Cancer has myriad causes, and we discover new ones often. The trick is that we don’t have sufficient evidence that has withstood scrutiny to believe any of the above, and do have evidence to reject them. I wonder if adherents want them to be true? I can’t imagine why they would, except maybe for the Obama born in Kenya one.

Of course the folks who hold these views believe they have evidence. In the Obama case it’s inconsistent and (in some cases) manufactured. In the 9/11 case it’s considerably better, and includes some apparent physical evidence. In the cell phone case it’s even better, with thermal and non-thermal mechanisms proposed. In the 9/11 case the evidence does not withstand scrutiny. In the cell phone case any effects appear to be just outside the consistently measurable range.

I’m reminded of polywater and N-rays. It is necessary to subject your own beliefs to skepticism. You also need to know that the failure to disprove your beliefs does not make them true. You can be right when everyone else is wrong… but you can be wrong, too.

So, I remain skeptical about the above, in the same way I’m skeptical about many other claims. If you believe something is truly significant, and you plan to commit a considerable part of your life to it, you should, I think, subject it to rather strong skepticism before taking the plunge… and after, as well. It’s the latter that is most difficult, of course. One of my favorite quotations is a supposed Turkish proverb: No matter how far you have gone down the wrong road, turn back.

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.