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.

It's the language, stupid. Or is it?

In a forum dedicated to programming languages is it is easy to get carried away, and forget that choosing a programming language for a project is not just about finding the best or most expressive language possible, but often very much dependent on the platform for which the software is developed.

An interesting blog post about web applications, AlphaBlox and Oddpost should help drive this point home.

It describes the struggle it took to develop applications with rich user interfaces for web browsers, especially early versions of IE. Javascript was the programming language used.

Along the line browsers evolved (as well as the browser-language interface called the DOM), the language matured, and programming techniques were discovered.

So, yes, it is the language. But it is good to keep in mind that things are not always a simple as they may seem on first sight.

The C++ Source Journal

via Digital Mars C++

C++ [is] indisputably the most powerful programming language in the world. For reasons understood by many, it has, however, become a very complex language, and many a novice has followed after the siren song of lesser languages.

So is launched The C++ Source, the authoritative voice for the C++ community on the web. The board of editors is a veritable Who's Who of C++. Articles are peer-reviewed. There is not much content yet, but it looks like they offer live feeds. The journal's premiere article, "The Spirit of C," offers a potted history of C.

Like BCPL, B was a typeless language with a rich set of operations on machine words... How well does B embody The Spirit [of C]? Almost perfectly, in my opinion. "Trust the programmer" and "Don't prevent the programmer from doing what needs to be done" are obvious characteristics of a typeless language. [Meanwhile, however, the] C++ language is very nearly completely type-safe, which is a good thing, as its type system is arguably the most complex of any language.

Put that in your pipe and smoke it.

Streaming Representation-Changers

Jeremy Gibbons (2004). Streaming Representation-Changers. To appear in Mathematics of Program Construction, July 2004.

Unfolds generate data structures, and folds consume them. A hylomorphism is a fold after an unfold, generating then consuming a virtual data structure. A metamorphism is the opposite composition, an unfold after a fold; typically, it will convert from one data representation to another. In general, metamorphisms are less interesting than hylomorphisms: there is no automatic fusion to deforest the intermediate virtual data structure. However, under certain conditions fusion is possible: some of the work of the unfold can be done before all of the work of the fold is complete. This permits streaming metamorphisms, and among other things allows conversion of infinite data representations. We present the theory of metamorphisms and outline some examples.

More origami work from Gibbons.

This paper is related to several previous papers by Gibbons that were mentioned here (e.g., spigot pi, arithmetic coding), and it could be said that it summarizes the main results. I don't think this paper was linked to directly, so here goes.

Routine Maintenance

Later today we are going to do some routine maintenance. During this period posting new
item may be disabled. If all goes well, the the time window in which posting is disabled is going to be short.

Wobbly types

Wobbly types: type inference for generalised algebraic data types

Simon Peyton Jones, Geoffrey Washburn, and Stephanie Weirich.
July 2004

Generalised algebraic data types (GADTs), sometimes known as "guarded recursive data types" or "first-class phantom types", are a simple but powerful generalisation of the data types of Haskell and ML. Recent works have given compelling examples of the utility of GADTs, although type inference is known to be difficult.

It is time to pluck the fruit. Can GADTs be added to Haskell, without losing type inference, or requiring unacceptably heavy type annotations? Can this be done without completely rewriting the already-complex Haskell type-inference engine, and without complex interactions with (say) type classes? We answer these questions in the affirmative, giving a type system that explains just what type annotations are required, and a prototype implementation that implements it. Our main technical innovation is wobbly types, which express in a declarative way the uncertainty caused by the incremental nature of typical type-inference algorithms.

Edit: Made the title into a hyperlink, as the "Postscript" link could easily get lost in a sea of blue text...

Edit 2:Quoted the article with a plain-ol' <blockquote> instead. Better?


C-omega, Microsoft Research's experimental language featuring asynchronous concurrency (formerly, Polyphonic C#) and XML data types (Xen), is now available for download.

I think this is an interesting project. It was discussed here several times in the past.

I think that the integration of the new features with the core language is quite nice (e.g., XML types and the type system), so I suggest taking a look even if you are not particularly in favor of embedding XML in programming language.

The Cw home page includes links to relevant papers. And here's a LtU discussion of Xen and a discussion of Polyphonic C#.

The ongoing LtU discussion.


This project's goal is to provide integrated support for Aspect Orientated Programming in Oracle's JDeveloper IDE. Where possible we hope to make use of, and reuse code from, projects that have solved similar problems for other IDEs. The initial focus of the project is to integrate ADJT, the AspectJ design time environment, into JDeveloper.

It would be interesting to see whether projects such as this will help get AOP accepted by industry.

New CLR Language: Boo

This project is very interesting: a CLR-based language with Python-esque syntax, optional type declarations, open compilation pipeline, and some interesting ideas about generators and class attributes. There are some unique ideas about running a dynamic language atop the CLR, as well, like syntax to declare "duck" typing for individual objects, which lets you use them as dynamic proxies for COM objects, web services, etc.

It's definitely a bit green, but if even a significant fraction of the features discussed in the "manifesto" are there, it looks like an impressive effort, regardless.