Lambda the Ultimate

Well, at least according to this article.
Much as I like Ada, I find this article a bit unbalanced, so feel free to criticize it and the language, if you like.

On the same subject as the Scheme compiler in 90 Minutes, is the Essential Haskell Compiler. From the HC&AR summary:

The purpose of the EHC project is to provide a description a Haskell compiler which is as understandable as possible so it can be used for education as well as research


In order to avoid overwhelming the innocent reader, the description of the compiler is organised as a series of increasingly complex steps. Each step corresponds to a Haskell subset which itself is an extension of the previous step. The first step starts with the essentials, namely typed lambda calculus.



Sounds like BC Pierce's Types and Programming Languages.
Also notable is that EHC uses Utrecht's Attribute Grammars, which are interesting in their own right.

At a session entitled "The Great J2EE vs. Microsoft .Net Shootout" at the OOPSLA conference here this week, software development superstars debated the relative strengths and weaknesses of Microsoft's .Net and Sun's Java 2 Platform, Enterprise Edition. The panelists included Anders Hejlsberg, Microsoft Corp. distinguished engineer and lead designer for the C# language; John Crupi, chief Java architect for Sun Services at Sun Microsystems Inc.; Don Box, leading Microsoft architect on its Indigo project; Rob High, IBM's chief architect for the WebSphere Application Server Family; and Alan Knight, lead developer for the Web Toolkit at Cincom Systems Inc. and a Smalltalk expert.

From the eWeek coverage it would seem that the panelinsts didn't explore the deep, underlying, issues (but then, for that you read LtU).

Still, some of you might want to check out this article for yourselves.

An article from IEEE Security & Privacy magazine.

The article is an accessible introduction to the idea of static code analysis. Several security-related tools are described.

I guess it's tool-week here on LtU what with Dialyzer, JFluid and now this...

According to Infoworld,

JFluid is a "profiling" tool, software that examines Java applications and informs developers of potential performance bottlenecks in their code. It was developed by a team lead by Misha Dmitriev, who was transferred from Sun Labs to the software group last week, according to a statement on Sun's Web site.

Which makes me wonder about performance tools in IDEs. On the one hand, performance can be an important factor in software development, and educating programmers about performance isn't such a bad idea. On the other hand, performance considerations are often abused ('the root of all evil,' and all that).

So what kind of performance tools do we really want inside our IDEs? How is the answer effected by the type of programming language language considered? How about IDEs targeting students (DrScheme etc.)?

A highlight from the Erlang/OTP User Conference 2004:

The Dialyzer is a static analysis tool that identifies software discrepancies such as obvious type errors, unreachable code, redundant tests, virtual machine bytecode which is unsafe, etc. in single Erlang modules or entire applications. Currently, it starts its analysis from BEAM bytecode and reports to its user the functions where the discrepancies occur and an indication of what the discrepancy is about.

A lot of static-analysis programs have been written for Erlang but this is the first one that programmers have immediately downloaded, used, and liked. I would love to see more researchers following the development philosophy they describe in their paper.

I don't remember a discussion here about JBoss's use of AOP.

This is somewhat related to J2SE 5.0, mentioned yesterday, specifically JSR-175, being based on metadata annotations.

Two related papers are Aspectizing Server-Side Distribution (ASE 2003) and The JBoss Extensible Server (Middleware 2003) [both PDFs].

ZigZag has been mentioned on LtU only in passing. I think it merits a story, although no personal opinion is implied.

I have always tended to disagree, but there is more and more to disagree with as the computer field gets worse and worse.

The world is unanimous about "computer basics" and "computer literacy". They tell beginners: computers are built around hierarchical directories, word processing, the Desktop, databases, the one-way links of World Wide Web.

Lies. All lies.

These things are, of course, the present reality. But they are no more true and natural than hamburger being the true and natural form of cows, or Central Park being the true and natural form of uptown Manhattan.

The ZigZag tutorial descibes the idea this way:

The ZigZag system is very hard to explain, especially since it resembles nothing else in the computer field that we know of, except perhaps a spreadsheet cut into strips and glued into loops.

It is a PRINCIPLED SYSTEM OF INTERCONNECTION.

Lists and Spreadsheets are rational ways of connecting things, but they have shortcomings. Hierarchical directories are a standard way of connecting things, but they have extreme shortcomings.

The ZigZag structure...is extremely simple but has remarkable properties.

(via Gordon)

PLaneT is PLT Scheme's centralized package distribution system.

PLaneT provides automatic run-time module distribution and caching.

Cute, and be sure to check out the available packages on the PLaneT website, as well as the implemenetation details.

Some kind of language support for error handling (e.g exceptions of various kinds, on error blocks, Maybe types, continuations etc.) has become standard. The exact mechanism is yet another language design decision designers have to make.

Eric Lippert describes VBScript's error handling mechanims. The VBScript approach is perhaps more confusing than it has to be (though I personally didn't find Eric's examples confusing). Tying exception handlers to blocks is more structured and perhaps better.

Be that as it may, I think better error handling constructs are still waiting to be discovered (or designed).