Morning (two parallel sessions):
Afternoon (two parallel sessions):
This tutorial will describe the MPS ("Memory Pool System") and should be attractive to anyone interested in memory management and garbage collection, or in Lisp implementation in general. We will talk about the integration of the MPS with DylanWorks, Configura Magic, and our own Scheme implementation. We will also talk about our experience of integrating the MPS with CMUCL.
Prerequisites for attending: knowledge of, or interest in, memory management, garbage collection, or programming language run-time systems.
See also the project home page at: http://www.ravenbrook.com/project/mps/
About the Memory Pool System
The MPS is a very general, adaptable, flexible, reliable, and efficient memory management system. About 30 person-years of effort was invested in it between 1994 and 2001 at Harlequin, where it was targeted at Harlequin's ScriptWorks (PostScript) and DylanWorks systems. The system contains many innovative techniques and abstractions which were kept secret.
The MPS is now owned by Ravenbrook, and is open source, as well as being used commercially in ScriptWorks, and in Configura's "Magic" system. We'd like to see it more widely used, or even just see the techniques reused.
Richard Brooksby is a senior consultant at Ravenbrook, a software engineering consultancy company with ethical goals. At Harlequin he was the architect of the MPS and the manager of the team that created it -- a team that achieved a bug rate as low as one defect in six months. In 1997 Richard co-founded Ravenbrook, and has carried out numerous product strategy, project management, software process, configuration management, and (of course) programming projects for various clients including Symbian (mobile phone operating systems), Lastminute.com (online travel, entertainment, gifts), Perforce Software (configuration management tools), Configura (configuration, CAD, business tools), Zoonami (games), and many smaller companies struggling with growth problems. He recently spent a year on the EU's Executive Training Programme in Japan studying the Japanese language and business culture. His goal is to be a skilled generalist.
This tutorial is aimed at hackers who haven't built Lisp web applications yet. We're going to start from scratch and implement a simple, interactive demo website using authorization, sessions, and other features you'll probably expect nowadays - maybe even some Ajax goodies if time permits.
Biography: Edi Weitz studied mathematics and has a Ph.D. in logic and set theory from the University of Hannover, Germany. Since 1998 he has worked as an independent programmer/consultant for customers in several European countries and in the United States.
ContextL is one of our first programming language extensions that explicitly support Context-oriented Programming. In Context-oriented Programming, 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.
The following examples are to motivate the need to provide code depending on its deployment and execution context.
With contemporary mainstream programming languages, the only way to introduce context-dependent behavior into a program is either by inserting if statements wherever necessary to check for the context in which a program is running, violating one of the fundamental principles of object-oriented programming, namely to avoid explicit conditionals for achieving polymorphic behavior, or else by factoring out the context-dependent behavior into separate objects that can be substituted according to specific contexts of use. Both approaches lead to unnecessarily complicated code that is hard to comprehend and even harder to maintain.
With Context-oriented Programming on the other hand, we can modularize context-dependent parts of a software system using partial class and method definitions which are organized within layers. Layers are composed into or out of the system depending on the context apparent during program execution. The basic concept of layers as partial program definitions has been suggested before, but with our approach we extend this idea by the notion of dynamically scoped layer activation, resulting in a viable approach for expressing context-dependent behavior.
In our tutorial about ContextL we will show and discuss the following.
ContextL is used as a research platform, but has already been used in industrial settings as well. Activities concerning ContextL are carried out in an open-source project which is available at http://common-lisp/project/closer.
Dr. Pascal Costanza, Dr. Robert Hirschfeld
Pascal Costanza has a Ph.D. degree from the University of Bonn, Germany, and works as a research assistant at the Programming Technology Lab of the Vrije Universiteit Brussel, Belgium. His past involvements include specification and implementation of the languages Gilgul and Lava, and the design and application of the JMangler framework for load-time transformation of Java class files. He has also implemented ContextL, the first programming language extension for Context-oriented Programming based on CLOS, and aspect- oriented extensions for CLOS. 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. He has also co-organized numerous workshops on Unanticipated Software Evolution, Aspect-Oriented Programming, Object Technology for Ambient Intelligence, Lisp, and redefinition of computing.
Robert Hirschfeld is a Professor of Computer Science at the Hasso- Plattner-Institute Potsdam, Germany. There he leads the Software Architecture Group which is concerned with fundamental elements and structures of software. Methods and tools are developed for improving the comprehension and design of large complex systems. Prof. Hirschfeld was a senior researcher with DoCoMo Euro-Labs, the European research facility of NTT DoCoMo Japan where he worked on infrastructure components for next generation mobile communication systems with a focus on dynamic service adaptation, dynamic AOP, and context-oriented programming. Prior to joining DoCoMo Euro-Labs, he was a principal engineer at Windward Solutions in Sunnyvale, California. Robert Hirschfeld received a Ph.D. in Computer Science from the Technical University of Ilmenau, Germany.
The optimization and debug of Common Lisp programs go hand-in-hand; from the first time the programmer turns the speed optimization quality up or the safety optimization quality down, or from the first declaration that is added, the questions that must be asked are "Is this doing any good?", and "Is this doing any bad?". These questions are sometimes answered similarly for all Common Lisps, but sometimes also differently, depending on the implementation. Often the CL implementation provides extensions and allows for more heavy optimization, or more detailed debug, based on those extensions.
This tutorial will explore optimization and debug techniques both for Common Lisp in general and also those specific to Allegro CL. On the optimization side, we will explore reduction of consing, speed of compiled code, reading from and writing to streams efficiently, the use of foreign types to overlay external structures, and other topics. In the area of debugging, we will deal with the questions "Why did this optimization do nothing?" and "Why did this optimization cause my program to fail?". This will include the use of low-level debuggers, especially with newly available Lisp-knowledge provided to generic C debuggers like gdb, dbx, and windbg, and perhaps a glimpse of what is to come in our 8.1 version. It will also involve practical examples of usage of the Runtime Analyzer to identify time and space hot-spots.
Attendees should know Common Lisp, and are encouraged to have at least tried Allegro CL, perhaps from experience on the free Express Edition. Experience with system debuggers such as gdb, dbx, and/or windbg would also be helpful, but is not necessary. Understanding of individual architectures and instruction sets is not necessary.
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.
The goal of this tutorial is to provide an introduction to Common Lisp for absolute beginners. We really will start at the beginning (although we will assume that you have some other programming experience); if you already know Lisp then this isn't the place for you.
We'll work intensively, as our aim will be to cover enough ground to deliver a good feel for what Lisp is about, how much it's influenced other languages over the years, and why it's still such a cool language to program in. We can't cover everything in seven or eight hours, but by the end you should have the confidence to make sense of mainstream reference material, understand other people's code, and start writing your own.
Part of the session will be a hands-on practical, so you will have to bring a computer with you. (If this is absolutely impossible, let us know and we'll see what we can do to arrange a machine for you, but we may have to negotiate a charge to cover any costs.)
It is expected that you will have installed Common Lisp on your machine before you arrive. You'll find a list of implementations on the ALU Wiki. Several implementations come with a "free personal" edition; these will undoubtedly all be eminently suitable for our purposes.
We hope to have tutors on hand during the practical sessions with experience of both Allegro (available on Windows, Linux, FreeBSD and Mac OS X) and LispWorks (Windows, Linux and Mac OS X). A Lisp which comes with graphical development tools is to be preferred. Feel free to contact us if you're in any doubt. In any case, if you want to use an implementation other than one of those listed above, please discuss it with us in advance so that we can arrange for a tutor with relevant experience to be present.
You are asked to register in advance your intention to attend this tutorial, so that we can plan for numbers. Send mail to:
Ernst van Waning
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 2007