Kevin on Code

My Programming Reading List

2011-12-22T12:48:00.000-08:00

I started collecting links to reading materials for programmers recently for my own use, but I realized it could be more generally useful. Checkout my list here, and check back often for updates:

Kevin’s Programming Reading List

My Git Setup

2011-12-07T04:59:00.000-08:00

Mostly for my own personal future reference, here is how I setup my Git environment.

Multiple Accounts

I love Git for source control, and it is a goal of mine to keep all of my personal projects on GitHub. That is easy enough, but for work, I also need to be able to use Git with two different accounts connecting to two different servers.

For this example, I am going to assume there are two accounts: a GitHub account associated with a personal email, and an account hosted on an imaginary GitDude service associated with a work email.

Step 1: Create RSA Keys

Generate a key for GitHub:
ssh-keygen -t rsa -C "personal_email@example.com"
When prompted, choose the following location for your file to go:
/Users/your_username/.ssh/id_rsa_github
Follow instructions in the "Set up Git" section on http://help.github.com/ to upload your public key to GitHub. On the same page, follow the instructions for setting your github.user and github.token config values.
Generate a key for GitDude:
ssh-keygen -t rsa -C "work_email@example.com"
When prompted, choose the following location for your file to go:
/Users/your_username/.ssh/id_rsa_gitdude

Step 2: Setup Config File

Create a blank file called "config" in your ~/.ssh directory.

Edit the file, and type the following text:

Host gitdude.com
  HostName git.gitdude.com
  User git
  IdentityFile /Users/your_username/.ssh/id_rsa_gitdude

Host github.com
  HostName github.com
  User git
  IdentityFile /Users/your_username/.ssh/id_rsa_github

Step 3: Setup User Name and Email

When using only one account on a computer, you can use global settings for user.name and user.email. However, when using two separate accounts, you need to use local settings for each repo. If you want to still use global settings, you will still need to use local settings for the repos that don't use the global credentials.

See this to get a list of all global settings:
git config --global -l
Use this to set global git info:
git config --global user.name "First Last"
git config --global user.email "your_email@example.com"
Or this for local:
git config --local user.name "First Last"
git config --local user.email "your_email@example.com"

Same for github.user and github.token properties, if appropriate.

Step 4: Setup Default Editor

In order to write multiline commits, you will want to associate git with an editor:

    git config core.editor emacs

This allows you to make commits like "git commit". The editor will then open and allow you to enter a commit message.

References

Non-Locking Concurrency Control

2011-11-30T10:27:00.001-08:00

At work this week I have been working on implementing a concurrency control strategy on a system. During the discussions, software transactional memory (STM) came up, as we want to develop a solution that does not involve locking, and since my primary experience with it is Clojure's built-in STM, I brought that up.

The world seems to be helping out today with a link on Hacker News to an old discussion involving Clojure's creator Rich Hickey: Clojure: STMs vs Locks. Good food for thought.

It is great to see that my Clojure knowledge is proving to be surprisingly useful at work. Those years of being a closeted functional programming nerd are paying off!

I also re-watched Rich Hickey's talk "Are We There Yet?" and reread "Equal Rights for Functional Objects" by Henry G. Baker, which are both great resources for really thinking about state in a functional manner.

My Clojure Environment Setup

2011-11-20T00:36:00.000-08:00

Mostly for my own personal future reference, here is how I setup my Clojure environment.

Emacs

Install Emacs 24 (links to the binaries available here).
Install the Emacs Starter Kit or the Emacs Prelude.

Leiningen
Based on instructions from Leiningen (github.com).

Get the Leiningen batch script from https://raw.github.com/technomancy/leiningen/master/bin/lein.bat and edit it to fetch version 1.6.1.1 instead of 2.0.0-SNAPSHOT.
Put lein.bat in a folder. Add that folder to your PATH.
Download wget.exe and curl.exe and add them to your PATH.
Run:
lein self.install

Setting Up Emacs for Clojure

Setup clojure-mode
Setup swank-clojure

Follow installation instructions from swank-clojure (github.com).

References

Mirror of the Joy Programming Language

2011-05-11T06:17:00.000-07:00

I have been working on a pet project recently which was greatly inspired by fascinating little programming language called Joy. If you can, imagine combining Scheme with Forth, and that is basically what Joy is. It is a wonder of minimal, yet functional, programming language design, and a mind-bender to boot.

In any case, a couple of days ago, the original homepage for Joy went down. Considering that the language was created by a retired professor and maintained at his old university, there are any number of reasons why it went down, and seems likely never to come back again. With the hope that this language will not disappear from the web, I have mirrored the complete contents of the original Joy programming language homepage on my personal site.

Understanding JavaScript Inheritance

2011-04-19T13:35:00.000-07:00

JavaScript is a language which can be difficult to understand deeply. As opposed to most object-oriented programming languages, JavaScript is not class-based, it is prototype-based. This means that objects inherit from other objects, not classes. But while it is prototype-based, it has a syntax and features to make it seem like it is class-based. Because JavaScript seems confused about whether it is class-based or prototype-based, it can be difficult to use it correctly in either way. However, with a little bit of information about how JavaScript works behind the scenes, it is possible to emulate class-based inheritance or take full advantage of prototype-based inheritance.

My goal in this blog post is to try to get to the root of how JavaScript inheritance works in three cases: without explicitly doing it, using modern prototype-based inheritance, and using modern pseudo-class-based inheritance.

(This post is definitely not for beginners to JavaScript, but for someone who already knows it and wants to understand it a little deeper.)

Functions

function Animal() { }

On the surface, this code seems to create a function called Animal. But with JavaScript, the full truth is slightly more complicated. What actually happens when this code executes is that two objects are created. The first object, called Animal, is the constructor function itself. The second object, called Animal.prototype, has a property called Animal.prototype.constructor, which points to Animal. Animal has a property which points back to its prototype, Animal.prototype. This is illustrated in this diagram:

Although not shown in the diagram above, Animal.prototype actually inherits from the Object.prototype object. All objects in Javascript ultimately inherit from the Object.prototype object. A link from the object to the object it inherits from is stored in the internal __proto__ property (which is not publicly available in all browsers). The __proto__ property is illustrated in this diagram with a dashed line:

The "new" Operator

function Planet() { }
var earth = new Planet();

JavaScript's built-in "new" operator is how JavaScript attempts to emulate class-based inheritance. The "new" operator creates a new object, in this case called "earth", calls the function "Planet" on it, then sets the __proto__ property of the new object to Planet.prototype.

This allows functions to act like classes in some ways, but creating a deep inheritance hierarchy is impossible using just the "new" operator. For example, how could you create a new class that inherits from the Planet "class"?

Using the "Object.create" Function to Implement Prototype-Based Inheritance

Because of the fact that most browsers do not let programmers directly access the __proto__ property, it is difficult to create objects in JavaScript that directly inherit from another object--the very definition of prototype-basd inheritance. To simplify this, Douglas Crockford discovered an improved way to create new objects in JavaScript. His function, illustrated below, creates an object which inherits from the object passed to the function, thus providing a simple method of implementing prototypal inheritance.

function createObject(parent) {
  function TempClass() {}
  TempClass.prototype = parent;
  var child = new TempClass();
  return child;
}

I will walk through what this function does one line at a time with diagrams.

1. function TempClass() {}

2. TempClass.prototype = parent

3. var child = new TempClass()

A version of this function is actually implemented on all the newer browsers (including Internet Explorer 9, Firefox 4, and Chrome 9) as "Object.create". But it is easy to implement it yourself if you need to support older browsers, using the formulation above or that described by Douglas Crockford in Prototypal Inheritance in JavaScript.

Using the Inherit Function to Emulate Class-Based Inheritance

Imagine that you wanted to use class-based inheritance in JavaScript. You might want to do something like this:

function Mammal() {
  this.hasHair = true;
}

function Bear() {
  Mammal.call(this); // Call parent constructor
  this.roars = true;
}
inherit(Bear, Mammal);

var yogi = new Bear();
alert(yogi.hasHair); // This should display 'true'

Note the call to "Mammal.call" in the Bear constructor. This calls the parent constructor, similar to super() in Java or base() in C#. To implement the above, you can create some version of the "inherit" function:

function inherit(sub, super) {
  var newSubPrototype = createObject(super.prototype); 
  newSubPrototype.constructor = sub; 
  sub.prototype = newSubPrototype;
}

The inherit function takes two classes (functions) as parameters, and makes the first class inherit from the second one. In memory, here is how each line of the inherit function works...

1. Before the function is run, we have two classes, sub and super:

2. var newSubPrototype = createObject(super.prototype)

3. newSubPrototype.constructor = sub

4. sub.prototype = newSubPrototype

Using one of these two methods can allow you to implement whichever inheritance scheme you like, which is one of the reasons why JavaScript can be so powerful if understood correctly.

Related Links

Tim Caswell's Learning Javascript with Object Graphs, Part 2, and Part 3
Dmitry A. Soshnikov's JavaScript. The core.
(A deep understanding of scope, inheritance, closures.)
Mozilla's JavaScript Reference
Douglas Crockford's Prototypal Inheritance in JavaScript

(Updated 2011-04-23 - Additional clarifications based on comments.)
(Updated 2011-05-16 - Added missing call to super constructor in Bear constructor.)

Installing Google's Closure Linter on Windows

2011-04-04T13:57:00.000-07:00

I am working on a JavaScript project right now, so I decided to try out Closure Linter, Google's relatively new JavaScript code style verification tool that is part of their Closure Tools collection. I'm using Windows 7 64-bit, and their instructions for using Closure Linter on Windows do not quite make it clear what all needs to be done to get it working.

In case this is helpful to someone else in the future, here are the steps I took (modified from those found at How to Use Closure Linter):

Download and install Python 2.7.x for Windows 32-bit. Note that you must choose the 32-bit version of Python from the 2.7.x branch to ensure that you can use the EasyInstaller program needed for the next step.

Download and install SetupTools/EasyInstall for Python 2.7.
Install Closure Linter:

In a command prompt, change directory to to C:\Python27\Scripts
Run this command:
easy_install http://closure-linter.googlecode.com/files/closure_linter-latest.tar.gz

Now you will be able to run Closure Linter using variations on this command:
C:\Python27\Scripts\gjslint --nojsdoc -r DIRECTORY_TO_LINT

Good luck with the tool!

Visual Studio Color Themes

2011-01-06T13:35:00.000-08:00

Whenever I get tired of my color scheme in Visual Studio, I go to Studio Styles and try out a new theme. After that, I switch my font to a more readable font, like Deja Vu Sans Mono.

SAML 2.0

2010-11-19T02:00:00.000-08:00

I have been working a lot with SAML recently, which is a protocol for standardizing single sign on (SSO) between sites. A good number of sites and products use SAML as a SSO protocol, including Google Apps and Moodle, important sites to communicate with in my particular case.

I'm working in .NET 3.5, which unfortunately has no built-in support for SAML 2.0, but there are many third-party libraries and references to build your own support for it.

Here are some of the best links I have found for learning SAML.

References

Examples

Importing GWT SDK Samples into Eclipse

2010-10-19T17:30:00.000-07:00

I've recently started working with the Google Web Toolkit (GWT), which seems pretty sweet from everything I've read so far. It has great integration with an IDE, in this case Eclipse, which is absolutely essential.

Unfortunately, it was hard to find a way to easily open GWT's sample projects in Eclipse, but after a little trial and error, here is what I came up with. For each sample project you want to use, do the following:

Create a new Java project with the name of the sample project you want to use, for example, "Hello". Use all the other default settings, and press "Finish".
Right-click on the project and choose "Import". Choose "General" -> "File System", then press "Next".
Browse to the directory of the sample project you want to import. On my computer, the project was found at something like: C:\Program Files\eclipse\plugins\com.google.gwt.eclipse.sdkbundle...\gwt-2.0.4\samples. Select all, then press "Finish".
Right-click on the project and choose "Google" -> "Web Toolkit Settings". Check the "Use Google Web Toolkit" check box.
Go the the "Java Build Path" section of the project's properties. Change the default output folder to something like: "/Hello/war/WEB-INF/classes" (This will be different depending on your project name).

That's all! Good luck and have fun trying out GWT's samples.

Best Android Apps by Category

2009-11-11T17:30:00.000-08:00

Social Networking

Twidroid (Twitter client)
Facebook

Podcasts

DoggCatcher

Easy control over when podcasts downloaded

Desktop Music Syncing Software

Salling Media Sync

Allows you to sync iTunes with your Android phone

Music Listening

Built-in Music App

Language Learning

Anki

Flashcard app

Does not sync with Anki Online

Productivity

Remember the Milk (Todo list w/ online sync)
Movies by Flixster
FeedR News Reader

Utilities

WiFi OnOff
Barcode Scanner
Astro (File Browser)

Creating a Clojure GUI Application with SWT

2009-02-02T15:19:00.000-08:00

In my explorations of Clojure, I have been developing a desktop GUI application that uses SWT, the graphics toolkit that Eclipse uses. Once you get going, SWT is fairly intuitive to program in with Clojure, but you might need a little help to get started. Here is an example of a barebones app in SWT:

(ns swttest
(:import (org.eclipse.swt.widgets Display Shell)
        (org.eclipse.swt.layout GridLayout)
        (org.eclipse.swt.events ShellAdapter)))

(defn create-shell [display shell]
(let [layout (GridLayout.)]
 (doto shell
   (.setText "SWT Test")
   (.setLayout layout)
   (.addShellListener
    (proxy [ShellAdapter] []
      (shellClosed [evt]
        (System/exit 0)))))))

(defn swt-loop [display shell]
(loop []
 (if (.isDisposed shell)
   (.dispose display)
   (do
     (if (not (.readAndDispatch display))
       (.sleep display))
     (recur)))))

(defn begin []
 (let [display (Display.)
       shell (Shell. display)]
   (create-shell display shell)
   (.setSize shell 700 700)
   (.open shell)
   (swt-loop display shell)))

(begin)

On Mac, you will need to add the "-XstartOnFirstThread" command line option or your application will crash soon after launching.

Update:
I originally left out the line "(create-shell display shell)". The code above is now corrected.

See also:

Google Code and Subversion

2009-01-20T14:31:00.000-08:00

I recently started using Google Code for hosting a new open source project I'm working on (written in Clojure) in my spare time. Google Code uses Subversion for version control, which some predict is going to change soon to Git. While I am pretty familiar with the command line options for the Git version control system, I'm definitely not with Subversion. Maybe Google Code will switch to Git soon, but until it does, I needed to use Subversion, so I went looking for some GUI-based Subversion clients to simplify its use.

Windows

Finding a good Windows client was easy. TortoiseSVN is an Explorer shell extension that is free, stable, and complete. It worked right out of the box with Google Code and I didn't have to read a single line of documentation to become proficient at it.

Mac

The situation wasn't quite as simple for Mac. There are multiple non-free clients for Mac, but I wanted to stick with open source if possible. The closest thing to TortoiseSVN for Mac is something called SCPlugin, but it is incomplete and development on it seems to have stalled in 2005 or 2006.

SvnX is the one I ended up choosing. It is not quite as intuitive as TortoiseSVN, but it seems to get the job done. To get it working with Google Code, I had to run this command on the command line in order to accept the security certificate:

svn list https://GOOGLE_CODE_CHECKOUT_URL

That's it! Off to do some programming.

My Favorite Mouse

2008-12-22T11:26:00.000-08:00

As a programmer, I naturally spend a good portion of my waking hours--if not the majority--in front of a computer. This didn't seem a problem for the first quarter century of my life, but then about three years ago, I started experiencing pain in my mousing wrist. My first thought was that the beginning of carpal tunnel syndrome was setting in, which freaked me out.

I immediately set out to try more ergonomic input devices, and I switched to a pen input device at home and a radical ergonomic mouse at work. While the pen input device worked fairly well, the ergonomic mouse I chose proved to be the single greatest purchase I've ever made. Since starting to use it, I no longer have any pain in my wrist. I now realize that with the many viable ergonomic options for mousing that are available, no computer user should be using the very dangerous standard mouse.

Anyway, the mouse that I wholeheartedly recommend is the 3M Ergonomic Optical Mouse:

It is definitely a strange looking mouse, but the strange shape is what makes it work so well. This mouse fixes two problems with traditional mice:

1. Traditional mice force your arm to twist, causing your tendons to rub against each other, which causes inflammation and pain. By letting your arm sit in a much more natural arm-shaking position, the ergonomic mouse prevents this.

2. When using traditional mice, your wrist, with all it's delicate parts, does all the moving. The ergonomic mouse, on the other hand, keeps the wrist straight and the arm becomes the moving part.

So again, I highly recommend this mouse (or a pen tablet) to all computer users, and especially to programmers.

(Note: Just in case anyone thinks I am advertising for 3M, no, I am not in any way sponsored by or affiliated with them.)

Industrial Strength Application Development in JavaScript

2008-12-16T14:17:00.000-08:00

Inspired by the work of Douglas Crockford, I have been developing a JavaScript application using full blown development techniques. JavaScript is definitely a misunderstood and underestimated programming language, and I have found it to be a pretty good hybrid of object-oriented and functional techniques. I have even done some cool things with it that would not be possible in a statically typed language. I have found that with proper unit testing and debugging tools, its dynamic typing has caused me few problems.

So what tools can I recommend for industrial development in JavaScript? Everything below is an absolute must for my needs:

jQuery

What it does: Ajax, DOM-modification, and general utility functions
As Jeff Atwood pointed out, there is no good reason to write low-level JavaScript to manipulate the DOM with today, now that there are tons of high quality JavaScript libraries to help out.

QUnit

What it does: Simple unit testing, compatible with jQuery
I tried out a few other unit testing frameworks, but QUnit is the simplest one by far and just gets the job done.

JavaScript Lint

What it does: Identifies most textual errors in JavaScript files.
Indispensable tool to find that missing semicolon that is causing that weird error.
Note for TextMate users: Use the JavaScript Tools bundle instead of downloading it from the official site.

Firebug

What it does: Firefox plugin. In addition to excellent DOM manipulation, it makes a great JavaScript debugger.

In Addition, Mozilla's JavaScript Reference is a must for any serious JavaScript developer.

Well, I hope this gets you started. If you have any other suggestions, let me know!

Javascript's Undeclared versus Undefined

2008-12-02T11:45:00.000-08:00

I learned the hard way that undeclared is different than undefined. If you try to test the simple way for an undeclared variable, you get an error, which in my environment means an annoying pop-up.

/* var a; */  // undeclared
var b;        // undefined

// This would cause an 'object undefined' error
/*
if (a) {
  alert("a is defined");
}
else {
  alert("a is undefined");
}
*/

if (typeof(a) == "undefined") {
  // this will be executed
  alert("a is undeclared or undefined");
}
else {
  alert("a is declared and defined");
}

if (b) {
  alert("b is defined");
}
else {
  // this will be executed
  alert("b is undefined");
}

if (typeof(b) == "undefined") {
  // this will be executed
  alert("b is undeclared or undefined");
}
else {
  alert("b is declared and defined");
}

Greasemonkey-ing with Gmail's Styles

2008-11-24T09:53:00.001-08:00

Last week, Google finally gave us some options to customize the look of Gmail. Excitedly, I went through each theme trying to find my replacement for the boring old "Classic" one. Many of them are graphically appealing, but unfortunately, most of them also have poor contrast compared to "Classic". I finally settled on the "Mountains" theme, but one thing still bugged me about it: the text color of mail titles were too light.

Determined to fix this, I broke out Firebug, the trusty HTML/CSS inspection plugin for Firefox, and found the offending CSS:

.AnqB9d {
   color:#3F586D;
}

Then, I created this little Greasemonkey script:

function addGlobalStyle(css) {
   var head, style;
   head = document.getElementsByTagName('head')[0];
   if (!head) { return; }
   style = document.createElement('style');
   style.type = 'text/css';
   style.innerHTML = css;
   head.appendChild(style);
}

addGlobalStyle(
   '.AnqB9d {' +
   '    color: black ! important;' +
   '}'
   );

Viola! Readable mailbox items! Check out before and after shots:

Before:

After:

Related Links:

Joel Sutherland - Gmail's New Default Theme is a Step Backwards for Usability

F# and Functional Language Respect

2008-11-07T14:39:00.000-08:00

I have been experimenting with Microsoft's F# language, their version of ML / OCaml for the .NET Framework. Microsoft recently announced that F# will become an official part of Visual Studio, up there with C# and Visual Basic. I had never really used an ML-based language before, so I was not sure how big the learning curve would be, but I find that my knowledge of Haskell gets me far enough to feel comfortable writing simple programs after looking over the documentation for a few minutes. On top of that, the current pre-release version of F# has near perfect integration with Visual Studio, including an interactive REPL, debugging, and syntax completion. If you are in the market for a good functional language and are in the Microsoft developer ecosystem, F# seems like a great choice.

I'm not sure how much I will use F# at work, if at all, but it is good to see that functional languages are being taken very seriously at Microsoft now. Not only are the developments of F# encouraging, but each new version of C# adds more functional features, and I find myself using those features daily in my work.

Recommended Sites:

Microsoft F# Development Center

Developing on iPhone and Android

2008-10-29T22:41:00.000-07:00

When the iPhone SDK came out early this year, I was one of the first to sign up for the beta program. I was excited by the possibility to develop on the platform and quickly started reading through the documentation and watching developer videos as I began development of what was to be my first iPhone app. Unfortunately, Apple put one too many roadblocks in place, making the iPhone an undesirable platform for me to work on:

Apple prevented all discussion of iPhone APIs by developers. I tried to ask a simple API question on an Apple developer board, and although a nice explanation why no one could answer me was sent to the board (see the mailing list archive), I actually received obscene emails attacking me for having the audacity to break the SDK's non-disclosure agreement. The draconian NDA clause was removed a few weeks ago, but even then was long after the beta period was over.
Apple charged a fee just to get the developer kit working on an actual device, but then never gave many developers, including me, the unlocking codes to do so until long after the beta period ended.
Apple is still playing games with developers by occasionally pulling legitimate applications off the App Store.

In the end, I gave up and decided to work on Google's Android instead. First of all, Google got Android right by making the tools free and the restrictions few. Another nice benefit was the rich tools available to Android developers due to the Android SDK's use of Java (which has the added bonus of letting me use Scala for Android development!). So far, developing for the Android has been great-- straight-forward APIs, good tools, good documentation. Maybe someone got mobile OS development right.

Related Links:

Bad Code

2008-10-25T10:51:00.000-07:00

Every programmer has experienced it. Code that is so bad, you have to share it with someone. Here are some recent gems I have encountered.

Poor man's comments.

If 1 = 0 Then
...
End If

Is nameString empty?

if (nameString + "x" != "x") {
...
}

Hmm, is the comment wrong, or the code?

// Comma-separated list of numbers
string configurationIds = "254:762:2:236:23:5:21";

JUnit Testing Scala in Eclipse

2008-10-20T09:51:00.000-07:00

Being a fairly new convert to agile development methods, including test driven development, I knew the first thing I would want to get up and running with Scala was a unit testing framework. The NetBeans plugin has built-in JUnit support which served me very well. But I also wanted to get some unit testing working with the Eclipse plugin. It took me a while to get JUnit testing setup with Eclipse, mainly due to my lack of experience in the Java ecosystem. To help future explorers down this path, here are a few lessons I learned.

Put the your tests in a separate source folder. See this tutorial on setting up JUnit in Eclipse for more information.

Add JUnit to your project's build path. Select the project and choose "Build Path" -> "Add Libraries...". Then choose the JUnit jar.

Add the output directory of your project to your build path. See this short guide from the makers of Spec.

To get you started, here is a simple test:

package tests

import junit.framework._
import org.junit.Assert._

class FirstTest extends TestCase {
 override def setUp() = {
 }

 override def tearDown() = {
 }

 def testOne() = {
   assertEquals(1, 1)
 }
}

October's Bay Area Scala Enthusiasts Meetup, Part 2

2008-10-17T11:44:00.000-07:00

I promised some technical notes on the Bay Area Scala Enthusiasts meetup earlier this week, so here we go.

Coding Guidelines

As I mentioned previously, the presentation by the Twitter folks focused on the informal guidelines they have been using internally for Scala coding (PDF of their presentation). I like their guidelines generally. Something that may be controversial in the guidelines is their policy not to use implicits. DSLs especially can make good use of implicits, so I would imagine that would have to be the exception to their rule. Maybe someone should take their coding guidelines as a starting point to make a coding guidelines page on the Scala Wiki?

Structural Types

One of the topics mentioned at the meetup was structural types, which I hadn't used before, so I checked them out. Structural types seem to be a way to accomplish the same sort of "duck"-typing that you can do in Ruby and Python. Let's say you don't care about what the inheritance hierarchy of a parameter is, just that it can perform some operation. There are at least two ways to do this: traits or structural types.

Using traits:

trait Jumpable {
 def jump() : Unit { print("Jumping!") }
}

class Bunny extends Jumpable { ... }
class PogoStick extends Jumpable { ... }

class Controller {
 def makeThemJump(jumpers: List[Jumpable]) = {
   jumpers.foreach { jumper =>
     jumper.jump()
   }
 }
}

Using structural types:

class Bunny { def jump(): Unit { print("Jumping!") } }
class PogoStick { def jump(): Unit { print("Jumping!") } }

class Controller {
 def makeThemJump(jumpers: List[{ def jump(): Unit }]) = {
   jumpers.foreach { jumper =>
     jumper.jump()
   }
 }
}

The Twitter guys pointed out that it might be a good idea to avoid structural types due to their use of reflection, which may be slow.

Dependency Injection

How to use dependency injection (DI) with Scala was brought up. There was some argument on how applicable DI was in Scala, with developers coming from a Java background supporting it and those with a Ruby background questioning its relevance to Scala. Either way, this in depth article by Jonas Bonér was brought up.

Development Environment

There was a short discussion on what ide/editor people were using for Scala. The Twitter guys were using TextMate or Emacs, and a few people in the audience mentioned Eclipse and NetBeans. I am really curious what luck developers have had with the different environments. I am using NetBeans right now, but I am not completely happy with it. Can anyone make any recommendations?

October's Bay Area Scala Enthusiasts Meetup

2008-10-14T23:11:00.000-07:00

Tonight I attended a meeting of the Bay Area Scala Enthusiasts, a user group focused on the Scala programming language. The meeting was held at Twitter's office in San Francisco, only a few blocks from my company's office, so it couldn't have been more convenient for me. I expected to encounter around 5-10 people there, but I was surprised when around 30 had gathered. The Scala community is definitely growing!

Alex, Steve, and Robey from Twitter hosted the meeting, and explained how they are using Scala at Twitter. They are using it both in middleware and in front-end code and seem to be committed to expanding its use in Twitter-- good things for Scala and Twitter both. Their main presentation focused on establishing a set of coding conventions for the Scala community, which I think could be a really good help for new programmers to have some structure. Robey showed us some of his open source code up on github, including configgy, which I plan to take a serious look at soon.

Some other interesting discussions at the meeting included preferred development environments and strategies to deal with the paradox of being paralyzed by having multiple ways to accomplish the same thing in Scala, usually at least a functional and an object-oriented way of doing things. The concensus seemed to be that each group will ultimately end up with their own style or Scala programming, somewhere between the extremes of writing Java in Scala or Haskell in Scala.

We also learned that there are no less than three Scala books in the works:

Programming in Scala by Odersky, Spoon, and Bill Venners (who was also present and shared some good stories about his experiences in the language as well as the origin of the "/:" operator)
Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine by Venkat Subramaniam
Programming Scala by Alex Payne and Dean Wampler, published by O'Reilly

Notice a pattern in the titles?

All in all, a great meeting where I meet some very interesting people. It's great to see the community of Bay Area Scalists so... well, Enthusiastic :)

Update:
Added exact authors of the new O'Reilly Scala book.

Reflections on Scala

2008-10-10T13:35:00.000-07:00

In my professional programming career, I have been a mostly object-oriented programmer, programming in C#, Java, Python, and C++. Throughout this time, though, I researched functional programming languages from Scheme to Haskell. While I was frequently fascinated by them and they definitely stretched my mind, I never found them to be as practically usable as the relatively new language Scala.

Scala describes itself as a fusion of object-oriented and functional programming languages, and while that is true, it certainly does not give the language justice. Scala has let me leverage my familiarity with object-oriented languages like C# and Java, but add in functional elements as I go along. This has been great for me since I am most comfortable developing real-world applications in an object-oriented style, as I suspect most professional developers are these days. After I have the basics of my program done in an object-oriented style, I can start adding in more functional features. I have never found a language that makes this easier.

To me, the biggest stumbling block for programmers new to Scala is that most of the official documentation describes Scala's functional features very well, but lacks in depth discussions on how to transition to Scala from an object-oriented background. My advice if you are new to Scala and you're an object-oriented developer, learn how to program Scala in a object-oriented way first, then add in functional stuff.

Finally, I have tried two IDE plugins that offer Scala support: one for Eclipse and one for NetBeans. Of the two, I find NetBeans to be more stable, faster, and better able to deal with Scala syntax than Eclipse. There are definitely still some bugs for them to solve, but I'll be sticking with the NetBeans plugin for my Scala development in the near term.

Scala's Community

2008-10-02T15:28:00.000-07:00

I am studying the functional/object-oriented language Scala right now and I thought I'd share a few observations about this language and the community around it:

Last night I was having some issues getting Eclipse's Scala plugin to work correctly. Frustrated, I went on Scala's IRC chat room and made an off-hand comment on my problems. The maintainer of the plugin just happened to be in the room at the time, and pointed out my problem, quickly setting me on the right path. My first "technical support" question solved!

A great little tutorial for getting someone familiar with Scala from the Java/C# school of object-oriented programming is Daniel Spiewak's Scala for Java Refugees. Highly recommended.

Test Driven Development Best Practices for C#

2008-09-03T11:56:00.000-07:00

As I have mentioned before, my company has recently started to use the Test Driven Development style of programming. In order to help us write testable code, I came up with this simple list of best practices for making our C# code base more testable. (Some of the links refer to limitations of Rhino Mocks, a mocking framework for C#, but the rules apply more generally as well.)

To maximize the testability of code, follow these rules:

Write the test first, then the code. (PRIME DIRECTIVE!)
Reason: This ensures that you write testable code and that every line of code gets tests written for it.
Design classes using dependency injection.
See: Intro to Rhino Mocks (see "Creating Testable Web Applications" section) and Dependency Injection Article
Reason: You cannot mock or test what cannot be seen.

Separate UI code from its behavior using Model-View-Controller or Model-View-Presenter.
Reason: Allows the business logic to be tested while the parts that can't be tested (the UI) is minimized.
Do not write static methods or classes.
See: Intro to Rhino Mocks (see "Creating Testable Web Applications" section) and Rhino Mocks Limitations
Reason: Static methods are difficult or impossible to isolate and Rhino Mocks is unable to mock them.
Program off interfaces, not classes.
Reason: Interfaces can be easily mocked using Rhino Mocks and other mocking frameworks.
Isolate external dependencies.
Reason: Unresolved external dependencies.
Mark as virtual the methods you intend to mock.
See: Rhino Mocks Limitations
Reason: Rhino Mocks is unable to mock non-virtual methods.

Code Can Be Poetic

2008-08-16T20:06:00.000-07:00

While learning RSpec (a testing framework for Ruby), my girlfriend was sitting next to me on our couch asking me what color of yarn she should knit some socks in. While she asked me questions, I came up with these to snippits of code that "tested" if a particular yarn type was correct. Not very useful, but fun!

sock.rb:

class Sock
 attr_accessor :colors

 def initialize
    @colors = [:teal, :olive, :green, :blue, :purple]
 end 

 def machine_washable?
   true
 end
end

sock_spec.rb:

require "sock"

describe "Socks that Kevin would like" do

 before :each do
   @sock = Sock.new
 end

 it "should not have pink in it" do
   @sock.colors.include?(:pink).should_not == true
 end

 it "should not have purple in it" do
   @sock.colors.include?(:purple).should_not == true
 end

 it "should be machine washable" do
   @sock.should be_machine_washable
 end

 it "should not have grey in it" do
   @sock.colors.include?(:grey).should_not == true
 end

 it "should have multiple colors" do
   @sock.colors.length.should > 1
 end

end

Programming at a High Level

2008-08-14T10:15:00.000-07:00

Jeff Atwood (of the Coding Horror blog) this week pointed out that there are many new high-level JavaScript libraries that allow you to ignore the lower-level JavaScript incompatibilities between browsers. I have used JQuery and can also vouch that using JQuery is incredibly fun and easy to program with.

This is more broadly applicable to other programming languages and libraries, too: Use the highest-level interface that you are able to use to accomplish your task. For example, don't use C when you can use C++. Don't use JavaScript when you can use JQuery. Don't use C++ when you can use C#. Don't use Perl when you can use Ruby.

References:

Secrets of the Scripting Ninjas (Coding Horror blog post)

Ruby Compiler Project

2008-08-12T21:12:00.001-07:00

In my spare time (that is, apart from all the other hobbies I have), I have started work on a new programming project. My goal is to write an interpreter/compiler for a new programming language. I have no great ambitions, this project is purely for my own enjoyment and to hopefully teach myself something new.

Goals/Plans:

Develop in Mac OS X
Implement the compiler in Ruby
Use test driven development and the agile process

Test Driven Development

2008-04-24T12:11:00.000-07:00

We have started using Test Driven Development at work, which is an entirely new way to program. This goes along with our existing use of Agile Development, so we are totally embracing the latest and (hopefully) greatest in programming philosophy.

JavaScript Retardedness

2007-08-14T11:38:00.000-07:00

I just discovered after dealing with an annoying bug for over an hour, that in JavaScript, this evaluates to true:

0 == ''

Thankfully, in the newer browsers, they added the === operator to deal with this.

Mac OS

2007-07-15T09:12:00.000-07:00

I've been using Mac for about a year now, so I thought it was time to give a quick review comparing and contrasting the benefits of Mac (compared to my previous experience with Windows).

Things I like about Mac:

Invisibility of the operating system -- It really does "just work" as Apple claims. Unless you need to do something very advanced, you could get away with never configuring anything in the OS.
Visual appeal -- the OS looks very slick while still being functional
Application availability -- there are many applications available (obviously less than Windows, though), and the quality of each application is very high
Application switching -- the application switching features are incredible and very useful

Things I don't like about Mac:

The WiFi applet responds slowly to user feedback, about a 5-10 second lag between clicks sometimes.
Most applications can't be maximized
Lack of Visual Studio -- Microsoft's Visual Studio development tool is the most user-friendly development tool I've ever used, but it's not available on Mac... Eclipse is a fairly good alternative once you get used to it.

Overall what I've noticed during my switch is how the rise of Internet applications has made it which operating system I use less important. I use Google Calendar, Gmail, Google Reader, and Firefox, which works on every platform. Internet based blogs constitute much of my writing. As internet apps get more powerful, this trend will only continue, making the OS you use nearly meaningless.

Functional Languages on the Horizon

2007-05-24T08:13:00.000-07:00

The usefulness of functional languages is really starting to go mainstream now. In the past, I've learned Haskell, Scheme, and Ruby, and I'm studying Scheme again now. Trying to learn every technology is impossible so I'm going to stick with Scheme right now because of the great books that are available for learning it.

Practical reasons for learning some functional languages:

Scala

Lift Web Framework: http://liftweb.net/
Java interoperability

Haskell

New O'Reilly book, "Real-World Haskell": http://www.realworldhaskell.org/blog/
Most modern functional language in semi-mainstream use.

Scheme/Lisp

Great books: "Lisp in Small Pieces", "The Scheme Programming Language" (by Kent Dybvig), and "The Structure and Interpretation of Computer Programs".
Good, cross-platform IDE: DrScheme
Ability to leverage knowledge for Arc (Paul Graham's language which will almost certainly have a large following due to his popularity)

PLT Scheme

2007-05-18T13:02:00.000-07:00

I'm learning Scheme right now in my spare time to expand my programming ability and hopefully find use for it at work. PLT Scheme seems to be a good implementation: it has a large library, and a good cross-platform IDE. Also, the PLT Scheme user community is large and active compared to many other Scheme implementations.

There are also some cool extensions for it:

Typed Scheme: typing on top of PLT Scheme
DivaScheme: environment to improve PLT Scheme

And some other good links:

Planet Scheme: a aggregation of Scheme blogs
Keybinding 101 in PLT Scheme

Hello, World!

2007-05-17T21:10:00.000-07:00

No better way to start a blog about computer programming than with the immortal words of every programmer's first foray into a new programming language. This blog will mostly be for my own benefit and future reference, but if someone finds it useful, all the better!