Slash Boxes
NOTE: use Perl; is on undef hiatus. You can read content, but you can't post it. More info will be forthcoming forthcomingly.

All the Perl that's Practical to Extract and Report

use Perl Log In

Log In

[ Create a new account ]

autrijus (1505)

  (email not shown publicly)

Journal of autrijus (1505)

Saturday July 16, 2005
01:47 PM

Day 163: Papers... and more papers.

[ #25742 ]
Before putting PIL evaluator to action, I thought I'd take some time off to read relevant papers. But as I chase the references, everything seems to be related to each other, and before long I find myself reading fascinating things that may not have any obvious connections with PIL. ;-)

Stevan asked me to put links to what I've read. Below is a quite incomplete list, in roughly chronological order.

I started off with the two QuickCheck papers. I had a passing understanding of specification-based testing, mostly via Test::LectroTest, but the papers highlighted many aspects I've never thunk of. Grokking the coarbitary construct is a lot of fun; it is fascinating how QuickCheck can generate arbitary functions randomly, purely based on its type signature.

From QuickCheck I've moved to Scrap your boilerplate with class, the third paper in the SYB series, which provides a nice way to do generic programming in Haskell. In the design pattern world, the generic programming strategies would be known as visitor, composite and other related patterns; in the SYB papers, similar ideas are expressed in a very concise fashion, and the notion of type class variables feels very natural indeed.

SYB's predeccessor, Strafunski, proved to be rather hard to grok in one sitting. I got sidetracked to its SDF component, which describes a nice way to do scannerless parsing -- that is, parsing directly from character level, without a tokenizer. Pugs uses this approach too, and I confess I've never felt the use for a tokenizer. But perhaps I'm spoiled by fast computers, perl5's capable regex engine, and the even more capable Parsec. Still, SGLR/SDF is far easier to reason about than parser combinators or regex with embedded code, and if its claim of superior performance is true, the it's definitely worth more investigation.

From there I moved to the Lambda cube, and the Calculus of constructions (CoC). First-class types and bindings is one of Perl 6's shining new features; the design team recognizes its importance and uses, but very little is understood in how it works in the implementation level, and how it interacts with constraint-based subtyping.

As CoC allows no subtypes, I turned to Scala, an advanced multi-pradigmic language featuring not only subtyping and trait-based mixins, but also generics, views, macros and inferencing, which are all underspecified parts of Perl 6. I have just begun reading the Scala papers, but the first one (the vObj paper) is already extremely enlightening -- especially because it contains detailed comparison with both OO-style languages like Java, as well as functional-style languages in the ML family.

I have also looked at PyPy's parser and evaluator, and skimmed through many other papers in several detours, but the above are the primary ones. The lyf so short, the craft so longe to lerne...

The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
More | Login | Reply
Loading... please wait.