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.

Table of Contents

On Lisp extensibility, and its impact on DSL implementation

  • Duration:
    120 min
  • Audience:
    This tutorial is accessible to anyone. Prior knowledge of Lisp is a plus but it shouldn't be required.
  • Description
    Creating a domain-specific language (DSL) is inherently a transversal activity: it usually requires knowledge and expertise in both the application domain and in language design, two completely orthogonal areas of expertise. The difficulty is that either one needs to find people with such dual competence, which is rare, or one needs to add manpower to the project by means of different teams which in turn need to coordinate their efforts and communicate together, something not easy to do either.

    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:

    1. showing that by using a truly extensible GPL, implementing a DSL is considerably simplified, to the point that it may sometimes boil down to writing a single line of code,
    2. exhibiting several of the most important characteristics of a programming language that make it truly extensible, and hence suitable for DSL'ification.

    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.

  • Instructor
    Didier Verna
  • Biography
    Dr. Didier Verna has a Ph.D. in Computer Science and is currently working as an assistant professor for EPITA, a private computer science university located in Paris. He gives lectures on Operating Systems, Computer Graphics, Functional Programming and Typesetting. His research interests include Genericity, Performance, Object Orientation and Functional Programming, all in one language: Common Lisp.

    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…

Programming AllegroGraph in Lisp

  • Duration

    120 minutes

  • Audience:

    Anyone with some Lisp experience and an interest in an RDF graph database.

  • Description
    AllegroGraph is a powerful RDF Graph Database that was built from scratch in Allegro Common Lisp. There are many open source client libraries that interact with the database. The majority of these libraries are in Java, but there are also Javascript, Python, Ruby, Clojure, Perl, .Net, and C libraries. These libraries give you full control over all the functionality in AllegroGraph but none of them give you the total control and server side speed if you are not afraid of lisp and prolog.

    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

    • Getting you on your way:
      • installing and starting the server
      • managing the server through agWebView
      • loading some files
      • navigating graphs through the graphical browser in agWebView
    • Using it in the REPL
      • basic interaction for adding and deleting triples, transactions.
      • inferencing
      • writing rules with Prolog
      • querying with SPARQL 1.1
      • writing Stored Procedures in Lisp and JavaScript (we use cl-javascript)
      • turning Stored Procedures in http service calls
      • social network analysis
    • etc.

What is the best language for compiler writers

  • Duration

    60 minutes

  • Audience

    Those who are interested in writing compiler easily and concisely.

  • Description

    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.

  • Instructor
    Seika Abe
  • Biography

    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).

Allegro CL 9.0 Internals

  • Duration:
    120 min
  • Audience:
    Anyone may attend. Attendees should know Common Lisp, and are encouraged to have at least tried Allegro CL, perhaps from experience on the free Express Edition.
  • Description:
    Allegro CL internals will be discussed, focussing on Allegro CL 9.0. Discussion will include underlying changes from version 8.2, including SMP design decisions and debugger changes, and perhaps a sneak peek at a future version.
  • Instructor
    Duane Rettig
  • Biography:
    Duane Rettig, Senior Software Engineer, holds a BA in Computer Mathematics from San Jose State University. He has been with Franz since September, 1987. Previously, he was employed as a Staff Engineer and a Manager at Amdahl Corp for 6 years in the area of hardware testing. Prior to working at Amdahl, he held engineering positions in testing at Memorex and Information Storage Systems (ISS), two disk drive manufacturers. He has had experience in both hardware and software fields since 1973. As a test engineer, Mr. Rettig wrote various compilers and Artificial Intelligence programs, including a Forth interpreter, a macro preprocessor for test pattern generation, a Guided Fault Isolation program to help technicians find defects in circuit boards, and a natural language English Grammar parser. While at Amdahl, he ported Franz Lisp (from UC Berkeley), Macsyma, and Allegro CL to the IBM 370 Architecture. At Franz Inc., Mr. Rettig has the responsibility of porting, maintaining, and enhancing the basic Allegro CL product and compiler on all architectures.

Good Old Lisp Machines (exhibition)

Touch and feel it, D-machine, Symbolics 3620, and ELIS

  • Description
    1980s is the era of lisp machines in the history of Lisp. Symbolics 3600 series (from Symbolics) and D-machine series (from Xerox) were delivered as commercial AI activity. Before the advent of Macintosh, they were equipped with new generation of user interface, GUI, that is, graphic windows and mouse. The time was exceedingly competitive on Lisp languages. Before the efforts of Common Lisp project, Zeta lisp and Interlisp-D were integrated with new programming environments in which lisp languages provided graphic programming functions on top of lisp-dedicated OSes that were realized by lisp languages. ELIS from Japanese NTT also provided lisp-based Multiple Programming Paradigm TAO under the environment named NUE (New Unified Environment). So, in 1980s we had everything of lisps, for lisps, and on lisps. That is lisp machines.

    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

A walk through the Semantic Technology land

  • Description
    Semantic Technology shares most of the same standards and tools for Semantic Web, but is geared for ICT production today. It is a paradigm shift in information modeling, in which much of the “business logics” is embedded in the model itself rather than in application code. Such application architecture is extremely flexible, easy to evolve and share. It is the most robust and practical way for knowledge representation and engineering today. And, a robust knowledgebase is the essential foundation for practical, real-world AI applications. In this tutorial, we will briefly review what Semantic Technology is, what it is good for and why it is better than traditional technology for certain class of ICT applications. We will give an overview of the basics of Semantic Technology, such as RDF, RDFS and OWL, and commercial tools for ontology editing, semantic database management and reasoning.

    The tutorial will conclude with some example ontology and applications employing Semantic Technology.

Author: Association of Lisp Users

Date: 2012-10-29 09:28:02 JST

Generated by Org version 7.8.11 with Emacs version 24

© alu 2012