- 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.
- Dylan Reference Manual (Errata)
The official definition of the Dylan language and standard library.
- 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 [pdf] [epub] [old HTML]
Describes the libraries forming DUIM (Dylan User Interface Manager), the portable window programming toolkit. It complements Building Applications Using DUIM.
- Developing Component Software with CORBA
A tutorial and reference for CORBA interoperability using the Open Dylan ORB.
External Libraries and Tools¶
Note that many core libraries are bundled with Open Dylan and are documented in the Library Reference. This includes, System, IO, strings, logging, network, and many others.
- 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.
- dylan-tool [epub]
dylancommand to manage workspaces and package dependencies, and create the registry.
- HTTP [pdf] [epub]
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.
- Statistics [pdf] [epub]
A collection of libraries for performing statistical analysis.
- Testworks [pdf] [epub]
Unit testing framework.
- Tracing [pdf] [epub]
Tracing is an alternative to traditional logging and performance measurements.
- 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.
- Dylan Web in 60 Seconds
A quick introduction to web development in Dylan.
- Development inside emacs using DIME
An exciting look at using DIME and emacs for Dylan development. DIME is for Dylan what SLIME is for Common Lisp.
- Beyond Java?
A discussion of some of the advantages Dylan provides over Java, based on Jason Trenouth’s experience writing a CORBA IDL compiler in both Java and Dylan. (Written around 2001 and Java now has better handling of numeric boxing/unboxing.)
See the publications page for a full list. Below are a few highlighted publications.
- Extending Dylan’s type system for better type inference and error detection (by Hannes Mehnert at ILC 2010 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.
- 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.
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.
- Open Dylan Release Notes
Notes on new features and bug fixes in each release of Open Dylan.
This is old documentation that we don't plan to bring forward. Let us know if there's interest in this material.
- 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.