Tutorial sessions will be held on Sunday, October 21. Tutorial registration is included within the Full Registration fee and with Daily Registration for October 21.
One additional complication is that being an expert developer in one specific programming language does not make you an expert in language design – only in using one of them. DSLs, however, are most of the time completely different from the language in which the embedding application is written, and a general-purpose programming language (GPL), suitable to write a large application, is generally not suited to domain-specific modeling, precisely because it is too general.
As a consequence, it is often taken for granted that your application's DSL has to be completely different from your application's GPL. But what if this assumption was wrong in the first place ?
The need for designing a DSL as a completely new language often comes from the lack of extensibility of your GPL of choice. By imposing a rigid syntax, a set of predefined operators and data structures on you, the traditional GPL approach gives you no choice but to implement your application's DSL as a different language, with its own lexical and syntactic parser, semantic analyzer and possibly its own brand new interpreter or even compiler.
A much less widely accepted view, however, is that some GPLs are extensible, or customizable enough to let you implement a DSL merely as either a subset or an extension of your original language. The result is that your final application, as a whole, is now written in a completely unified language. While the end-user does not have access to the whole backstage infrastructure and hence does not really see a difference with the traditional approach, the gain for the developer is substantial. Since the DSL is now just another entry point for the same original GPL, there is essentially only one application written in only one language to maintain. Moreover, no specific language infrastructure (parser, interpreter, compiler etc.) is required for the DSL anymore, since it is simply expressed in terms of the original GPL. The already existing GPL infrastructure is all that is needed.
The purpose of this tutorial is to envision the process of DSL design and implementation from the perspective of extensible languages, and to show how the capabilities of the original application's GPL can have a dramatic impact on DSL conception. More precisely, the objective of is twofold:
The tutorial will consist of a live implementation of a particular DSL in Common Lisp, gradually introducing the features that make the language very extensible. Such characteristics are most notably dynamicity (not only dynamic typing, but in general all things that can be deferred to the run-time), introspection, intersession, structural or procedural reflexivity, meta-object protocols, macro systems and JIT-compilation.
Didier Verna is also quite involved in free software: he has been one of the core maintainers of XEmacs for more than 10 years. He is also the author of several LaTeX packages (FiNK, FiXme, QCM and CurVe) and an occasional contributor to other Free Software projects (the GNU Autotools most notably; he was one of the technical reviewers for the "Goat Book").
Didier Verna is a member of the European Lisp Symposium steering committee and serves as a program committee member in various conferences (International Lisp Conference, European Lisp Symposium, Dynamic Languages Symposium, Context-Oriented Programming workshop, ACM Symposium on Applied Computing).
Didier Verna is also a semi-professional Jazz musician, but that is another story…
120 minutes
Anyone with some Lisp experience and an interest in an RDF graph database.
In my tutorial I will walk you through all the things that you get from AllegroGraph if you are a lisp programmer. Here is a short summary of the highlights
60 minutes
Those who are interested in writing compiler easily and concisely.
This talk explores what is the best programming language for compiler writers based on my experiences of writing compilers, interpreters, and static program analyzers.
First, I would like to introduce myself as a compiler writer to make this talk real, and then propose a criteria for writing compilers easily and concisely which the best language should clear.
Finally, based on the criteria, some programming languages are evaluated and compared with each other. Mainly mentioned languages here are Lisp, C, Haskell, and Java.
Seika Abe is a programmer of Mathmatical Systems inc. His representative works concerning this talk are C compiler for Super-Nintendo (written in Lisp, and then in C), A retargetable compiler system (in EmacsLisp), Slice analizer (in Haskell), Data flow analyzer (in Lisp, and then in Java).
Touch and feel it, D-machine, Symbolics 3620, and ELIS
In this exhibition, volunteers in Japan present and exhibit three kinds of lisp machines:
Visit this exhibition!
Touch the good old lisp machines and feel the novelty that you do not feel the oldness even today.
You will be fascinated with and envious of lisp integrated environments for lisp programming.
Symbolics 3620 by courtesy of Shozo Takeoka (AXE, Inc.)
ELIS 8100, 8200 by courtesy of Yasushi Hibino (JAIST Collection of Symbolic Processing Computers)
Fuji-Xerox 1121AIW by courtesy of Seiji Koide
The tutorial will conclude with some example ontology and applications employing Semantic Technology.
Date: 2012-10-29 09:28:02 JST
Generated by Org version 7.8.11 with Emacs version 24
© alu 2012