Seven tutorial sessions will be held on the first day of the conference, Sunday March 22nd. Tutorial registration is included within the conference registration fee.
The Common Lisp Object System (CLOS) is unique in two ways.
In most OOP languages, methods belong to classes and are invoked by sending messages. In CLOS, methods belong to generic functions, which select and execute the correct methods according to the types of the arguments they receive.
The CLOS Metaobject Protocol (MOP) specifies how its essential building blocks are implemented in CLOS itself. This allows changing and extending the semantics of CLOS for a well-defined scope.
In this tutorial, you will learn about these powerful concepts, with a focus on the general ideas instead of technical details. I will develop - live during the tutorial - the code for an interpreter for generic functions that performs selection and execution of methods. I will then discuss how that interpreter can be extended to introduce, for example, multimethods and advice, and sketch how generic functions are made efficient in actual CLOS implementations. In the second part, I will illustrate the extensibility of CLOS by implementing - live - the Python object model as a metaclass. Other practical extensions based on the CLOS MOP are also sketched.
One goal of this tutorial is to present the concepts and strengths of metaobject protocols that are relevant in practical and especially industrial settings. You will get the necessary insights as well as pointers to literature and online material to deepen your knowledge.
This tutorial will be given in two parts of 90 mins each. The first part introduces the notion of generic functions, while the second part focuses on the CLOS MOP. If you already understand generic functions and how they accomplish method selection and application, you can safely skip the first part and attend just the second part of the tutorial.
Programming Technology Lab, Vrije Universiteit Brussel
Pascal Costanza has a Ph.D. degree from the University of Bonn, Germany, and currently works at the Vrije Universiteit Brussel, Belgium. He has been involved in the specification and implementation of the languages Gilgul and Lava, and the design and application of the JMangler framework for load-time transformation of Java classes. He has also implemented aspect-oriented and context-oriented extensions for CLOS that heavily rely on its MOP. He is furthermore the initiator and lead of "Closer", an open source project that provides a compatibility layer for the CLOS MOP across multiple Common Lisp implementations.
Software systems must adapt to changing contexts over time, even while they are running. Context-oriented Programming (COP) directly supports variability depending on dynamic attributes. In effect, it is possible to dispatch behavior on any properties of the execution context. This is important because any information which is computationally accessible may indeed form part of the context upon which behavioral variations must depend. ContextL is one of our first programming language extensions that explicitly support COP, and is realized as an extension to the Common Lisp Object System. In ContextL, programs consist of partial class and method definitions that can be selected and composed at runtime as needed, encouraging continually adjusting behavior of programs according to their context of use. ContextL is already successfully used worldwide in academic and industrial settings and have illustrated how COP principles can be used to better support a wide range of applications: multiple views on the same object which are selected based on execution context, context-aware web applications, coordination of screen updates, discerning of phone calls based on the context of both callers and callees, selecting billing schemes based on dynamic context conditions, and traversals of expression trees, to name a few. This tutorial covers an introduction to essential COP principles (behavioral variations as layers, dynamic activation of layers, activation scope), illustrates basic constructs of ContextL, and shows how do develop comprehensive realistic examples of context-aware software systems. It also discusses implementation issues, especially with regard to integrating ContextL with the CLOS Metaobject Protocol and retaining efficient method dispatch. Open issues and directions for future research will also be sketched.
This tutorial will be given in two parts of 90 mins each. The first part introduces ContextL and its basic constructs, including an illustration of its reflective hooks for extending it with new features. The second part discusses the integration of ContextL with the rest of Common Lisp indepth. If you already understand the basics of ContextL, you can safely skip the first part and attend just the second part of the tutorial. The second part of this tutorial is addressed at a more advanced audience and assumes that you already have a good understanding of the CLOS MOP and its concepts. It may be worthwhile to attend my other tutorial on Generic Functions and the CLOS MOP first.
Programming Technology Lab, Vrije Universiteit Brussel
Biography — see above
Tk is a graphics toolkit for the tcl programming language developed by John Ousterhout. Initially developed for the X-Window system, it has been ported to a wide selection of operating systems, including Windows and Mac OS. This makes Tk the ideal base for a powerful and portable GUI library.
LTk is a Common Lisp binding of Tk. It wraps the Tk library seamlessly with CLOS objects. This way it provides the GUI widgets as first class Common Lisp objects. No Tcl knowledge is required to write user interfaces with LTk. As Tcl/Tk is available for all common platforms, and LTk is written in pure ANSI Common Lisp, it require no installation other than compiling and loading ltk.lisp itself. This makes LTk a very accessible and available on almost all Lisp implementations and operation systems. Thus, LTk is a very beginner friendly GUI platform.
This tutorial aims to give all interested participants a detailed introduction into LTk and all involved technologies. Sample applications will be built and hopefully many questions from the audience answered.
Cadence Design Systems
Peter earned his degree in physics at the University of Cologne, where he worked on holography, optical data storage and pulse laser absorption in crystals. He worked as a freelancing programmer for several years before he became a Services Applications Engineer at Cadence Design Systems, a leading vendor for electronic design automation (EDA) software. His private projects include creating and maintaining the first large multiuser adventure written in Java, Dawn of the Ages, as well as the creation of the GUI toolkit Ltk.
Functional programming, interoperability, extensibility and concurrency objectives call for different decisions at many Lisp design points. Meeting those objectives in a Lisp dialect testifies to the continued vitality of the Lisp idea. Clojure is a new, substantive and unique dialect of Lisp, designed for, and implemented on, the Java virtual machine. It encourages functional programming with immutable persistent data structures, and provides built-in concurrency support via software transactional memory and asynchronous agents.
This session will go beyond introduction to delve into the details of Clojure. It will cover:
Extending code-as-data to other data types
Building a Lisp library on abstractions
Programming with immutable data and the implementation of persistent data structures
The problems of concurrency and state - the references to values model
Software transactional memory and multi-version concurrency control
Clojure's interoperability with Java and the Java virtual machine
The objective of the tutorial is to provide attendees with a sufficiently detailed exposure to the concepts, facilities and mechanisms of Clojure to begin using it effectively. Numerous details, code examples, demos, and opportunities for questions and discussion will be provided. Attendees should have some familiarity with Lisp, as the focus will be on what makes Clojure different and why. Feel free to bring a laptop with Clojure installed so you can play along. You can get support for installing Clojure from the Clojure Google group prior to the conference.
Rich Hickey, the author of Clojure, is an independent software designer, consultant and application architect with over 20 years of experience in all facets of software development. Rich has worked on scheduling systems, broadcast automation, audio analysis and fingerprinting, database design, yield management, exit poll systems, and machine listening, in a variety of languages.
Monads are a computational pattern for encapsulating and controlling effects. First employed in pure languages, monad design patterns have recently been implemented in impure functional languages. This tutorial introduces monads as implemented in the pure language Haskell before describing monad facilities for Scheme and Clojure.
The monad design pattern adds structure to a value so that effects associated with computing the value can be modeled. A wide variety of effects can be modeled this way, including things that are not normally thought of as effects, such as parser failure or accessing an environment of bindings.
For the programmer, monads are useful tools for structuring functional programs because they provide modularity, flexibility and isolation. Modularity is achieved because monads allow effectful computations to be composed from simpler effectful computations. Monadic programs can be more flexible than non-monadic programs because monads separate effectful processing and the plumbing required to implement effects -- allowing both plumbing and processing to be changed or replaced independently. Monads also make it easier to isolate effectful computations and to track and delimit the scope of effects within a program.
The tutorial is intended to teach experienced Lisp programmers how to work with monads. It will begin by presenting basic monadic concepts. Monads in Haskell will be used to illustrate these concepts and to introduce monad transformers. A simple Scheme monad package will be presented to show how a Lisp programmer can use macros to implement their own monadic syntax. The tutorial will conclude with an extended example of monadic programming -- building a modular interpreter using Clojure's monad library.
Ravi Nanavati and Jeff Newbern
Ravi Nanavati is the Lead Compiler Architect at Bluespec, Inc. in Waltham, Massachusetts. His ICFP Experience Report "Pure Shirt Fits - Reflections on Haskell at Bluespec" focuses on how a pure, monadic programming style has enabled Bluespec to quickly and correctly adapt and re-use complex, imperative computations in response to changing external requirements. Ravi has both an M. Eng and S.B. in Computer Science from MIT. At MIT, he worked with Scheme extensively, including as both a lab assistant and teaching assistant for 6.001. His M.Eng thesis =93Extensible Syntax in the Presence of Static Analysis=94 was about generating user-friendly error-messages when combining a Scheme-style macro system with a Hindley-Milner type system.
Jeff Newbern is a Haskell enthusiast and engineer at Bluespec, Inc. He received his M.Eng. and S.B. in Computer Science from MIT in 1996 and has since worked on several projects in the Electronic Design Automation industry. He is the author of "All About Monads", one of the most popular and extensive monad tutorials in the Haskell community.
Lisp programmers have traditionally scoffed at the idea of a gdb-like or VC++ - like debugging and stepping capability. Debugging is after all relatively easy in Lisp, because it is a symbolic language, and its implementations are naturally interactive. Also, it is hard to imagine a source debugger that will be useful in Common Lisp; in particular macro forms present problems as macros tend to be opaque and therefore not generally debuggable. But as Lisp compiler technology advances, and optimizations increasingly result in compiled code that is harder to understand, debugging aids are becoming more and more desirable. This tutorial will demonstrate a new source debugger/stepper in Allegro CL. This debugger is unique to existing Lisp debuggers in several ways, and in some cases probably unique to any other source-level debuggers: First, debug/stepping info can be loaded on demand, without recompiling the function under debug. Second, assembler instructions can be displayed and stepped. Third, macros are rendered transparent, allowing macro forms as well as all levels of their expansions to fully participate in the debug process. And fourth, language personalities can be defined and loaded, which customize the debugger behavior for domain specific languages implemented in CL. The tutorial will present concepts of source debugging, information about the language interface, and demos. The demos will include Lisp and assembler debugging sessions, a coverage analysis tool for Lisp functions, and a Python language personality which will allow Python code to be debugged in the style of a regular Python debugger. No experience in Allegro CL or CLPython is required, though an understanding of debugging issues in either is helpful.
Duane Rettig and Willem Broekema
Franz, Inc. / MobiHealth B.V
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.
Willem Broekema is an ICT developer at MobiHealth B.V. His background is in operations research and telematics. He started using Common Lisp in 2003, and has since developed a special interest in compilers for dynamic languages.
What is Lisp?
Lisp is a notation to reason and communicate with; computers execute that notation.
Lisp is interactive: You get immediate feedback to help develop your ideas efficiently.
Lisp is an extensible notation: You can develop a notation for your ideas.
The technical parts of Common Lisp are discussed from the perspective of types, constructors, and accessors, with many examples. Sequences are discussed, including operators, showing the generality of sequences and the usefulness of functions as first-class values. Hash tables, caching, and memoization are discussed.
Macros are treated at length, including backquote, when to use them and how to debug them, what style to use, etc.
There will also be some question-and-answer time at the end for interactive responses to specific audience interests. (In 2007, CLOS was a popular topic.)
Ernst van Waning
Association of Lisp Users
Ernst van Waning is a consultant and teacher of Lisp and statistical data mining. He holds a degree in data analysis from Leiden University in the Netherlands. He has contributed to many strategic research projects for the Dutch government and the European Union. He has taught large courses in Lisp at universities and has extensive experience with large practical Lisp applications in various industrial domains.
Currently, he combines his skills at QSM Europe, a company that specializes in sizing, estimating, planning, tracking and benchmarking software development projects.
© alu 2009