Lambda the Ultimate

I just stumbled across the February 28 development-blog posting from the commercial online game Vendetta Online:

The new erlang based system is now in production. For those who haven't been following, we ran into problems with our existing Lisp-based system (named "Deliverator") which handles high-level AI behaviour.. large groups of NPCs, large battles and the like. Over the last couple of months, we've been in the process of migrating to a much more scalable architecture (named "Kourier") based on Erlang, an elegant distributed-programming platform. ...

I do enjoy starting the day with a nice cup of coffee and an interesting read like this. :-)

No matter what your opinion of Forth, this is an enticing paper. J.V. Noble takes an interesting problem from rough implementation through an elegant solution which takes advantage of the compile-time features of Forth. There aren't many easily accessible papers that show how beautiful Forth can be, so this is worth taking some time to understand, especially if you've a fondness for stack-based languages.

The Design and Implementation of a Dataflow Language for Scriptable Debugging, Guillaume Marceau, Gregory H. Cooper, Jonathan P. Spiro, Shriram Krishnamurthi, and Steven P. Reiss.

Debugging is a laborious, manual activity that often involves the repetition of common operations. Ideally, users should be able to describe these repetitious operations as little programs. Debuggers should therefore be programmable, or scriptable. The operating environment of these scripts, however, imposes interesting design challenges on the programming language in which these scripts are written.

This paper presents our design of a language for scripting debuggers. The language offers powerful primitives that can precisely and concisely capture many important debugging and comprehension metaphors. The paper also describes a pair of debuggers, one for Java and the other for Scheme, built in accordance with these principles. The paper includes concrete examples of applying this debugger to programs.

We've seen a paper on compiling dataflow languages, so here's one on an interesting application.

The Java Open Review Project identifies and reports bugs and security vulnerabilities in widely used Java open source software...The identification process is powered by Fortify Source Code Analysis (SCA) and Findbugs.

This may be an easy way to get a glimpse at what static analysis tools can do. Reviewing the potential defects identified by the automatic tools is a good starting point for thinking about the implications of various decisions about language semantics, and about language expressiveness in general.

To see actual code, you need to login using the guest account details provided on the page.

Second Life Faces Threat to its Virtual Economy

Groups of Second Life content creators were gathering digitally Tuesday to protest the dissemination of a program they worry could badly damage the virtual world's nascent economy.

The controversy gathered steam Monday when Linden Lab, which publishes Second Life, posted a blog alerting residents of the virtual world to the existence of a program or bot called CopyBot, which allows someone to copy any object in Second Life. That includes goods such as clothing that people purchase for their in-world avatars, and even the virtual PCs that computer giant Dell announced Tuesday it is going to sell in the digital world.

Related to this thread, especially my "Not Merely Predictable" post, as well as the various Lightweight Static Capabilities and Robust Composition threads. I'm absolutely convinced that a future language design will evolve to accomodate the development of distributed systems in which these kinds of issues are impossible to impose. Is it time to add an "object capability security" and/or "cooperation without vulnerability" (a great phrase from Mark Miller) category to LtU?

Testing Telecoms Software with Quviq QuickCheck by John Hughes, Thomas Arts, Joakim Johansson, Ulf Wiger.

We present a case study in which a novel testing tool, Quviq QuickCheck, is used to test an industrial implementation of the Megaco protocol. We considered positive and negative testing and we used our developed specification to test an old version in order to estimate how useful QuickCheck could potentially be when used early in development.The results of the case study indicate that, by using Quviq QuickCheck, we would have been able to detect faults early in the development.We detected faults that had not been detected by other testing techniques. We found unclarities in the specifications and potential faults when the software is used in a different setting. The results are considered promising enough to Ericsson that they are investing in an even larger case study, this time from the beginning of the development of a new product.

That's right, the illustrious John Hughes is dropping out of school to do an Erlang startup!

Bjarne Stroustrup. A rationale for semantically enhanced library languages. LCSD05. October 2005.

This paper presents the rationale for a novel approach to providing expressive, teachable, maintainable, and cost-effective special-purpose languages: A Semantically Enhanced Library Language (a SEL language or a SELL) is a dialect created by supersetting a language using a library and then subsetting the result using a tool that “understands” the syntax and semantics of both the underlying language and the library.

How similar or different this idea really is compared to the facilities found in PLT Scheme and other previous apporaches to this issue?

This is the inaugural edition of Code Reads, a weekly discussion of some of the central essays, documents and texts in the history of software. This week we're talking about Frederick Brooks's The Mythical Man-Month. (OK, let's be honest: I'm talking about it. I'm hoping you, or you, or you, may want to, as well!

This is an ongoing series with Dijkstra's "Go To Statement Considered Harmful" coming up. This essay was mentioned here a few times, of course, so you might want to check the archives.

This item is not directly language related, but since you can win prizes, I thought I'd better let you guys know..

Tim Bray writes about advanced IDE feature support for dynamic languages, a subject that was debated here at length a few times.

Lest this turn into the usual flamefest, I suggest concentrating this time on practical implementation approaches that can help with implementing dynamic language support in IDEs.

Samurai - Protecting Critical Heap Data in Unsafe Languages.
Karthik Pattabiraman, Vinod Grover, Benjamin G. Zorn.
September 2006.

Programs written in type-unsafe languages such as C and C++ incur costly memory safety errors that result in corrupted data structures, program crashes, and incorrect results. Previous approaches to eliminating these errors attempt to eliminate all unsafe memory operations in a program. We present Samurai, a runtime system that allows programmers to selectively identify heap objects that are critical to correct execution of their program. Samurai supports operations to consistently read and update critical data and probabilistically guarantees that no other memory updates in the program will corrupt critical data. Samurai uses replication and randomization to provide these consistency guarantees. Because Samurai is oblivious to memory operations on noncritical data, the majority of memory operations in programs run at full speed, and Samurai is compatible with 3rd party libraries. We have annotated five benchmark programs with Samurai and we present measurements of the execution overhead and fault tolerance that Samurai provides. Samurai can be applied selectively to parts of a program’s heap allowing the execution overhead to be tailored for the needs of a particular application.

Essentially, you use a custom memory allocator for critical objects, so that they are stored redundantly (i.e, they are replicated).

Related reading: Failure-oblivious computing.