*************
Documentation
*************
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.
Cheat Sheets
============
.. hlist::
* `Basics of Dylan Syntax `_
* `Iteration `_
* `Conditionals `_
* `Collections `_
* `For Scheme programmers `_
References
==========
`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.
Advanced Guides
===============
`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.
`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.
`Statistics `_ [`pdf `__] [`epub `__]
A collection of libraries for performing statistical analysis.
`Testworks `_ [`pdf `__] [`epub `__]
Testworks is Dylan's unit testing framework.
`Tracing `_ [`pdf `__] [`epub `__]
Tracing is an alternative to traditional logging and performance measurements.
Articles
========
`Dylan Macro System <../articles/macro-system/index.html>`_ 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 <../articles/procedural-dylan/index.html>`_ 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 <../news/2011/12/12/dswank.html>`_
An exciting look at using DIME and emacs for Dylan development.
DIME is for Dylan what `SLIME `_
is for Common Lisp.
`Beyond Java? <../articles/beyond-java.html>`_
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.)
Publications
============
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 <../_static/documentation/mehnert2010.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/doi/10.1145/1869643.1869645
**Partial Dispatch: Optimizing Dynamically-Dispatched Multimethod Calls with Compile-Time Types and Runtime Feedback** [`pdf `__] [`bib <../_static/documentation/bachrach2000.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 <../_static/documentation/bachrach1999.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
=========================
.. raw:: html
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 <../proposals/index.html>`_
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.
Archived Documentation
======================
.. raw:: html
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.
.. raw:: html