Documentation

Warning

We are in the process of converting over to a new documentation publishing system. Some documents are not entirely correct yet. We’ve retained links to the ‘Old HTML’ where relevant. These will be going away in the near future.

Cheat Sheets

Quick one-page sheets for common tasks.

Learning Dylan

Just getting started with Open Dylan? We recommend that you read the Introduction to Dylan to get a feel for the language. After that, you can broaden your knowledge with the Dylan Programming book.

An Introduction to Dylan [pdf] [epub]
This tutorial is written primarily for those with solid programming experience in C++ or another object-oriented, static language. It provides a gentler introduction to Dylan than does the Dylan Reference Manual (DRM).
Dylan Programming [pdf] [epub]
A good, book length Dylan tutorial by several Harlequin employees.
Getting Started with the Open Dylan Command Line Tools [pdf] [epub]
Describes development using the Open Dylan command line tools and editor integration (like emacs). This is mainly useful for people using Open Dylan on Linux, FreeBSD and Mac OS X.
Getting Started with the Open Dylan IDE [pdf] [epub] [old HTML]
Describes Open Dylan’s integrated development environment which is available for Windows.
Building Applications Using DUIM [pdf] [epub] [old HTML]
Describes how to use DUIM (Dylan User Interface Manager), the portable window programming toolkit. This is only useful if you are using Open Dylan on Windows.

References

These are some lengthier reference materials. While they make for dry reading, they're full of invaluable information!

Dylan Reference Manual (Errata)
The official definition of the Dylan language and standard library.
Dylan Library Reference [pdf] [epub]
Describes the Open Dylan implementation of the Dylan language, a core set of Dylan libraries, and a library interchange mechanism. The core libraries provide many language extensions, a threads interface, and object finalization, printing and output formatting modules, a streams module, a sockets module, and modules providing an interface to operating system features such as the file system, time and date information, the host machine environment, as well as a foreign function interface and some low-level access to the Microsoft Win32 API.
DUIM library reference
Describes the libraries forming DUIM (Dylan User Interface Manager), the portable window programming toolkit. It complements Building Applications Using DUIM.

External Libraries and Tools

Binary-Data [pdf] [epub]
The binary-data library provides an extension to the Dylan language for parsing and assembling binary data using high level Dylan objects.
Concurrency [pdf] [epub]
The concurrency utility library.
HTTP [pdf] [epub]
Dylan provides libraries for writing HTTP clients and servers.
Melange [pdf] [epub]
Generates Dylan code to wrap C libraries.
Objective C Bridge [pdf] [epub]
Provides a bridge between Objective C and Dylan, allowing integration with Objective C libraries.
Testworks [pdf] [epub]
Testworks is Dylan’s unit testing framework.
Tracing [pdf] [epub]
Tracing is an alternative to traditional logging and performance measurements.

Articles

Featured articles and blog postings.

Learning Dylan

Dylan Macro System by Dustin Voss.
This article holds hard-won knowledge about how the Dylan macro system works and how to work around some of the gotchas that may catch a macro writer.
Procedural Dylan by Paul Haahr.
This essay explores Dylan from the perspective of a programmer used to traditional procedural languages, such as Pascal or C.

Tools

Development inside emacs using DIME
An exciting look at using DIME and emacs for Dylan development.

Publications

Extending Dylan’s type system for better type inference and error detection [pdf] [bib]

Whereas dynamic typing enables rapid prototyping and easy experimentation, static typing provides early error detection and better compile time optimization. Gradual typing provides the best of both worlds. This paper shows how to define and implement gradual typing in Dylan, traditionally a dynamically typed language. Dylan poses several special challenges for gradual typing, such as multiple return values, variable-arity methods and generic functions (multiple dispatch).

In this paper Dylan is extended with function types and parametric polymorphism. We implemented the type system and a unification-based type inference algorithm in the mainstream Dylan compiler. As case study we use the Dylan standard library (roughly 32000 lines of code), which witnesses that the implementation generates faster code with fewer errors. Some previously undiscovered errors in the Dylan library were revealed.

https://dl.acm.org/citation.cfm?id=1869643.1869645

Partial Dispatch: Optimizing Dynamically-Dispatched Multimethod Calls with Compile-Time Types and Runtime Feedback [pdf] [bib]
We presented an approach to gaining back complete class hierarchy information by delaying the construction of dispatch caches until the whole class hierarchy is available at run- time. Run-time call-site caches can then be constructed as specialized decision trees built from disjointness and concrete- subtype operations on actual arguments combined with compile-time inferred types injected into the run-time. Unnecessary decision steps can be avoided and often run-time dispatch can be completely eliminated. We consider this to be a nice half-way house between full static compilation and dynamic compilation which mitigates the runtime expense of separately compiled components while satisfying our implementation constraints of code shareable components, multi-threaded runtime, incremental development, “pay as you go philosophy”, and interoperability with standard tools.
D-Expressions: Lisp Power, Dylan Style [pdf] [bib]
This paper aims to demonstrate that it is possible for a language with a rich, conventional syntax to provide Lisp-style macro power and simplicity. We describe a macro system and syntax manipulation toolkit designed for the Dylan programming language that meets, and in some areas exceeds, this standard. The debt to Lisp is great, however, since although Dylan has a conventional algebraic syntax, the approach taken to describe and represent that syntax is distinctly Lisp-like in philosophy.

See our publications page to find more.

For Open Dylan Developers

Notes and materials useful to those working on Open Dylan itself or those who have an interest in the low level details.

Open Dylan Hacker’s Guide [pdf] [epub]
A work in progress to help out people who are hacking on Open Dylan itself.
Dylan Style Guide [pdf] [epub]
Notes and thoughts on how to format your Dylan code. This is the style guide that we aspire to adhere to in the Open Dylan sources.
Dylan Enhancement Proposals
A series of proposals for improvements to the Open Dylan implementation and related libraries.

Archived Documentation

This is old documentation that we don't plan to bring forward. Let us know if there's interest in this material.

Developing Component Software with CORBA
A tutorial and reference for CORBA interoperability using the Open Dylan ORB.
OLE, COM, ActiveX and DBMS library reference
Describes high and low level interfaces to COM, OLE, and ActiveX component technology, and generic DBMS support, through SQL with an ODBC backend.