Older blog entries for welisc (starting at number 29)

It's occurred to me - after a mere four years - that I've spent much more time writing code for extracting propensity tables and loop modelling than I have actually running it. Since the output of the programs is what I'm really interested in, it's obvious that I should be trying to minimise the development time.

Using Perl or Python would certainly reduce development times but at a cost in terms of performance. However, if it saves a lot of development time, this might actually offset the increased running time to the extent of reducing the overall time to get results. And there's always the option of using SWIG to drop down into C for the heavy-lifting bits.

This of course still means having to write the heavy-lifting bits in C or C++.

I really like functional languages: they let you write high-level code and write it quickly, and then compile it to get optimal performance. The problem with functional languages is that the paradigm is very different to imperative programming so there might be problems persuading coworkers that they're a good idea. There's also the perennial problem of people not wanting to use lesser-used languages that add little or no value to a CV.

I suspect I'm going to end up with a compromise solution such as gcj-compiled Java, a language whose only selling point for me is that it eliminates a lot of the complexity of C++ (while also eliminating some of the good features of C++).

Reading Structure and Interpretation of Computer Programs and working through the exercises in Accelerated C++. C++ is certainly an improvement on C but Scheme makes it look like a supercharged assembly language.

IT job market imploding. Interest in structural biology reviving. First sighting of Lisp in a bioinformatics job ad [This was at the EBI].

My first attempt to read Damian Conway's Exegesis 3 left me with a spinning head and serious doubts about Perl 6. Piers Cawley's Not just for Damians acknowledges that a lot of people feel the same way but makes a good case for the new features and inspired me to have another go at Exegesis 3. I liked what I found: the features discussed in the Exegesis have a distinctly functional flavour to them that will make it possible to write Perl code that is more concise but also more readable.

The O'Reilly book (in French) about O'Caml is online. I skimmed through it and was surprised to find I could follow it pretty well. This seems likes an interesting, if slightly unusual, way to brush up on my technical French. A volunteer project to translate it into English has completed about 70 % of the text.

The results of the Fourth ICFP programming contest are out. First place went to Haskell Carrots. The Dylan Hackers came second, with most of the team using Gwyddion Dylan, which would indicate that the current version is in a very usable state. Dylan is interesting for the reason outlined in the contest write-up:

A major design goal of Dylan is to produce a language in which complex programs can be rapidly prototyped in the same way as with dynamically-typed languages such as Smalltalk or Lisp or "scripting" languages, while at the same time enabling performance comparable to statically typed languages such as C or ML.

Having problems building DrScheme and Bigloo from source using gcc 3.0. Luckily, I still had the (very) old installation of gcc 2.91.66, which compiles them without a problem.

Spent half the afternoon tracking down a mysterious segfault caused by one little line:

static char *sort_phen1 = NULL,*sort_phen2 = NULL;
static int initialised = FALSE;

/* lots of code */

static int sort_comp_phen(Ind *s1, Ind *s2)
{

char *sort_phen1,*sort_phen2;
if (!initialised){

sort_phen1 = chrom_string();
sort_phen2 = chrom_string();
initialised = TRUE;

}

strcpy(sort_phen1,chrom_phenotype(s1->chrom)); strcpy(sort_phen2,chrom_phenotype(s2->chrom));
return strcmp(sort_phen1,sort_phen2);

}

Strange how you can never see something that's staring you in the face. Compiling with the -Wshadow flag would've caught it.

Bruce Eckel isn't impressed by Ruby. I've tinkered with Ruby and I like the pure OO design but there are two reasons why I don't see myself doing much with it. First, it's not as concise as Perl for writing small scripts (neither is Python). Second, and more significantly, there are no Ruby libraries that make it worth my while learning it. By contrast, there are at least two Python molecular modelling projects, Pmv and MMTK, each of which is fairly mature and featureful. Even if I didn't care about Python having a cleaner design than Perl, these two libraries would be a compelling reason to learn it.

New Scientist has an interview with Stephen Wolfram about his new book. He may or may not be "the Isaac Newton of the 21st century" but the book sounds interesting. This kind of simulation is going to be hugely important in bioinformatics.

I'm not well prepared for this kind of stuff; looking at Mark De Pristo's notes on bioinformatics programming in Scheme reminds me just how little I know.

Paul Graham's article Beating the Averages is interesting. Lisp programmers (and functional programming advocates in general) have been saying this kind of thing for years. I suspect they're right but at this stage in my career, my job prospects depend on knowing the usual suspects (C/C++/Java/Perl). It's a pity because the idea of trying something different, especially something that would give me an advantage over the competition, appeals to me.