« Binding! The beer of choice for Computer Science | Main | How American are Startups? »
May 17, 2006
More Dagstuhl Talks
Modules
Matthew Flatt
A module is "the way you share code with other programmers"
Module systems in different languages: Python, Ruby
Mutually dependent modules are the first issue
Ruby example: mutually dependent modules sometimes work (when required from files) but dependent on order of execution. Shows that a module definition is a side-effecting operation. Similarly a module may be extended. Hence a module is a runtime concept.
Ruby modules also function as mixins.
MzScheme modules are not side effects. Runtime order does not matter. However expand time (aka static analysis time) order does. Mutually dependencies disallowed. Use units for mutual dependencies. (New!) Unit/signature modules. A module can be written in a unit or signature language. External linking -- the module no longer decides what it links to (cf internal linking, the usual method).
Scheme48 modules, known as structures. Similar to MzScheme units and ML functors. However allows units to export macros, unlike MzScheme.
Smalltalk modules
Alexandre
Smalltalk 80 has no modules. Distribute changesets. Changesets have no composition.
VisualWorks/Squeak packages track their changes and so can be uninstalled. Packages have prerequisites.
Selector namespaces in Modular Smalltalk. They are not reentrant. Seems to have strange scoping rules.
Classboxes allow re-entrance.
CPAN
Mike Sperber
Pragmatics and deployment.
Tools create boilerplate. Standard format for packaging and creation.
Online distribution (CPAN) and shell for retrieval and installation. Can automatically install dependencies.
Perl code may branch depending on installed modules and versions.
Social features (e.g. number of available modules) make it difficult to change the implementation. For instance, you can only have 1 version installed at a time. Cf PLaneT allows multiple versions. However there are still issues with loading multiple versions at once.
Java's Future
Gilad Bracha
JSR-277 attempting to add a module system for Java. Main interest is deployment, versioning etc.
Initial proposed system: modules are like units -- parameterised.
Actual proposed system: no language changes allowed. Instead embed using reflective API. Turing complete therefore any particular implementation possible (first-class, higher-order, etc.)
Module implementations check for prerequisites at runtime. Just code, so anything is allowed. Lots of state.
My comments: As usual for Java has taken a reasonable idea and turned it into a huge hairball.
Soapbox Session
Context-oriented Programming
Pascal Constanza
Make program change behaviour due to context of use (e.g. personalisation) without making it a huge hairball.
Basically a new type of modularity. Similar to aspects, and OO inheritance / overriding.
F-Script
Philippe Mougin
Open source scripting language for Cocoa / OS X
Unifies OO and array programming
Interactive environment.
Source Code Mining for Latently-Typed Languages Dave Mandelin
Extracting information from source code. Perhaps to find out how to use a library from example code.
Example: what are the types of the arguments in a latently typed language?
[Reflection!]
BabyUML
Trygve Reenskaug
Modularity, again.
My comments: I didn't really get this talk, so my summary is brief and perhaps incorrect.
Ambient Oriented Programming
Ambient resources and volatile connections
Non-blocking communication
Reified communication traces
Reified environmental context
OO sans classes to handle code updates
Converge
Laurence Tratt
Pythonic language with compile time metaprogramming ala Template Haskell.
Converge's role is to host DSLs, and so must be very flexible. In a senese a Lisp with curly braces.
Customisable parsing.
Father Time
Greg Cooper
MzTake
Guillaume Marceau
My comments: I've seen FrTime and MzTake before so I didn't take notes. If they're new to you check them out -- they come as part of PLT Scheme
Posted by Noel at May 17, 2006 09:47 AM