From Lang.NET 2008 – Wednesday

Alrighty… we’re online. I checked in on #debian-mono, and meebey had plenty of suggestions on how to fix the .deb.

There’s a talk on IronRuby. Microsoft is implementing a Ruby compiler on the CLI. It uses the DLR to do the heavy lifting. It is currently slow :)

Contributions are being accepted for libraries outside of the core, but not against the implementation of the compiler.

This talk is on a Ruby compiler/runtime built on the CLI without using the DLR. One of the benefits is that it allows for ahead-of-time compiling, unlike implementations which use the DLR.

On the drive down today, I was contemplating how Perl6 might handle importing modules from “external” sources. It looks like someone else has already thought about this. Perl6’s module docs can be found in Synopsis 11 of the Official Perl 6 Documentation.

More thoughts on the issue with the DLR’s DynamicSite interface and the problem it poses regarding ahead-of-time compiling. DynamicSite allows fast paths to be determined during runtime. As methods and operators get used, they get bumped up in the priority. This allows the runtime to optimize for the user’s use case without having to hard-code stuff that’s hard to optimize. One of the drawbacks is that it makes it difficult to do ahead-of-time compilation.

A possible solution to this would be to serialize the state of the DynamicSite object into an .exe when the runtime exits. This way, the DynamicSite could be deserialized when next the DLR loads a program for the language. I don’t know how feasible this is, but it might be interesting to try. Theoretically, this concept might make use of Linden Labs’ work on stack serialization, ie Continuations, as a different solution to the same problem.

The current talk is on F#. The language reminds me of a blog post on Caml which I read a few years ago in Evan Martin’s blog.

Seo showed me a version of the F# example running on Debian sid. Whee.

Parsing in F#
Harry Pierson

Discussing parsing expression grammars.
1.9.2 of F# includes “Active Patterns”, an interesting approach to building compilers.

This has been documented in his blog. Here’s an example from his presentation:

/// Additive <- Multitive '+' Additive | Multitive
and (|Additive|_|) inp =  match inp with
       | Multitive(v1,Token '+' (Additive(v2, inp))) -> Some(v1+v2)
       | Multitive(v,inp) -> Some(v,inp)
       | _ -> None

Neato. Someone from Intentional Software is presenting a language which includes code written using mathematical representation, diagrams, etc. They call it “literate programming” and mentioned Don Knuth as the person responsible for the concept which they have implemented.

While I’m watching the presentations, I’m trying to add ToyScript to the prebuild.xml file and see if I can get it integrated into the .deb distribution.

That was relatively painless. I’ve gotten rid of the original dlr-solution-1.0.tar.gz and replaced it with dlr-solution-0.0.1.tar.gz, which better indicates the state of the codebase. Sorry for breaking history.

Next talk is on NStatic a static analysis tool. The author, Wesner Moise, writes a blog called “SmartSoftware” and owns an LLC. I have a feeling it only runs on win32… The application is IDE-ish in nature. Very cute and user-friendly looking. The author claims that it has a debugger-like experience, which presents discovered errors. Errors are presented in the context of the executing environment to assist the user in correcting the problem. Errors also contain the stack/execution path which lead to the violation. In the UI, the execution path is indicated using arrows, non-executed code is dimmed.

The author is now accepting applications for beta testers. He does not shake hands :)

Miguel’s talking about Cecil. It can be used to build a native binary from managed code. Nifty. – Seo tells me that I misunderstood. D’oh.

His examples of Moonlight were pretty neat. Novell can’t ship ffmpeg, so nobody can get a usable distribution right now. Microsoft has promised to give Mono a media framework that can be redistributed.

The Novell Mono team is working on new features which Moonlight requires. Mono did not previously have a CLI verifier. It is required for Silverlight. The runtime is becoming hardened. A security sandbox is being implemented.

The team is also working on some automation tools:
* Static analysis with Gendarme. think “customizable FxOp”
* Monoxide (assess audit surface).

When the above are done, the Second Life folks will be able to open the doors to languages other than LSL when the above tools are complete.

Novell is shipping a Moonlight SDK. This consists of a compiler and class libraries. There is a prototype of Monodevelop on MacOS X. There is also a prototype of a Moonlight IDE. Fancy.


* object-oriented, imperitive
* run-time performance
* static & dynamic typing
* Nil tracking
* Cleaner syntax than perl
* Contracts built-in
* built-in unit test syntax as a language feature
* works on Mono
* compiler will be “open sourced” in February
** there will be a wiki
** there will be an issue tracker
** there will be discussion forums

I’m working with meebey’s debian packages of mono. They’re a little tricky to get building. They complain that mcs.exe and friends are missing from mcs/class/lib/net_1_1_bootstrap/ and mcs/class/lib/basic/ when run out of the box. I’ve found that dropping the assemblies generated by building from svn into those directories seems to work. *crosses fingers*

I assume that if I can install these packages, I will be able to build the dlr packages using them. I’ll stick them on the web server for reference.

Current talk is by some Visual Studio folks. They are discussing what is required to make a language play nice with Visual Studio.

regarding the debian/ problem I had earlier, dmoonfire told me that I should use dbuild instead of running the various debian/rules targets individually. It seems to run much better that way :)

The current talk is about the Visual Studio 2008 Shell. It seems nifty. One can build a stand-alone IDE that makes use of the visual studio interface. The resultant redistributable package will run without having to purchase visual studio. Yay. Free as in beer. Or was that lunch?

The IronPython Studio is available on codeplex. Looks similar to Visual Studio 2008. Comes with solution explorer, toolbox, debugger, output windows, winforms designer, intelisense. The only projects available in the “new project dialogue” of the IronPython Studio are those related to IronPython.


Don box. I’ve heard of him. He’s talking about “Modeling and Languages.” Chris Anderson is supporting.

Doesn’t like WSDL or XSD.


  • Write less code
  • Understand our software (and hardware)


  • Increase data/code ratio in the platform
  • Representations matter (a lot)

Philosophy : Data + interpretation

Data == values devoid of context
Interpretation == applying context to data
One value, many interpretations

The Platform Premise : Data-driven capabilities
1992: /subsystem:
1993: MKTYPLIB.exe
1996: [TransactionRequired]
1999: wsdl:definitions
2000: xlang:process
2002: [YourAttributeGoesHere]
2006: wf:StateMachine
2006: wf:Policy
2006: wpf:ContentControl
2008: Expression(Of Func(Of T))

He keeps using “data” as a singular. gar.

The end.

Oops. I meant to say KTHXBYE.

, , , , , , , , , ,

%d bloggers like this: