Older blog entries for welisc (starting at number 19)

Working through the exercises in Accelerated C++. Eiffel may not be as concise as C++ but at least you can't make stupid mistakes like:

line = string('*',cols);

instead of

line = string(cols,'*');

Took me a while to spot that one.

I've come to the conclusion that I like languages to be concise; that's why I haven't given up Perl for Python or Ruby. Lately my Perl scripts have become exercises in using the least possible number of variables. I never loop over a list where map will do the job. If this continues, I'll end up coding in Haskell.

One thing I've thought would be useful is a way to interface Eiffel objects with a scripting language. Victor Putz has done it with epolyglot, a library that supports mixed-language programming in Eiffel, Python and Haskell.

Hodges Figgis are having a sale at the moment; Core C++: A Software Engineering Approach looked like a bargain at £10.99 but having read the ACCU review, I'm glad I didn't buy it: "Not Recommended" is pretty damning.

Installed GCC 3.0 to try out gcj. It looks like native code runs 2-3 x faster than byte codes on the JVM 1.3. If this is really the case then the performance gap between C and Java is small enough to make Java a feasible alternative.

Now if it only had generics and operator overloading...

Not sure I'm clever enough to be a Scheme programmer. Doing quite well with Teach Yourself Scheme in Fixnum Days but the implementation of the amb operator is baffling.

Scheme is fascinating in a mindbending sort of way. Even more fascinating when used to teach bio-programming.

Python is my secret weapon to free propensity tables from the clutches of the abomination that is Fortran 77.

Timings for finding atom contacts in the 1FLT ligand-receptor interface:

C: 0.77 s
Eiffel:0.96 s
Java: 1.72 s
Perl: 13.16 s

Contacts between V or W chains and X or Y chains:

C: 0.43 s
Eiffel: 0.47 s
Eiffel->Java 1.28 s
Java 1.17 s

Java timings corrected for JVM startup time

Finished Accelerated C++. Now I understand why people prefer Eiffel or Java.

Two thirds of the way through Accelerated C++. Excellent book but I have reservations about C++: too much low-level detail that I'd rather not have to worry about.

Spent the day thinking about coding representations in GenLoop. Thinking of using GAlib; no point re-inventing the wheel. Read the chapter in Thinking in C++ on the uses of const. Eiffel suddenly looking attractive again. Use of Cecil looks straightforward.

Can't remember who said that all software evolves to the point where it can send email but one of my Perl scripts has done just that in the space of an afternoon. Began as a wrapper so Dave could use Lynx in a Unix terminal to download PDFs from the Journal of Neurophysiology without having to click through several levels of the site. The trouble was that he was having to telnet and ftp via my INCBI account. I figured out how to use Mail::Sendmail to mail the PDFs to him as attachments. All he has to do is type:

reprint 83 1 1

and J. Neurophysiol. 83(1):1 is emailed straight to his Windows desktop.
A fairly trivial bit of hacking but satisfying nonetheless.

Got a call from PHDjobs.com this morning. Apparently bioinformaticists are in high demand. So there might even be a job for me at the end of all this.
Writing-up is being impeded by my obsession with Eiffel. One thing I don't like about it is that the array access syntax is clunky (although you can use array @ i for array.item(i)); one of the things that was fixed in Sather. But I should really forget Eiffel and get down to reading Accelerated C++, which might at least leave me with a marketable skill.

Spent the whole day getting a handle on Chris's propensity table code. He writes a single program to do the whole smoothing procedure. My approach is more Unixish - lots of little programs to do pieces of the job, which I then glue together with a shell script. The right thing to do would be to have a Perl script that parses a table definition and then works out what lower level tables you need to generate to smooth the final table.