Three interesting discussions

Since we are having a slow week, I thought it might be a good idea to mention three interesting threads from the discussion group. Most regulars read the discussion group, but not everyone is aware of it, and we are still working on an RSS feed for new discussion group messages. So, in case you missed them, you might want to check out,

  1. Understanding continuations.
  2. Explaining monads.
  3. Why type systems are interesting (this is a long thread, so consider starting a new one if you want to move the discussion in a new direction).

Francis Crick (1916-2004)

This is a bit offtopic, but Francis Crick was an esteemed man of science and we should all be saddened to hear of his death.

Crick co-discovered the the structure and properties of DNA in 1953, along with James Watson.

His work leading to the understanding of the genetic code is, however, more closely related to our areas of interest. These classic experiments were an astonishing example of scientific discovery at its best.

In recent years Crick was interested in the questions of neurobiology, and published the provocative book Astonishing Hypothesis which tackled the question of human consciousness.

Udell at OSCON: IronPython news

Udell reports:

"When you think about it," Hugunin said, "why would the CLR be worse for dynamic languages than the JVM, given that Microsoft had the second mover advantage?" And in fact, while he had to do plenty of extra work to support dynamic features that the CLR doesn't natively offer, he notes that the massive engineering resources invested in the CLR make it highly optimized along a number of axes. So, for example, the CLR's function call overhead is apparently less than the native-code CPython's function call overhead, and this is one of the reasons why IronPython benchmarks well against CPython.

New feature

If you look carefully you'll see that items on the home page now have an "other blogs" link along with the comment link, department link etc.

The "other blogs" link invokes a Technorati search which hopefully shows all blogs referencing the LtU item (if there are any).

Thanks, Anton!

Parallel Programming with Control Abstraction

Parallel Programming with Control Abstraction. Lawrence A. Crowl and Thomas J. LeBlanc. ACM Transactions on Programming Languages and Systems 16(3): 524-576, May 1994

Since control abstraction separates the definition of a construct from its implementation, a construct may have several different implementations, each exploiting a different subset of the parallelism admitted by the construct. By selecting an implementation for each control construct using annotations, a programmer can vary the parallelism in a program to best exploit the underlying hardware without otherwise changing the source code. This approach produces programs that exhibit most of the potential parallelism in an algorithm, and whose performance can be tuned simply by choosing among the various implementations for the control constructs in use.

There were some queries regarding parallel programming constructs, so this paper may be of interest.

Icon Language Implementation and Unicon News

Icon has always impressed me as the most elegant and useful string processing language. In fact, I still use it. The speed impresses me to this day. Lately the out-of-print Implementation of the Icon Programming Language book went online as a PDF download. Not only that, the copyright is public domain.

The successor language Unicon has published the first issue of The Generator, a journal devoted to that language. Unicon is an open-source project. Therefore code from the Icon implementation book lives in Unicon's public code repository. What Unicon adds to Icon is OO, POSIX, and other goodies.

My own plea is for language folks to study (Un-)Icon's string scanning mechanisms. How I wish they were more common. No matter what my task or language du jour, I always find myself longing for Icon when it comes to strings. Doug Bagley offers some OCaml libraries which imitate Icon string techniques.

A Methodology for Generating Verified Combinatorial Circuits

A Methodology for Generating Verified Combinatorial Circuits. Oleg Kiselyov, Kedar N.Swadi, Walid Taha.

This is the final version of a paper accepted for Embedded Software Conference 2004. The paper doesn't show any circuits but the straight-line C code should be implementable easily.

There is a significant difference from FFTW in that the authors don't do any intensional code analysis -- the generated code is black box and can't be processed nor manipulated any further. Moreover, the generated code can't even be compared by equality. Oleg tells me that the paper is somewhat obsolete: it says that they approach FFTW in the number of operations in the generated code. That is no longer true: the power-two FFT generated code has exactly the same number of floating-point operations as that in codelets of FFTW.

Abstract interpretation is used to fix several problems in the generated code. This makes some optimizations possible (e.g., avoiding code duplication).

Multi-stage programming fans, enjoy!

Derrida's Machines

PDF Link

Came across this in my referrers log and thought it might be of interest to others. Reminds in scope of GEB, meandering through Number Theory, Category Theory, Combinatorial Logic, Metaphysics, AI and the Semantic Web, touching programming language issues along the way. Lots of loose ends and uneven in flow but there's various gems scattered throughout (I thought the section that explains CT was good).

What have we learnt on our trip around the fascinating perspectives and problems of a Dynamic Semantic Web? It is all about dynamics and structures. This brings us back to the central topics of DERRIDA'S MACHINES: Interactivity between structures and dynamics, that is, to the interplay of algebras and co-algebras, ruled by category theory and surpassed by the diamond strategies leading to polycontexturality and kenogrammatics.

Guess I'll have to work on my vocabulary as I've never heard of polycontexturality and kenograms.

Grady Booch on software archeology

Booch's Rational User Conference presentation on software archeology is available online.

This is related to our previous discussions about reading code, mining code for patterns and about the history of programming languages and software systems.

Obviously, many of the issues mentioned in the presentation (e.g., SLOC counts) are programming language dependent. The major case study is Eclipse, which should make this interesting to IDEs buffs as well.

See here for more on Booch's work on documenting software architecture.

Haskell Functional Programming Bookstore

John Meacham has set up a print-on-demand bookstore for Haskell-related books at CafePress. There are only a few books there at the moment, but they tend to be things that are otherwise out of print, for instance Simon Peyton-Jones and David Lester's Implementing Functional Languages. In this particular case, Amazon has one used copy for $204, but you can get a brand new one from the Haskell bookstore for $18.50.