Kevin on Code

Blog Retired

2015-08-20T15:58:00.001+02:00

I am no longer posting to this blog. To see my up-to-date blog on programming, visit https://medium.com/kevin-on-code

You can also visit my personal page at http://www.kevinalbrecht.com

Value Attributes Don't Always Mean What You Think They Mean

2013-06-02T10:51:00.001+02:00

I recently discovered the hard way that the "value" attributes of different HTML elements can have subtle and frustratingly different meanings.

Take a look at this simple example:

<input type="button" value="one" id="buttonX">
<input type="text" value="one" id="textX">

<script>
  var buttonX = document.getElementById("buttonX");
  var textX = document.getElementById("textX");

  buttonX.value = "two";
  textX.value = "two";

  buttonX.setAttribute("value","three");
  textX.setAttribute("value","three");
</script>

(View this as a JSFiddle: http://jsfiddle.net/sEpMz/)

After running this code, you would probably guess that the text visible in the two widgets would both be "three", but in fact, the button will display "three" while the text box will display "two"!

The reason behind this is that for certain input element types, the "value" attribute defines the initial text of the widget, while for other element types, the "value" attribute defines the visible text of the widget!

The important distinction here is between the "value" attribute (the value="something" that appears in the HTML), and the "value" property (elementX.value = 'something' in JavaScript). The property will always reflect what is displayed in the widget on the page, while the attribute has different behavior depending on the type of the input element.

A Short Survey on the State of Functional Reactive Programming in ClojureScript

2013-05-23T20:58:00.001+02:00

In the Object-Oriented world of JavaScript, architectures like MVP, MVC, and their brethren are well established. But when I started using ClojureScript to build rich user interfaces on the web, I was naturally interested in finding ways to architect my site that are friendly to a functional programming language like Clojure. This led me to functional reactive programming, or FRP.

FRP, probably the best-known user interface paradigm for functional programming, models UIs as dataflows, where changes (user actions or data source changes) propagate through the system using purely functional operations and eventually end up as visual changes back in the UI. In short, FRP is similar to how changes to a cell in a spreadsheet propagate to other dependent cells.

Though the ClojureScript ecosystem is still fairly immature (or perhaps because it is), there are many libraries which support the FRP style of programming. If you are looking for an alternative to faking object-oriented styles of programming in ClojureScript, jump in and give one or more a try!

(By the way, if you want my personal recommendation, I have had a lot of luck with the simplicity and power of widje.)

Native ClojureScript libraries

todoFRP's C2 example (Github)

cljs-binding

cljs-binding (Github)

Javelin

Pedestal

Reflex

Shafty

Shafty (Github)

Widje

ClojureScript libraries built on top of JavaScript libraries

acute (wrapper around AngularJS)

acute (Github)

rx-cljs (wrapper around RxJS)

Yolk (wrapper around Bacon.js)

Clang (wrapper around AngularJS)

Clang (Github)

Using JavaScript libraries directly

AngularJS

My Programming Reading List

2011-12-22T21:48:00.000+01: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-07T13:59:00.000+01: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-30T19:27:00.001+01: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-20T09:36:00.000+01: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-11T15:17:00.000+02: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-19T22:35:00.000+02: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-04T22:57:00.000+02: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-06T22:35:00.000+01: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-19T11:00:00.000+01: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-20T02:30:00.000+02: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-12T02:30:00.000+01: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-03T00:19:00.000+01: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-20T23:31:00.000+01: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-22T20:26:00.000+01: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-16T23:17:00.000+01: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-02T20:45:00.000+01: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-24T18:53:00.001+01: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-07T23:39:00.000+01: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-30T06:41:00.000+01: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-25T19:51:00.000+02: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-20T18:51:00.000+02: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-17T20:44:00.000+02: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?