Commit 12290a1d authored by Dave Cooper's avatar Dave Cooper
Browse files

merged latest red-pen edits

parent 00469f1e
(:gwl-graphics)
"(:gwl-graphics #-allegro :cl-html-parse)"
......@@ -107,7 +107,7 @@ This list defaults to standard internal and test packages"
(title "GDL Reference Documentation")
(dom-chapter `((:chapter :title "GDL Reference")
(dom-chapter `((:chapter :title "Reference for GDL Objects and Operators")
,@(mapcar #'(lambda(package)
`((:section :title ,(the-object package strings-for-display-verbose))
(:p ,@(remove nil (the-object package dom-section)))))
......
......@@ -21,6 +21,9 @@
(in-package :common-lisp-user)
#+allegro
(eval-when (:compile-toplevel :load-toplevel :execute)
(require :phtml))
(gwl:define-package :yadd
(:documentation #.(glisp:system-description :yadd))
......
......@@ -4,7 +4,7 @@
"The Gendl™ Yet Another Definition Documenter (yadd)" :author
"John McCarthy" :license
"Affero Gnu Public License (http://www.gnu.org/licenses/)" :serial t
:version "20130501" :depends-on (:gwl-graphics)
:version "20130501" :depends-on (:gwl-graphics #-allegro :cl-html-parse)
#+asdf-encoding :encoding #+asdf-encoding :utf-8
:components
((:file "source/package") (:file "source/genworks")
......
This diff is collapsed.
......@@ -22,6 +22,6 @@
(in-package :gendl-doc)
(defparameter *advanced-common-lisp*
`((:chapter :title "More Common Lisp for Gendl")
`((:chapter :title "More Common Lisp for GDL")
))
......@@ -36,6 +36,7 @@
:usepackage ("makeidx")
:usepackage ("textcomp")
:usepackage ("colorlinks=true, urlcolor=cyan" "hyperref")
:usepackage ("nottoc, numbib" "tocbibind")
:newsavebox ("\\boxedverb")
:makeindex nil)
:frontmatter
......@@ -59,6 +60,7 @@ written consent from Genworks International.")
,*upgrade-notes*
,(the-object (make-self 'yadd::assy) dom-chapter)
:backmatter
,*bibliography*
:printindex
))
......
......@@ -26,9 +26,9 @@
"This chapter will lead you through all the basic steps of
operating a typical GDL-based development environment. We will not go
into any depth about the additional features of the environment or
language syntax in this section --- this is just for getting familiar
and practicing with the mechanics of operating the environment with a
keyboard."
language syntax in this section --- this is merely for getting
familiar and practicing with the mechanics of operating the
environment with a keyboard."
((:section :title "What is Different about GDL?")
"GDL is a dynamic language environment with incremental
......@@ -43,23 +43,33 @@ them immediately or update an existing set of objects to observe their
new behavior.
In many other programming language systems, to introduce a new
function or object, one has to start the system from the beginning and
reload all the files in order to test new functionality.
function or object, one has "
(:emph "to start the system from the beginning")
" and reload all the files in order to test new functionality.
In GDL, if you shut down the system after having compiled and loaded a
set of files with new definitions, then when you restart the system
you will have to recompile and/or reload those definitions in order to
bring the system back into the same state. This is typically done
automatically, using commands placed into the "
(:texttt "gdlinit.cl")
" initialization file, as introduced in Section "
(:ref "sec:customizingyourenvironment")
". Alternatively, you can compile and load definitions into
In GDL, it is typical to keep the same development session up and
running for an entire day or longer, making it unnecessary to
constantly recompile and reload your definitions from scratch. Note,
however, that if you do shut down and restart the system for some
reason, then you will have to recompile and/or reload your
application's definitions in order to bring the system back into a
state where it can instantiate (or ``run'') your application.
While this can be done manually at the command-line, it is typically
done automatically in one of two ways:"
(:ol
(:li "using commands placed into
the "
(:texttt "gdlinit.cl")
" initialization file, as introduced in Section "
(:ref "sec:customizingyourenvironment") ".")
(:li "alternatively, you can compile and load definitions into
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.''")))
((:section :title "Startup, ``Hello, World!'' and Shutdown")
(:p
......@@ -86,18 +96,20 @@ Explorer. Emacs runs as the main "
" (MacOS, Linux) script files, or with the installed Start
program item (Windows) or application bundle (MacOS). Invoke this
script file from the Start menu (Windows), your computer's file
manager, or from a desktop shortcut if you have created one as
outlined in section "
(:ref "subsec:makeadesktopshortcut")
". Your installation executable may also have created a
Windows ``Start'' menu item for Genworks GDL. Of course you can also
invoke "
manager, or from a desktop shortcut if you have created one. Your
installation executable may also have created a Windows ``Start'' menu
item for Genworks GDL. You can of course also invoke "
(:texttt "run-gdl.bat")
" from the Windows ``cmd'' command-line, or from another command shell such as Cygwin."
(:footnote "Cygwin is also useful as a command-line tool on Windows
for interacting with a version control system like Subversion (svn)."))
((:image-figure :caption "Startup of Emacs with GDL"
:image-file "emacs-startup.png"
:width "6in" :height "4in"
:label "fig:emacs-startup"))
((:subsection :title "Startup")
" Startup of a typical GDL development session consists of
two fundamental steps: (1) starting the Emacs editing environment,
......@@ -109,7 +121,7 @@ back to Emacs, allowing you to interact directly with the GDL process from withi
(:texttt "run-gdl.bat") ", " (:texttt "run-gdl.bat") "
startup script, or the provided executable from the Start
menu (windows) or application bundle (Mac).")
(:item "You should see a blue emacs window as in Figure "
(:item "You should see an emacs window similar to that shown in Figure "
(:ref "fig:emacs-startup")
". (alternative colors are also possible).")
......@@ -138,7 +150,7 @@ running. This buffer contains an interactive prompt, labeled "
for testing, debugging, etc. There is also a web-based graphical interactive environment called "
(:emph "tasty")
" which will be discussed in Chapter "
(:ref "chapter:tasty"))
(:ref "chap:thetastydevelopmentenvironment") ".")
(:item "To ensure that the GDL command prompt is up and running, type: "
(:texttt "(+ 2 3)")
......@@ -260,7 +272,7 @@ This will visit the *slime-repl* buffer. Now type: "
modified buffers before exiting."))))
((:section :title "Working with Projects")
"Gendl contains utilities which allow you to treat your
"GDL contains utilities which allow you to treat your
application as a ``project,'' with the ability to compile,
incrementally compile, and load a ``project'' from a directory tree of
source files representing your project. In this section we give an
......@@ -332,7 +344,7 @@ lexigraphical ordering).")
((:subsection :title "Generating an ASDF System")
(:p "ASDF stands for Another System Definition Facility, which
is the predominant system in use for Common Lisp third-party
libraries. With Gendl, you can use the "
libraries. With GDL, you can use the "
(:texttt ":create-asd-file?")
" keyword argument to make cl-lite generate an ASDF system
file instead of actually compiling and loading the system. For example: "
......@@ -379,7 +391,7 @@ process."))))
((:section :title "Customizing your Environment")
" You may customize your environment in several different ways,
for example by loading definitions and settings into your Gendl
for example by loading definitions and settings into your GDL
``world'' automatically when the system starts, and by specifying
fonts, colors, and default buffers (to name a few) for your emacs
editing environment."
......@@ -388,8 +400,8 @@ editing environment."
((:section :title "Saving the World")
" Saving the world refers to a technique of saving a complete
binary image of your Gendl ``world'' which contains all the currently
"``Saving the world'' refers to a technique of saving a complete
binary image of your GDL ``world'' which contains all the currently
compiled and loaded definitions and settings. This allows you to
start up a saved world almost instantly, without being required to
reload all the definitions. You can then incrementally compile and
......@@ -399,7 +411,7 @@ development session.
To save a world, follow these steps:"
((:list :style :enumerate)
(:item "Load the base Gendl code and (optionally) code for Gendl
(:item "Load the base GDL code and (optionally) code for GDL
modules (e.g. gdl-yadd, gdl-tasty) you want to be in your saved image. For example:"
(:verbatim "
(ql:quickload :gdl-yadd)
......@@ -419,9 +431,9 @@ modules (e.g. gdl-yadd, gdl-tasty) you want to be in your saved image. For examp
((:section :title "Starting up a Saved World")
"In order to start up Gendl using a custom saved image, or ``world,'' follow these steps"
"In order to start up GDL using a custom saved image, or ``world,'' follow these steps"
((:list :style :enumerate)
(:item "Exit Gendl")
(:item "Exit GDL")
(:item "Copy the supplied "
(:texttt "gdl.dxl")
" to "
......@@ -429,10 +441,10 @@ modules (e.g. gdl-yadd, gdl-tasty) you want to be in your saved image. For examp
".")
(:item "Move the custom saved dxl image to "
(:texttt "gdl.dxl")
" in the Gendl application "
" in the GDL application "
(:texttt "\"program/\"")
" directory.")
(:item "Start Gendl as usual. Note: you may have to edit the system gdlinit.cl or your home gdlinit.cl
(:item "Start GDL as usual. Note: you may have to edit the system gdlinit.cl or your home gdlinit.cl
to stop it from loading redundant code which is already in the saved image.")))))
......
(in-package :gendl-doc)
(defparameter *bibliography*
"\\begin{thebibliography}{1}
\\bibitem{LaRocca} G. LaRocca \\emph{Knowledge based engineering: Between AI
and CAD. Review of a language based technology to support engineering design}
Advanced Engineering Informatics 26 (2012) 159-179, Elsevier.
\\end{thebibliography}
")
......@@ -22,7 +22,7 @@
(in-package :gendl-doc)
(defparameter *custom-user-interfaces*
`((:chapter :title "Custom User Interfaces in Gendl")
`((:chapter :title "Custom User Interfaces in GDL")
(:p "Another of the strengths of GDL is the ability to create custom
web-based user interfaces. GDL contains a built-in web server and
......@@ -67,7 +67,7 @@ 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 actually a separate language from GDL itself, but rather
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
......@@ -84,8 +84,11 @@ steps are needed:"
"The " (:texttt "main-sheet") " function should return valid
HTML for the page. The easiest way to produce HTML is with the use of
an HTML generating library, such as "
(:href "http://weitz.de/cl-who" "CL-WHO") " or "
(:href "http://weitz.de/cl-who" "CL-WHO")
(:footnote "http://weitz.de/cl-who")
" or "
(:href "http://www.franz.com/support/documentation/current/doc/aserve/htmlgen.html" "HTMLGen")
(:footnote "http://www.franz.com/support/documentation/current/doc/aserve/htmlgen.html")
", both of which are built into GDL.")
(:p "For our examples we will use cl-who, which is currently the
......@@ -105,8 +108,8 @@ visit the page at Edi Weitz' website linked above.")
within a GWL application."
((:boxed-figure :caption "Simple Static Page Example" :label "fig:gwl-1")
(:small (:verbatim
(:include "~/gendl/documentation/tutorial/examples/gwl-1.gdl")))))
(:verbatim
(:include "~/gendl/documentation/tutorial/examples/gwl-1.gdl"))))
(:p "The code in Figure "
......@@ -118,8 +121,8 @@ within a GWL application."
" in a web browser."
((:boxed-figure :caption "Simple Static Page Example" :label "fig:gwl-1-html")
(:small (:verbatim
(:include "~/gendl/documentation/tutorial/examples/gwl-1.html"))))
(:verbatim
(:include "~/gendl/documentation/tutorial/examples/gwl-1.html")))
((:image-figure :image-file "gwl-1.png" :caption "Simple Static Page Example"
:width "4in" :height "3in"
......@@ -329,7 +332,7 @@ to Figure "
(:p "The form-controls provided by GDL are documented in YADD accessible with "
(:verbatim "http://localhost:9000/yadd")
" and in Chapter " (:ref "chapter:gdlreference") " of this Manual. Examples of
" and in Chapter " (:ref "chap:gdlreference") " of this Manual. Examples of
available form-controls are:"
((:list :style :itemize)
(:item (:texttt "text-form-control"))
......
......@@ -28,7 +28,7 @@
geometric entities in various ways. Geometric capabilities are
provided by a library of "
(:emph "low-level primitives")
", or LLPs. LLPs are pre-defined GenDL objects which you can
", or LLPs. LLPs are pre-defined GDL objects which you can
extend by ``mixing in'' with your own definitions, and/or
instantiate as child objects in your definitions.")
......@@ -61,7 +61,7 @@
", and "
(:texttt "merged-solid") "."))
"This chapter will cover the default coordinate system of GenDL as well as the built-in simple 2D and 3D LLPs. Chapter "
"This chapter will cover the default coordinate system of GDL as well as the built-in simple 2D and 3D LLPs. Chapter "
(:ref "chap:workingwithsurfacesandsolids")
" will cover the advanced Surfaces and Solids primitives.")
......
......@@ -53,7 +53,7 @@ is also included; please contact Genworks if you need the source code for this."
(:item "Click to receive license key file by email.")))
((:subsection :title "Unpack the Distribution")
"Genworks GDL is currently distributed as an setup executable for Windows,
"Genworks GDL is currently distributed as a setup executable for Windows,
a ``dmg'' application bundle for Mac, and a self-contained zip file for Linux."
(:ul
(:item "Run the installation executable. Accept the defaults when prompted."
......
......@@ -36,12 +36,14 @@ Gendl Project compiler must be distributed as open-source under a
compatible license (if distributed at all). Commercial Genworks GDL,
properly licensed for development and/or runtime distribution, does
not have this ``copyleft'' open-sourcing requirement.")
". By first investing some of your valuable time into learning
this system, you will be investing in your future productivity, and in
the process you are becoming part of a quiet revolution. Although you
may have come to Genworks GDL because of an interest in 3D modeling or
". By investing some of your valuable time into learning this
system you will be investing in your future productivity and, in the
process, you will become part of a quiet revolution. Although you may
have come to Genworks GDL because of an interest in 3D modeling or
mechanical engineering, you will find that a whole new world, and a
unique approach to computing, will now be at your fingertips.")
unique approach to "
(:emph "computing")
", will now be at your fingertips as well.")
((:section :title "Knowledge Base Concepts According to Genworks")
"You may have an idea about Knowledge Base Systems,
......@@ -63,7 +65,16 @@ system, Genworks GDL.
Our informal definition of a "
(:emph (:indexed "Knowledge Base System"))
" is an object-oriented programming environment which implements the features of "
" is a hybrid "
(:emph "Object-Oriented")
(:footnote "An " (:emph "Object-Oriented")
" programming environment supports named collections of data values and procedures to operate on that data.")
" and "
(:emph "Functional")
(:footnote "A pure " (:emph "Functional")
" programming environment supports only the definition and execution of Functions which work by returning
computed values, but do not modify the in-memory state of any data values.")
" programming environment, which implements the features of "
(:emph (:indexed "Caching"))
" and "
(:emph (:indexed "Dependency tracking"))
......@@ -75,25 +86,28 @@ of that coin --- it ensures that if a cached result is "
(:emph "demanded")
", so as to give a fresh result.")
((:section :title "Classic Definition of Knowledge Based Engineering (KBE)")
(:footnote "Sections "
(:ref "sec:classicdefinitionofknowledgebasedengineering(kbe)")
" through "
(:ref "sec:objectorienteddesign")
" are derived from [cite LaRocca20120306]")
"Sections "
(:ref "sec:classicdefinitionofknowledgebasedengineering(kbe)")
" through "
(:ref "sec:object-orienteddesign")
" are sourced from "
(:cite "LaRocca")
"."
(:quote
"Knowlege based engineering (KBE) is a technology based on the
use of dedicated software tools called KBE systems, which are able to
capture and systematically re-use product and process engineering
knowledge, with the final goal of reducing time and costs of product
development by means of the following:"
(:ul (:li "Automation of repetitive and non-creative design tasks")
(:ul (:li "Automation of repetitive and non-creative design tasks;")
(:li "Support of multidisciplinary design optimization in all the
phases of the design process")))
phases of the design process"))))
((:section :title "Classic Caching Feature")
(:p "Caching refers to the ability of the KBE system to memorize at
((:section :title "Runtime Value Caching and Dependency Tracking")
(:quote
(:p "Caching refers to the ability of the KBE system to memorize at
runtime the results of computed values (e.g. computed slots and
instantiated objects), so that they can be reused when required,
without the need to re-compute them again and again, unless necessary.
......@@ -102,25 +116,26 @@ validity of the cached values. As soon as these values are no longer
valid (stale), they are set to unbound and recomputed if and only at
the very moment they are again demanded.")
(p "This dependency tracking mechanism is at the base of associative
(:p "This dependency tracking mechanism is at the base of associative
modeling, which is of extreme interest for engineering design
applications. For example, the shape of a wing rib can be defined
accordingly to the shape of the wing aerodynamic surface. In case the
latter is modified, the dependency tracking mechanism will notify the
system that teh given rib instance is no longer valid and will be
system that the given rib instance is no longer valid and will be
eliminated from the product tree, together with all the
information (objects and attributes) depending on it. The new rib
object, including its attributes and the rest of the affected
information, will not be re-instantiated/updated/re-evaluated
automatically, but only when and if needed (see demand driven
instantiation in the next section)"))
instantiation in the next section)")))
((:section :title "Demand-Driven Evaluation")
"KBE systems use the "
(:emph "demand-driven")
"approach. That is, they evaluate just those chains of
(:quote
"KBE systems use the "
(:emph "demand-driven")
" approach. That is, they evaluate just those chains of
expressions required to satisfy a direct request of the user (i.e. the
evaluation of certain attributes ofor the instantiation of an object),
evaluation of certain attributes for the instantiation of an object),
or the indirect requests of another object, which is trying to satisfy
a user demand. For example, the system will create an instance of the
rib object only when the weight of the abovementioned wing rib is
......@@ -134,37 +149,25 @@ in hundreds of branches and include thousands of attributes. Hence,
the ability to evaluate specific attributes and product model branches
at demand, without the need to evaluate the whole model from its root,
prevents waste of computational resources and in many cases brings
seemingly intractible problems into the realm of the tractible.")
((:section :title "The Object-Oriented Paradigm meets the Functional paradigm")
"In order to model very complex products and manage efficiently
large bodies of knowledge, KBE systems tap the potential of the object
oriented nature of their underlying language (e.g. Common
Lisp). ``Object'' in this context refers to an instantiated data
structure of a particular assigned data type. As is well-known in
computing community, unrestricted state modification of objects leads
to unmaintainable systems which are difficult to debug. KBE systems
manage this drawback by strictly controlling and constraining
any ability to modify or ``change state'' of objects.
seemingly intractible problems into the realm of the tractible."))
In essence, a KBE system generates a tree of inspectable objects which
is analogous to the function call tree of pure functional-language
systems.")
((:section :title "Object-oriented Systems")
"An object-oriented system is composed of
(:quote "An object-oriented system is composed of
objects (i.e. concrete instantiations of named classes), and
the behavior of the system results from the collaboration of
those objects. Collaboration between objects involves them
sending messages to each other. Sending a message differs from
calling a function in that when a target object receives a
message, it decides on its own what function to carry out to
service that message. The same message may be implemented by
many different functions, the one selected depending on the
current state of the target object.")
calling a function in the sense that when a target object
receives a message, it decides on its own what function to
carry out to service that message. The same message may be
implemented by many different functions, the one selected
depending on the current state of the target object."))
((:section :title "Object-oriented Analysis")
(:p "Object-oriented analysis (OOA) is the process of analyzing
(:quote
(:p "Object-oriented analysis (OOA) is the process of analyzing
a task (also known as a problem domain) to develop a conceptual
model that can then be used to complete the task. A typical OOA
model would describe computer software that could be used to
......@@ -179,38 +182,59 @@ systems.")
constraints (e.g. concurrency, distribution, persistence, or
how the system is to be built) are not considered during the
analysis phase; rather, they are addressed during
object-oriented design (OOD).")
object-oriented design (OOD) phase.")
(:p "The conceptual model that results from OOA will typically consist of a
(:p "The conceptual model that results from OOA will typically consist of a
set of use cases, one or more UML class diagrams, and a number of
interaction diagrams. It may also include some kind of user interface."))
interaction diagrams. It may also include some kind of user interface.")))
((:section :title "Object-oriented Design")
"During object-oriented design (OOD), a developer applies implementation constraints
to the conceptual model produced in object-oriented analysis. Such constraints could include
not only constraints imposed by the chosen architecture but also any non-functional ---
technological or environmental --- constraints, such as transaction throughput, response time,
run-time platform, development environment, or those inherent in the programming language. Concepts
in the analysis model are mapped onto implementation classes and interfaces resulting in
a model of the solution domain, i.e., a detailed description of "
(:emph "how")
" the system is to be built.")
(:quote
"During the object-oriented design (OOD) phase, a developer
applies implementation constraints to the conceptual model produced in
object-oriented analysis. Such constraints could include not only
constraints imposed by the chosen architecture but also any
non-functional --- technological or environmental --- constraints,
such as transaction throughput, response time, run-time platform,
development environment, or those inherent in the programming
language. Concepts in the analysis model are mapped onto
implementation classes and interfaces resulting in a model of the
solution domain, i.e., a detailed description of "
(:emph "how")
" the system is to be built."))
((:section :title "The Object-Oriented Paradigm meets the Functional paradigm")
"In order to model very complex products and efficiently manage
large bodies of knowledge, KBE systems tap the potential of the object
oriented nature of their underlying language (e.g. Common
Lisp). ``Object'' in this context refers to an instantiated data
structure "
(:emph "of a particular assigned data type")
". As is well-known in the computing community, unrestricted state
modification of objects leads to unmaintainable systems which are
difficult to debug. KBE systems manage this drawback by strictly
controlling and constraining any ability to modify or ``change state''
of objects.
In essence, a KBE system generates a tree of inspectable objects which
is analogous to the function call tree of pure functional-language
systems.")
((:section :title "Goals for this Manual")
"This manual is designed as a companion to a live two-hour
GDL/GWL tutorial, but you may also be relying on it independent of the
video tutorial. In either case, the basic goals are:"
GDL/GWL tutorial, but you may also be relying on it independently of the
video tutorial. In either case, the fundamental goals are:"
((:list :style :itemize)
(:item "Get you motivated about using Genworks GDL")
(:item "To get you motivated about using Genworks GDL")
(:item "Enable you to ascertain whether Genworks GDL is an appropriate tool for a given job")
(:item "Equip you with the ability to state the case for using GDL/GWL when appropriate")
(:item "Prepare you to begin authoring and maintaining GDL
applications, or porting apps from similar KB systems into GDL."))
"This manual will begins with an introduction to the "
"The manual will begin with an introduction to the "
(:indexed "Common Lisp")
" programming language. If you are new to Common Lisp:
congratulations! You have just been introduced to a powerful tool
congratulations! You are about to be introduced to a powerful tool
backed by a rock-solid standard specification, which will protect your
development investment for decades to come. In addition to the
overview in this manual, many resources are available to get you
......@@ -219,43 +243,44 @@ started in CL --- for starters, we recommend "
(:footnote (:underline "BLT")
" is available at "
(:texttt "http://www.franz.com/resources/educational_resources/cooper.book.pdf"))
", which was prepared by the author. ")
", which was written by the author. ")
((:section :title "What is GDL?")
"GDL is an acronym for
``General-purpose Declarative Language.''
GDL is a superset of ANSI Common Lisp, and consists largely of
``General-purpose Declarative Language.''"
(:ul
(:li
"GDL is a superset of ANSI Common Lisp, and consists largely of
automatic code-expanding extensions to Common Lisp implemented in the
form of macros. When you write, for example, 20 lines in GDL, you
might be writing the equivalent of 200 lines of Common Lisp. Of
course, since GDL is a superset of Common Lisp, you still have the
might be writing the equivalent of 200 lines of Common Lisp. Given
that GDL is a superset of Common Lisp, you of course still have the
full power of the CL language at your disposal whenever you are
working in GDL.
working in GDL.")
"
(:index "compiled language!benefits of")
(:index "macros!code-expanding")
"Since GDL expands into CL, everything you write in GDL will be
(:li
"Since GDL expands into CL, everything you write in GDL will be
compiled ``down to the metal'' to machine code with all the
optimizations and safety that the tested-and-true CL compiler provides
[this is an important distinction as contrasted to some other
so-called KB systems on the market, which are essentially nothing more
than interpreted "
(:emph "scripting languages")
" which often impose arbitrary limits on
the size and complexity of the application.
(:emph "scripting languages")