Alan's Ramblings - Tech category

Stupid BT router...

Wed, 23 Nov 2011 14:12:00 GMT

I have the misfortune to own a BT Business 2Wire router, and bleaklow.com sits behind that. A while back it threw a fit and reconfigured itself and when I beat it into submission I didn't notice that it had also lost the port mappings for bleaklow.com. As a result I've been off-air for quite some time. Bloody BT...

Hints on creating 256-colour themes for vim

Wed, 21 Sep 2011 20:06:00 GMT

Most existing vim colour themes are designed for the graphical version of vim, gvim. They don't work properly at all if you are running vim in a terminal, and there are very few themes available for vim in terminal-mode. You are pretty much obliged to make your own if one of the small number of available ones doesn't suit. Here's a list of hints and tips that I discovered in the process of creating one:

If your shell's setting for $TERM is xterm you won't get colour support. It needs to be xtermc or you need to add a set term=xtermc in your .vimrc.
Even with the terminal type set you may not get 256 colours if you are using gnome-terminal. To fix that, put set t_Co=256 in your .vimrc.
In vim, type :help highlight to get instructions on how to specify colours in vim.
To make the process of authoring a colour theme easier, install the Mkcolorscheme.vim script in your vim plugin directory, uncommenting the four commands at the top of the file. Read the instructions in the plugin, they give you hints on how to identify the colours currently being used by syntax elements.
Open a new subwindow in vim and type :so $VIMRUNTIME/syntax/hitest.vim. That will display a table of the current settings, which will be updated as you interactively change colours.
Open this colour chart in your browser, it gives you the colour numbers you'll need to set the colours.
Open up a source file of the type that you want to set the syntax colouring for, put the cursor over an element and use the :GetSyntax command to identify the element type, followed by the appropriate:highlight command to set the element colour.
When you are done, use the :Mkcolorscheme command to generate a set of commands to generate the colour scheme settings. Delete any lines containing cleared as they aren't valid.
Save the colour scheme to a file in your vim colors directory and load the scheme with a colorscheme command in your .vimrc.

Beautiful Scala

Tue, 23 Aug 2011 08:24:23 GMT

This is, of course, beautiful:

def msort[T](less: (T, T) => Boolean)
      (xs: List[T]): List[T] = {
  
    def merge(xs: List[T], ys: List[T]): List[T] =
      (xs, ys) match {
        case (Nil, _) => ys
        case (_, Nil) => xs
        case (x :: xs1, y :: ys1) =>
          if (less(x, y)) x :: merge(xs1, ys)
          else y :: merge(xs, ys1)
      }
  
    val n = xs.length / 2
    if (n == 0) xs
    else {
      val (ys, zs) = xs splitAt n
      merge(msort(less)(ys), msort(less)(zs))
    }
  }

scala> val intSort = msort((x: Int, y: Int) => x < y) _
intSort: (List[Int]) => List[Int] = <function1>
scala> intSort(List(3, 5, 1, 6, 2))
res3: List[Int] = List(1, 2, 3, 5, 6)

This is an example of a recursive merge sort implemented using a technique known as currying, expressed in the language Scala.

Some context: I was looking for a Java-based scripting language to act as 'glue' for my Java interface to OziExplorer which I'm using for a fenceline survey I'm doing for the Moors For The Future project. I initially looked at Groovy and came across an intriguing comment by James Strachan, the creator of Groovy:

I can honestly say if someone had shown me the Programming in Scala book by by Martin Odersky, Lex Spoon & Bill Venners back in 2003 I'd probably have never created Groovy.

That set me off on an exploration of the Scala website which has lots of good tutorials and links, including one to an online interpreter you can type examples into. Scala is a really intriguing language - it sits on top of the JVM so you get 'for free' Java's cross-platform support and access to the huge Java ecosystem, but Scala also blends together the features of some of the most influential languages that preceded it:

The 'everything is an object' nature of Smalltalk or Ruby
The imperative nature of languages that have C or Java heritage
Functional programming as per ML or Haskell
Strongly typed but with sophisticated type inferencing that makes it look & feel similar to Python or Groovy
Uniform access to methods and fields, like Eiffel
Actor-based concurrency similar to Erlang

Scala also adds new features of its own as well, such as abstract types, traits and extractors. It's also very easy to write domain-specific languages in Scala. James Strachan wrote a good summary of Scala, from which the above quote is taken.

I also ordered a copy of Programming in Scala, Second Edition which I'm enjoying reading and can thoroughly recommend. Unlike many programming books it's well written with a light but not overly-chatty style. It explicitly assumes you have programming experience, so it picks up pace pretty quickly. As I've been going through the book, most of my "Why did they do that?" questions have had good answers, which gives the impression that Scala has been very carefully thought through - always a good sign.

Now all I have to do is to think of a substantial project I can use Scala on :-)

Childhood autism spikes in geek heartlands

Fri, 24 Jun 2011 11:10:15 GMT

From the New Scientist:

Childhood autism is two to four times as common in Eindhoven, the centre of the Dutch information technology industry, as it is in two comparably sized Dutch cities with far fewer IT employees.

The result supports the suggestion that people who work in hi-tech engineering and computing industries, which demand the kinds of systemising and analytical skills often seen in people with autism, are more likely to have autistic children too.

New Scientist, 20 June 2011, Childhood autism spikes in geek heartlands

Who'd have thought it :-)

A mention on the Pragmatic Programmer

Sun, 08 May 2011 14:01:41 GMT

I was looking at my Google Analytics and noticed I was getting referrals from the Pragmatic Programmer site, specifically from an article in the April magazine issue entitled Advanced Arduino Hacking. Turns out they were using my Makefile.master as the basis of their article, which describes how to use the Arduino platform without having to use the not-very-good Arduino IDE. OK, I suppose that's a little unfair - the IDE is clearly meant for beginners but if you are an experienced developer or are working on more complex projects it becomes very limiting very quickly, as noted in the article.

There are a number of copies of my Makefile.master floating around, but I'm updating it fairly regularly, so I recommend you grab the original version. Compared to the version on the PragProg site, the current version (at time of writing) has the following improvements:

The only really platform-specific parts of the Makefile are those that deal with running the serial monitor used to connect to the Arduino. On Solaris I use tip whereas on Linux you'd probably want to use something such as screen. I've therefore added platform-specific sections to configure the serial monitor commands to the Makefile.master. I don't currently have settings for MacOS, if someone wants to provide some suggestions, I'll add them in.

I hit a linker bug when using the avr-libc floating-point library, the workaround being to specify -lm both first and last in the linker command-line arguments.

An optional EXTRA_FLAGS macro that can be used to specify any additional flags that you want passed to gcc/g++. I use this for enabling/disabling debugging, e.g. EXTRA_FLAGS=-DDEBUG in my project Makefile.

The automatic tracking of #include dependencies was being done via a separate invocation of the compiler, this has been collapsed into the main compilation step, thus halving the number of times the compiler is invoked. If you don't know what automatic dependency checking is, there's a good explanation here and also in the GNU make documentation.

The generated dependency files are stored in the build subdirectory of the project, but they do tend to clutter things up. I've therefore moved them all into hidden (dot) files.

One final note, the PragProg Makefile.master uses stty -f $(PORT) hupcl to trigger a reset on the arduino before uploading the hex image to it. Not only is that platform-specific, it's also unnecessary if you are using a recent-ish version of avrdude which will do the reset for you if you specify a programmer type of arduino rather than stk500.