Commit 9b41feba authored by Dave Cooper's avatar Dave Cooper
Browse files

merged red-pen edits to make Draft #5

parent c002aea7
This diff is collapsed.
......@@ -26,14 +26,16 @@
"This chapter will lead you through all the basic steps of
operating a typical GDL-based development environment. We will not go
into particular depth about the additional features of the environment
or language syntax in this section --- this is merely for getting
familiar and practicing with the mechanics of operating the
environment with a keyboard."
or language syntax in this section --- this chapter is merely for
getting familiar with and practicing with the nuts and bolts of
operating the environment with a keyboard."
((:section :title "What is Different about GDL?")
"GDL is a dynamic language environment with incremental
compiling and in-memory definitions. That means that as long as the
system is running you can "
"GDL is a "
(:emph "dynamic")
" language environment with incremental compiling and in-memory
definitions. This means that as long as the system is running you
can "
(:emph "compile")
" new "
(:emph "definitions")
......@@ -63,7 +65,7 @@ done "
(:li "using commands placed into
the "
(:texttt "gdlinit.cl")
" initialization file, as introduced in Section "
" initialization file, as described in Section "
(:ref "sec:customizingyourenvironment") ".")
(:li "alternatively, you can compile and load definitions into
......@@ -71,25 +73,30 @@ your session, then save the ``world'' in that state. That way it is
possible to start a new GDL ``world'' which already has all your
application's definitions loaded and ready for use, without having to
procedurally reload any files. You can then begin to make and test new
definitions (and re-definitions) starting from this new ``world.''")))
definitions (and re-definitions) starting from this new ``world.''
You can think of a saved ``world'' like pre-made cookie dough: no need
to add each ingredient one by one --- just start making cookies!")))
((:section :title "Startup, ``Hello, World!'' and Shutdown")
(:p
"The typical GDL environment consists of three programs: Gnu
Emacs (the editor), a Common Lisp engine with GDL system loaded or built into it (e.g. the "
(:texttt "gdl.exe")
" executable in your "
(:texttt "program/")
" directory), and (optionally) a web browser
such as Firefox, Google Chrome, Safari, Opera, or Internet
Explorer. Emacs runs as the main "
"The typical GDL environment consists of three programs:"
(:ol
(:li "Gnu Emacs (the editor);")
(:li "a Common Lisp engine with GDL system loaded or built into it (e.g. the "
(:texttt "gdl.exe")
" executable in your "
(:texttt "program/")
" directory); and")
(:li "(optionally) a web browser such as Firefox, Google
Chrome, Safari, Opera, or Internet Explorer"))
"Emacs runs as the main "
(:emph "process")
", and this in turn starts the CL engine with GDL as a "
(:emph "sub-process")
". The CL engine typically runs an embedded "
(:emph "webserver")
", enabling you to access your application through a standard web browser.")
(:p "As introduced in Chapter "
(:p "As described in Chapter "
(:ref "chap:installation")
", the typical way to start a pre-packaged GDL environment is with the "
(:texttt "run-gdl.bat")
......@@ -285,14 +292,11 @@ the bootstrap module."
(:p "You should structure your applications in a modular fashion, with the
directories containing actual Lisp sources called \"source.\"")
(:p "You may have subdirectories which themselves contain \"source\"
directories.")
(:p "We recommend keeping your codebase directories relatively flat,
however.")
(:p "You should structure your applications in a modular
fashion, with the directories containing actual Lisp sources called
\"source.\" You may have subdirectories which themselves contain
\"source\" directories. We recommend keeping your codebase directories
relatively flat, however.")
(:p "In Figure "
(:ref "fig:yoyodyne-base")
......@@ -316,8 +320,8 @@ however.")
(:p "Within a source subdirectory, you may have a file called "
(:texttt "file-ordering.isc")
(:footnote (:texttt "isc") " stands for ``Intelligent Source Configuration''")
" to enforce a certain ordering on the files. Here is the contents of an example for the
above application:")
" to enforce a certain ordering on the files. Here are
the contents of an example for the above application:")
(:verbatim "(\"package\" \"parameters\")")
(:p "This will force package.lisp to be compiled/loaded first, and
......
......@@ -24,7 +24,7 @@
(defparameter *custom-user-interfaces*
`((:chapter :title "Custom User Interfaces in GDL")
(:p "Another of the strengths of GDL is the ability to create custom
(:p "Another strength of GDL is the ability to create custom
web-based user interfaces. GDL contains a built-in web server and
supports the creation of generative "
(:emph "web-based")
......@@ -58,20 +58,20 @@ refresh) as well as so-called ``Web 2.0'' interaction with AJAX.")
((:section :title "Package and Environment for Web Development")
(:p "Similarly to " (:texttt "gdl:define-package") ", you can use "
(:texttt "gwl:define-package") " in order to create a working package which has
access to the symbols you will need for building a web application (in
addition to all the other GDL symbols).")
(:texttt "gwl:define-package") " in order to create a working
package which has access to the symbols you will need for building a
web application (in addition to the other GDL symbols).")
(:p "The " (:texttt ":gwl-user") " package is pre-defined and may be used for practice
work. For real projects, you should define your own package using "
(:texttt "gwl:define-package") ".")
(:p "The acronym ``GWL'' stands for Generative Web Language,
which is not in fact a separate language from GDL itself, but rather
is a set of primitive objects and functions available with GDL for
building web applications. The YADD reference documentation for
package ``Generative Web Language'' provides detailed specifications
for all the primitive objects and functions."))
which is not a separate language from GDL itself, but rather is a set
of primitive objects and functions available within GDL for building
web applications. The YADD reference documentation for package
``Generative Web Language'' provides detailed specifications for all
the primitive objects and functions."))
((:section :title "Traditional Web Pages and Applications")
(:p "To make a GDL object presentable as a web page, the following two
......@@ -92,10 +92,11 @@ an HTML generating library, such as "
", both of which are built into GDL.")
(:p "For our examples we will use cl-who, which is currently the
standard default HTML generating library used internally by
GDL. Here we will make note of the major features of cl-who while
introducing the examples; for complete documentation on cl-who, please
visit the page at Edi Weitz' website linked above.")
standard default HTML generating library used internally by GDL. Here
we will make note of the major features of cl-who while introducing
the examples; for complete documentation on cl-who, please visit the
page at Edi Weitz' website linked above and listed in the footnote
below.")
......@@ -129,7 +130,8 @@ within a GWL application."
:label "fig:gwl-1-image")))
(:p "Several important concepts are packed into this example. Note the following:"
(:p "Several important concepts are lumped into this
example. Note the following:"
((:list :style :itemize)
......@@ -409,7 +411,7 @@ unchanged. This ability is not present in some other Ajax
frameworks.")
((:subsection :title "Steps to Create a gdlAjax Application")
(:p "Initially, it is important to understand that the
(:p "Initially, it is important to appreciate that the
fundamentals from the previous section on Standard Web Applications
still apply for gdlAjax applications --- that is, HTML generation,
page linking, etc. These techniques will all still work in a gdlAjax
......@@ -545,10 +547,9 @@ necessary.")
and :function-key simultaneously. As long as your logic
works correctly when the form-controls are set before the
function is called, then you can group the functions
together into a ``wrapper-function,'' and do the whole
together into a ``wrapper-function,'' and do the entire
processing with a single Ajax (or Sjax) call. Normally this
would be be the recommended approach whenever it it
possible."))
would be be the recommended approach whenever possible."))
((:subsection :title "Including Graphics")
......
......@@ -23,10 +23,10 @@
(defparameter *gendl-geometry*
`((:chapter :title "Working with Geometry in GDL")
(:p "Although GDL's uses include general-purpose computing, one of
its particular strong points is generating geometry and processing
geometric entities in various ways. Geometric capabilities are
provided by a library of "
(:p "Although Genworks GDL is a powerful framework for all kinds
of general-purpose computing, one of its particular strong points is
generating geometry and processing geometric entities. Geometric
capabilities are provided by a library of "
(:emph "low-level primitives")
", or LLPs. LLPs are pre-defined GDL objects which you can
extend by ``mixing in'' with your own definitions, and/or
......
......@@ -27,7 +27,7 @@
"Follow Section "
(:ref "sec:installationofpre-packagedgdl")
" if your email address is registered with Genworks and you will
install a pre-packaged Genworks GDL distribution including its own
install a pre-packaged Genworks GDL distribution, including its own
Common Lisp engine. The foundation of Genworks GDL is also available
as open-source software through The Gendl Project"
(:footnote "http://github.com/genworks/gendl")
......@@ -46,10 +46,7 @@ Gnu Emacs)."
(:item "Enter your email address"
(:footnote "if your address is not on file, send mail to licensing@genworks.com")
".")
(:item "Download the latest Payload for Windows, Linux, or Mac"
(:footnote "Gnu Emacs is included with the download. The source code for this
is available at http://downloads.genworks.com/emacs-windows-24.3.zip. Gnu Ghostscript
is also included; please contact Genworks if you need the source code for this."))
(:item "Download the latest Payload for Windows, Linux, or Mac")
(:item "Click to receive the license key file by email.")))
((:subsection :title "Unpack the Distribution")
......@@ -72,13 +69,13 @@ a ``dmg'' application bundle for Mac, and a self-contained zip file for Linux."
((:section :title "Installation of open-source Gendl")
"This section is only relevant if you have not received a
pre-packaged Gendl distribution with its own Common Lisp engine. If
you have received a pre-packaged Gendl distribution, then you may skip
this section. In case you want to use the open-source Gendl, you will
use your own Common Lisp installation and obtain Gendl (Genworks-GDL)
using a very powerful and convenient CL package/library manager
called "
"This section is only germane if you have not received a
pre-packaged Gendl or Genworks GDL distribution with its own Common
Lisp engine. If you have received a pre-packaged Gendl distribution,
then you may skip this section. In case you want to use the
open-source Gendl, you will use your own Common Lisp installation and
obtain Gendl (Genworks-GDL) using a very powerful and convenient CL
package/library manager called "
(:emph "Quicklisp") "."
((:subsection :title "Install and Configure your Common Lisp environment")
......@@ -162,9 +159,9 @@ in a shaded dynamic view.")))
"The following commands will invoke a full regression test,
including a test of the Surface and Solids primitives provided by the
SMLib geometry kernel. Note that the SMLib geometry kernel is only
available with proprietary Genworks GDL licenses --- therefore if you
have open-source Gendl or a lite Trial version of Genworks GDL,
these regression tests will not all function.
available with proprietary Genworks GDL licenses --- therefore, if you
have open-source Gendl or a lite Trial version of Genworks GDL, these
regression tests will not all function.
In Emacs at the "
(:texttt "gdl-user>")
......
......@@ -34,8 +34,8 @@ as an end-user application interface (see Chapter "
(:ref "chap:customuserinterfacesingdl")
" for the recommended steps to create end-user interfaces).")
(:p "Tasty allows you to visualize and inspect any object defined
in GDL, which mixes at least "
(:p "Tasty allows one to visualize and inspect any object defined
in GDL which mixes at least "
(:texttt "base-object")
" into the definition of its root"
(:footnote "base-object is the core mixin for all geometric
......@@ -51,7 +51,7 @@ the Chapter 5 examples, contained in "
(:verbatim ".../src/documentation/tutorial/examples/chapter-5/")
" in your GDL distribution. If you are not sure how to do this,
temporarily leave this section and review Chapter "
you may want to leave this section temporarily and review Chapter "
(:ref "chap:basicoperationofthegdlenvironment")
", and then return.")
......@@ -101,20 +101,18 @@ practice, because it means that the code in quesion is accessing the
``internals'' or ``guts'' of another package, which may not have been
the intent of that other package's designer."))
(:p "After you specify the class package and the object type and press the
``browse'' button, the browser will produce the utility interface
with an instance of the specified type (see figure "
(:ref "fig:tastyshockabsorberpre") ".")
(:p "After you specify the class package and the object type and
press the ``browse'' button, the browser will produce the tasty
interface with an instance of the specified type (see figure "
(:ref "fig:tastytowerpre") "). The utility interface
by default is composed of three toolbars and three view frames (tree
frame, inspector frame and viewport frame ``graphical view port'').")
(:p "The utility interface by default is composed of three toolbars and
three view frames (tree frame, inspector frame and viewport frame
``graphical view port'').")
((:image-figure :image-file "tasty-shock-absorber-pre.pdf"
((:image-figure :image-file "tasty-tower-pre.pdf"
:width "5in" :height "5in"
:caption "Tasty Interface"
:label "fig:tastyshockabsorberpre"))
:label "fig:tastytowerpre"))
((:subsection :title "The Toolbars")
......@@ -271,16 +269,16 @@ object. For example for the tower assembly this will be as depicted in
figure "
(:ref "fig:tree-twisty-tower"))
(:p "To draw the graphics (geometry) for the shock-absorber
leaf-level objects, you can select the ``Add Leaves (AL)'' item from
the Tree menu, then click the desired leaf to be displayed from the
(:p "To draw the graphics (geometry) for the tower leaf-level
objects, you can select the ``Add Leaves (AL)'' item from the Tree
menu, then click the desired leaf to be displayed from the
tree. Alternatively, you can select the ``rapid'' button from third
toolbar which is symbolized by a pencil icon. Because this
operation (draw leaves) is frequently used, the operation is directly
available as a tooltip which will pop up when you hover the mouse over
any leaf or node in the tree.")
operation (draw leaves) is frequently used, the operation is also
directly available as a direct-click icon which will appear when you
hover the mouse over any leaf or node in the tree.")
(:p "The ``on the fly'' feature is available also for ``inspect
(:p "A direct-click icon is also available for ``inspect
object,'' as the second icon when you hover the mouse over a leaf or
node.")
......@@ -299,11 +297,9 @@ syntax). We will also pass the number-of-blocks as the :size of the "
" sequence, rather than using a hard-coded value as
previously. The new assembly definition is now:"
;;
(:verbatim ";;
;; FLAG -- insert verbatim or ref to new tower code
;;
)
;; "))
(:p "In this new version of the tower, the number-of-blocks is a
settable slot, and its value can be modified (i.e. ``bashed'') as
......@@ -318,7 +314,7 @@ menu, then select the root of the "
(:ref "fig:tasty-inspector")
"). Once the inspector is displaying this object, it is
possible to expand its settable slots by clicking on the ``Show
Settables!'' link. (use the ``X'' link to collapse the settable slots
Settables!'' link (use the ``X'' link to collapse the settable slots
view). When the settable slots area is open, the user may set the
values as desired by inputting the new value and pressing the OK
button (see Figure "
......
......@@ -23,17 +23,19 @@
(defparameter *understanding-common-lisp*
`((:chapter :title "Understanding Common Lisp")
(:p "GDL is a superset of Common Lisp, and is ``embedded'' in
Common Lisp. This means that when working with GDL you have the full
power of CL available to you. The lowest-level expressions in a GDL
definition are CL ``symbolic expressions,'' or ``s-expressions.''
This chapter will familiarize you with CL s-expressions.")
(:p "GDL is a superset of Common Lisp (CL) --- that is, all of
CL is available to you during development, and is available to your
applications at runtime (i.e. after they are deployed). The
lowest-level expressions in a GDL definition are CL ``symbolic
expressions,'' or ``s-expressions.'' This chapter will familiarize
you with CL s-expressions.")
((:section :title "S-expression Fundamentals")
(:p "S-expressions can be used in your definitions to establish
the value of a particular "
(:p "S-expressions can be used in a similar manner to Formulas
in a Spreadsheet to establish the value of a particular "
(:emph "slot")
" (i.e. named data value) in an object, which will be
computed on-demand. You can also evaluate S-expressions at the
" (i.e. named data value) in an object. Unlike in a
spreadsheet, however, these values are only computed on an as-needed
basis (i.e. ``on-demand''). You can also evaluate S-expressions at the
toplevel "
(:texttt "gdl-user\\textgreater")
" prompt, and see the result immediately. In fact, this toplevel prompt is called a "
......@@ -66,11 +68,12 @@ toplevel "
(:texttt "2")
" and another "
(:texttt "2")
". As you may have guessed, when this expression is evaluated it will return the value 4."
". As you may have suspected, when this expression is
evaluated it will return the value 4."
(:emph "Try it: ")
"try typing this expression at your command prompt, and see
the return-value being printed on the console. What is actually
happening here? When CL is asked to evaluate an expression, it
occurring here? When CL is asked to evaluate an expression, it
processes the expression according to the following rules:")
(:p ((:list :style :itemize)
(:item "If the expression is an "
......@@ -132,10 +135,16 @@ special power. Here are some examples of functional s-expressions: "
((:section :title "Fundamental CL Data Types")
(:p "As we have seen, Common Lisp natively supports
many data types common to other languages, such as numbers and text
strings. CL also contains several compound data types such as lists,
arrays, and hash tables. CL contains "
(:p "As has been noted, Common Lisp natively supports many data
types"
(:footnote "See http://en.wikipedia.org/wiki/Data_type for
a more detailed discussion of what is meant by ``data types'' in this
context.")
" common to other languages, such as numbers and text strings. CL
also contains several "
(:emph "compound")
" data types such as lists, arrays, and hash tables. CL
contains "
(:emph "symbols")
" as well, which typically are used as names for other data elements.")
......@@ -145,9 +154,9 @@ not necessarily have type, and typically variables are not
``pre-declared'' to be of a particular type.")
((:subsection :title "Numbers")
(:p "As we have seen, numbers in CL are a native
data type which simply evaluate to themselves when entered at the
toplevel or included in an expression.")
(:p "As observed, numbers in CL are a native data type which
simply evaluate to themselves when entered at the toplevel or included
in an expression.")
(:p "Numbers in CL form a hierarchy of types, which includes Integers,
Ratios, Floating Point, and Complex numbers. For many purposes, you
only need to think of a value as a ``number'' without getting any more
......@@ -159,11 +168,11 @@ specific than that. Most arithmetic operations, such as "
(:texttt "*")
", "
(:texttt "/")
" etc, will automaticaly do any necessary type coercion on their
" etc, will automaticaly do any necessary type-coercion on their
arguments and will return a number of the appropriate type.
CL supports a full range of floating-point decimal numbers, as well as
true Ratios, which means that "
true Ratios, which means that for example "
(:texttt "1/3")
" is a true one-third, not "
(:texttt "0.333333333")
......@@ -175,7 +184,7 @@ characters. These characters can be letters, numbers, or punctuation,
and in some cases can include characters from international character
sets (e.g. Unicode or UTF-8) such as Chinese Hanzi or Japanese
Kanji. The string delimiter in CL is the double-quote character.")
(:p "As we have seen, strings in CL are a native data type which simply
(:p "Text strings in CL are a native data type which simply
evaluate to themselves when included in an expression.")
......@@ -197,7 +206,7 @@ evaluate to themselves when included in an expression.")
gdl-user> (format nil \"The time is: ~a\" (iso-8601-date (get-universal-time) :include-time? t))
\"The time is: 2012-12-10T14:30:17\"")))
(:p "As you can see from the above example, "
(:p "As the above example shows, "
(:texttt "format")
" takes a "
(:emph "stream designator")
......@@ -254,13 +263,13 @@ plist slots is one fundamental distinction between Common Lisp and most
other Lisp dialects. Most other dialects allow only one (1) ``thing''
to be stored in the symbol data structure, other than its name
(e.g. either a function or a value, but not both at the same
time). Because Common Lisp does not impose this restriction, it is not
time). Because Common Lisp does not impose this restriction it is not
necessary to contrive names, for example for your variables, to avoid
conflicting with existing ``reserved words'' in the system. For
example, "
(:texttt "list")
" is the name of a built-in function in CL. But you
may freely use "
" is the name of a built-in function in CL, but you may
freely use "
(:texttt "list")
" as a variable name as well. There is no need to
contrive arbitrary abbreviations such as "
......@@ -274,8 +283,8 @@ expression. As we have seen, if a "
(:texttt "+")
" in "
(:texttt "(+ 2 2)")
", the symbol is evaluated for its function slot. If the first
element of an expression indeed has a "
", the symbol is evaluated for its function slot. If the
first element of an expression indeed has an identified "
(:emph "function")
" in its function slot, then any
subsequent symbol in the expression is taken as a variable, and it is evaluated
......@@ -293,9 +302,10 @@ way to achieve this is to ``quote'' the symbol name:"
") applies across everything in the list expression, including any sub- expressions."))
((:subsection :title "List Basics")
(:p "Lisp takes its name from its strong support for the list data
structure. The list concept is important to CL for more than this
reason alone --- most notably, lists are important because "
(:p "Lisp takes its name from its strong support for the list
data structure. The list concept is important to Common Lisp (CL) for
more than this reason alone --- most notably, lists are important
because "
(:emph "all CL programs are themselves lists."))
(:p " Having the list as a native data structure, as well as the form of all
programs, means that it is straightforward for CL programs to compute
......@@ -303,12 +313,16 @@ and generate other CL programs. Likewise, CL programs can read and
manipulate other CL programs in a natural manner. This cannot be said
of most other languages, and is one of the primary distinguishing
characteristics of Lisp as a language.")
(:p "Textually, a list is defined as zero or more items
surrounded by parentheses. The items can be objects of any valid CL
data types, such as numbers, strings, symbols, lists, or other kinds
of objects. According to standard evaluation rules, you must quote a
(:p "Textually, a "
(:emph "list")
" is defined as zero or more items surrounded by
parentheses. The items can be objects of any valid CL data types, such
as numbers, strings, symbols, lists, or other kinds of
objects. According to standard evaluation rules, you must quote a
literal list to evaluate it as such, or CL will assume you are calling
a function. Now look at the following list:"
a "
(:emph "function")
". Now look at the following list:"
(:verbatim "(defun hello () (write-string \"Hello, World!\"))")
"This list also happens to be a valid CL program (function definition,
in this case). Don't concern yourself about analyzing the function definition
......@@ -338,8 +352,9 @@ call "
((:subsection :title "The List as a Data Structure")
"In this section we will present a few of the fundamental native CL operators for manipulating
lists as data structures. These include operators for doing things such as:"
"In this section we will cover a few of the fundamental native
CL operators for manipulating lists as data structures. These include
operators for doing things such as:"
((:list :style :enumerate)
(:item "finding the length of a list")
(:item "accessing particular members of a list")
......@@ -469,7 +484,13 @@ arguments in any way:"
(:texttt "my-slides")
". Later we will see how one may alter the value of a variable such as "
(:texttt "my-slides")
"."))))
"."))
"In this chapter we have presented enough basics of Lisp's
minimal syntax, and some particulars of Common Lisp, to enable you to
start with the Genworks GDL framework. In keeping with the
demand-driven philosophy of GDL, subsequent chapters will cover additional
CL material on an as-needed basis."))
......@@ -23,28 +23,28 @@
(defparameter *understanding-gendl*
`((:chapter :title "Understanding GDL --- Core GDL Syntax")
(:p "Now that you have a basic grasp of Common Lisp syntax (or, more accurately, "
(:p "Now that you have a basic familiarity with Common Lisp
syntax (or, more accurately, the "
(:emph "absence")
" of syntax), we will move directly into the GDL
" of syntax), we will move directly into the Genworks GDL
framework. By using GDL you can formulate most of your engineering and
computing problems in a natural way, without becoming involved in the
complexity of the Common Lisp Object System (CLOS).")
(:p "The GDL product is a commercially available KBE system with
Proprietary licensing. The Gendl Project is an open-source Common
Lisp library which contains the core language kernel of GDL, and is
licensed under the terms of the Affero Gnu Public License. The core
GDL language is a proposed standard for a vendor-neutral KBE
language.")
(:p "As discussed in the previous chapter, GDL is based on and
is a superset of ANSI Common Lisp. Because ANSI CL is unencumbered and
is an open standard, with several commercial and free implementations, it
is a good wager that applications written in it will continue to be
usable for the balance of this century, and beyond. Many commercial
is an open standard, with several commercial and free implementations,
it is a good wager that applications written in it will continue to be
usable for the balance of this century, and beyond. Many commercial
products have a shelf life only until a new product comes along. Being
based in ANSI Common Lisp ensures GDL's permanence.")
(:p "[The GDL product is a commercially available KBE system
with Proprietary licensing. The Gendl Project is an open-source
Common Lisp library which contains the core language kernel of GDL,
and is licensed under the terms of the Affero Gnu Public License. The
core GDL language is a proposed standard for a vendor-neutral KBE
language.]")
((:section :title "Defining a Working Package")
......@@ -54,16 +54,17 @@ based in ANSI Common Lisp ensures GDL's permanence.")
" are a mechanism to separate symbols into
namespaces. Using packages it is possible to avoid naming conflicts in
large projects. Consider this analogy: in the United States, telephone
numbers consist of a three-digit area code and a seven-digit
number. The same seven-digit number can occur in two or more separate
area codes, without causing a conflict.")
numbers are preceded by a three-digit area code and then consist of a
seven-digit number. The same seven-digit number can occur in two or
more separate area codes, without causing a conflict.")
(:p "The macro "
(:texttt "gdl:define-package")
"is used to set up a new working package in GDL.")