Fix awkforai.txt to avoid copyright issues.

4 files changed, 74 insertions, 198 deletions

diff --git a/doc/ChangeLog b/doc/ChangeLog
index 2dbbd08f..d255da2b 100644
--- a/doc/ChangeLog
+++ b/doc/ChangeLog
@@ -1,3 +1,9 @@
+2012-12-09         Arnold D. Robbins     <arnold@skeeve.com>
+
+	* awkforai.txt: Changed content to be pointers to the article
+	to avoid copyright issues.
+	* gawk.texi: Updated description of awkforai.txt.
+
 2012-12-07         Arnold D. Robbins     <arnold@skeeve.com>
 
 	* gawk.texi (I/O Functions): Document that fflush() is now part
diff --git a/doc/awkforai.txt b/doc/awkforai.txt
index 3fca3204..2908da56 100644
--- a/doc/awkforai.txt
+++ b/doc/awkforai.txt
@@ -1,150 +1,18 @@
-Draft for ACM SIGPLAN Patterns (Language Trends)
+Sun Dec  9 11:58:23 IST 2012
+============================
 
-1996
+The original of this file was a draft of an article written in 1996 by
+Ronald P. Lui for an ACM Sigplan publication, explaining why he used
+gawk for teaching introductory Artificial Intelligence courses.
 
-Why GAWK for AI?
+Since it was not clear as to copying permissions and so on, it has been
+removed from the gawk distribution.
 
-Ronald P. Loui
+A quick web search shows that this same draft is available at
+http://www.cs.wustl.edu/~loui/sigplan and the final article is available
+from the ACM: http://dl.acm.org/citation.cfm?id=242908
 
-Most people are surprised when I tell them what language we use in our
-undergraduate AI programming class.  That's understandable.  We use
-GAWK.  GAWK, Gnu's version of Aho, Weinberger, and Kernighan's old
-pattern scanning language isn't even viewed as a programming language by
-most people.  Like PERL and TCL, most prefer to view it as a "scripting
-language."  It has no objects; it is not functional; it does no built-in
-logic programming.  Their surprise turns to puzzlement when I confide
-that (a) while the students are allowed to use any language they want;
-(b) with a single exception, the best work consistently results from
-those working in GAWK.  (footnote:  The exception was a PASCAL
-programmer who is now an NSF graduate fellow getting a Ph.D. in
-mathematics at Harvard.) Programmers in C, C++, and LISP haven't even
-been close (we have not seen work in PROLOG or JAVA).
+The article itself is recommended reading.
 
-Why GAWK?
-
-There are some quick answers that have to do with the pragmatics of
-undergraduate programming.  Then there are more instructive answers that
-might be valuable to those who debate programming paradigms or to those
-who study the history of AI languages.  And there are some deep
-philosophical answers that expose the nature of reasoning and symbolic
-AI.  I think the answers, especially the last ones, can be even more
-surprising than the observed effectiveness of GAWK for AI.
-
-First it must be confessed that PERL programmers can cobble together AI
-projects well, too.  Most of GAWK's attractiveness is reproduced in
-PERL, and the success of PERL forebodes some of the success of GAWK.
-Both are powerful string-processing languages that allow the programmer
-to exploit many of the features of a UNIX environment.  Both provide
-powerful constructions for manipulating a wide variety of data in
-reasonably efficient ways.  Both are interpreted, which can reduce
-development time.  Both have short learning curves.  The GAWK manual can
-be consumed in a single lab session and the language can be mastered by
-the next morning by the average student.  GAWK's automatic
-initialization, implicit coercion, I/O support and lack of pointers
-forgive many of the mistakes that young programmers are likely to make.
-Those who have seen C but not mastered it are happy to see that GAWK
-retains some of the same sensibilities while adding what must be
-regarded as spoonsful of syntactic sugar.  Some will argue that
-PERL has superior functionality, but for quick AI applications, the
-additional functionality is rarely missed.  In fact, PERL's terse syntax
-is not friendly when regular expressions begin to proliferate and
-strings contain fragments of HTML, WWW addresses, or shell commands.
-PERL provides new ways of doing things, but not necessarily ways of
-doing new things.
-
-In the end, despite minor difference, both PERL and GAWK minimize
-programmer time.  Neither really provides the programmer the setting in
-which to worry about minimizing run-time.
-
-There are further simple answers.  Probably the best is the fact that
-increasingly, undergraduate AI programming is involving the Web.  Oren
-Etzioni (University of Washington, Seattle) has for a while been arguing
-that the "softbot" is replacing the mechanical engineers' robot as the
-most glamorous AI testbed.  If the artifact whose behavior needs to be
-controlled in an intelligent way is the software agent, then a language
-that is well-suited to controlling the software environment is the
-appropriate language.  That would imply a scripting language.  If the
-robot is KAREL, then the right language is "turn left; turn right." If
-the robot is Netscape, then the right language is something that can
-generate "netscape -remote 'openURL(http://cs.wustl.edu/~loui)'" with
-elan.
-
-Of course, there are deeper answers.  Jon Bentley found two pearls in
-GAWK:  its regular expressions and its associative arrays.  GAWK asks
-the programmer to use the file system for data organization and the
-operating system for debugging tools and subroutine libraries.  There is
-no issue of user-interface.  This forces the programmer to return to the
-question of what the program does, not how it looks.  There is no time
-spent programming a binsort when the data can be shipped to /bin/sort
-in no time.  (footnote:  I am reminded of my IBM colleague Ben Grosof's
-advice for Palo Alto:  Don't worry about whether it's highway 101 or 280.
-Don't worry if you have to head south for an entrance to go north.  Just
-get on the highway as quickly as possible.)
-
-There are some similarities between GAWK and LISP that are illuminating.
-Both provided a powerful uniform data structure (the associative array
-implemented as a hash table for GAWK and the S-expression, or list of
-lists, for LISP).  Both were well-supported in their environments (GAWK
-being a child of UNIX, and LISP being the heart of lisp machines).  Both
-have trivial syntax and find their power in the programmer's willingness
-to use the simple blocks to build a complex approach.
-
-Deeper still, is the nature of AI programming.  AI is about
-functionality and exploratory programming.  It is about bottom-up design
-and the building of ambitions as greater behaviors can be demonstrated.
-Woe be to the top-down AI programmer who finds that the bottom-level
-refinements, "this subroutine parses the sentence," cannot actually be
-implemented.  Woe be to the programmer who perfects the data structures
-for that heapsort when the whole approach to the high-level problem
-needs to be rethought, and the code is sent to the junkheap the next day.
-
-AI programming requires high-level thinking.  There have always been a few
-gifted programmers who can write high-level programs in assembly language.
-Most however need the ambient abstraction to have a higher floor.  
-
-Now for the surprising philosophical answers.  First, AI has discovered
-that brute-force combinatorics, as an approach to generating intelligent
-behavior, does not often provide the solution.  Chess, neural nets, and
-genetic programming show the limits of brute computation.  The
-alternative is clever program organization.  (footnote: One might add
-that the former are the AI approaches that work, but that is easily
-dismissed:  those are the AI approaches that work in general, precisely
-because cleverness is problem-specific.)  So AI programmers always want
-to maximize the content of their program, not optimize the efficiency
-of an approach.  They want minds, not insects.  Instead of enumerating
-large search spaces, they define ways of reducing search, ways of
-bringing different knowledge to the task.  A language that maximizes
-what the programmer can attempt rather than one that provides tremendous
-control over how to attempt it, will be the AI choice in the end.
-
-Second, inference is merely the expansion of notation.  No matter whether
-the logic that underlies an AI program is fuzzy, probabilistic, deontic,
-defeasible, or deductive, the logic merely defines how strings can be 
-transformed into other strings.  A language that provides the best
-support for string processing in the end provides the best support for
-logic, for the exploration of various logics, and for most forms of
-symbolic processing that AI might choose to call "reasoning" instead of
-"logic."  The implication is that PROLOG, which saves the AI programmer
-from having to write a unifier, saves perhaps two dozen lines of GAWK
-code at the expense of strongly biasing the logic and representational
-expressiveness of any approach.
-
-I view these last two points as news not only to the programming language
-community, but also to much of the AI community that has not reflected on
-the past decade's lessons.
-
-In the puny language, GAWK, which Aho, Weinberger, and Kernighan thought
-not much more important than grep or sed, I find lessons in AI's trends,
-AI's history, and the foundations of AI.  What I have found not only
-surprising but also hopeful, is that when I have approached the AI
-people who still enjoy programming, some of them are not the least bit
-surprised.
-
-
-R. Loui (loui@ai.wustl.edu) is Associate Professor of Computer Science,
-at Washington University in St. Louis.  He has published in AI Journal,
-Computational Intelligence, ACM SIGART, AI Magazine, AI and Law, the ACM
-Computing Surveys Symposium on AI, Cognitive Science, Minds and
-Machines, Journal of Philosophy, and is on this year's program
-committees for AAAI (National AI conference) and KR (Knowledge
-Representation and Reasoning).
+Arnold Robbins
+arnold@skeeve.com
diff --git a/doc/gawk.info b/doc/gawk.info
index e23618b0..9ce4b602 100644
--- a/doc/gawk.info
+++ b/doc/gawk.info
@@ -20532,8 +20532,9 @@ Various `.c', `.y', and `.h' files
      does not.
 
 `doc/awkforai.txt'
-     A short article describing why `gawk' is a good language for
-     Artificial Intelligence (AI) programming.
+     Pointers to the original draft of a short article describing why
+     `gawk' is a good language for Artificial Intelligence (AI)
+     programming.
 
 `doc/bc_notes'
      A brief description of `gawk''s "byte code" internals.
@@ -27257,7 +27258,7 @@ Index
 * testbits.awk program:                  Bitwise Functions.   (line  68)
 * Texinfo <1>:                           Adding Code.         (line  99)
 * Texinfo <2>:                           Distribution contents.
-                                                              (line  79)
+                                                              (line  80)
 * Texinfo <3>:                           Extract Program.     (line  12)
 * Texinfo <4>:                           Dupword Program.     (line  17)
 * Texinfo <5>:                           Library Functions.   (line  22)
@@ -27861,54 +27862,54 @@ Node: Gawk Distribution816604
 Node: Getting817088
 Node: Extracting817914
 Node: Distribution contents819606
-Node: Unix Installation824828
-Node: Quick Installation825445
-Node: Additional Configuration Options827407
-Node: Configuration Philosophy828884
-Node: Non-Unix Installation831226
-Node: PC Installation831684
-Node: PC Binary Installation832983
-Node: PC Compiling834998
-Node: PC Testing837942
-Node: PC Using839118
-Node: Cygwin843303
-Node: MSYS844303
-Node: VMS Installation844817
-Node: VMS Compilation845420
-Ref: VMS Compilation-Footnote-1846427
-Node: VMS Installation Details846485
-Node: VMS Running848120
-Node: VMS Old Gawk849727
-Node: Bugs850201
-Node: Other Versions854053
-Node: Notes859334
-Node: Compatibility Mode860026
-Node: Additions860809
-Node: Accessing The Source861621
-Node: Adding Code863046
-Node: New Ports869013
-Node: Dynamic Extensions873126
-Node: Internals874502
-Node: Plugin License883605
-Node: Sample Library884239
-Node: Internal File Description884925
-Node: Internal File Ops888640
-Ref: Internal File Ops-Footnote-1893421
-Node: Using Internal File Ops893561
-Node: Future Extensions895938
-Node: Basic Concepts898442
-Node: Basic High Level899199
-Ref: Basic High Level-Footnote-1903234
-Node: Basic Data Typing903419
-Node: Floating Point Issues907944
-Node: String Conversion Precision909027
-Ref: String Conversion Precision-Footnote-1910727
-Node: Unexpected Results910836
-Node: POSIX Floating Point Problems912662
-Ref: POSIX Floating Point Problems-Footnote-1916367
-Node: Glossary916405
-Node: Copying941580
-Node: GNU Free Documentation License979137
-Node: Index1004274
+Node: Unix Installation824867
+Node: Quick Installation825484
+Node: Additional Configuration Options827446
+Node: Configuration Philosophy828923
+Node: Non-Unix Installation831265
+Node: PC Installation831723
+Node: PC Binary Installation833022
+Node: PC Compiling835037
+Node: PC Testing837981
+Node: PC Using839157
+Node: Cygwin843342
+Node: MSYS844342
+Node: VMS Installation844856
+Node: VMS Compilation845459
+Ref: VMS Compilation-Footnote-1846466
+Node: VMS Installation Details846524
+Node: VMS Running848159
+Node: VMS Old Gawk849766
+Node: Bugs850240
+Node: Other Versions854092
+Node: Notes859373
+Node: Compatibility Mode860065
+Node: Additions860848
+Node: Accessing The Source861660
+Node: Adding Code863085
+Node: New Ports869052
+Node: Dynamic Extensions873165
+Node: Internals874541
+Node: Plugin License883644
+Node: Sample Library884278
+Node: Internal File Description884964
+Node: Internal File Ops888679
+Ref: Internal File Ops-Footnote-1893460
+Node: Using Internal File Ops893600
+Node: Future Extensions895977
+Node: Basic Concepts898481
+Node: Basic High Level899238
+Ref: Basic High Level-Footnote-1903273
+Node: Basic Data Typing903458
+Node: Floating Point Issues907983
+Node: String Conversion Precision909066
+Ref: String Conversion Precision-Footnote-1910766
+Node: Unexpected Results910875
+Node: POSIX Floating Point Problems912701
+Ref: POSIX Floating Point Problems-Footnote-1916406
+Node: Glossary916444
+Node: Copying941619
+Node: GNU Free Documentation License979176
+Node: Index1004313
 
 End Tag Table
diff --git a/doc/gawk.texi b/doc/gawk.texi
index 63e9cbd6..ec83964d 100644
--- a/doc/gawk.texi
+++ b/doc/gawk.texi
@@ -27565,7 +27565,8 @@ as a list of things that the POSIX standard should describe but does not.
 
 @cindex artificial intelligence@comma{} @command{gawk} and
 @item doc/awkforai.txt
-A short article describing why @command{gawk} is a good language for
+Pointers to the original draft of
+a short article describing why @command{gawk} is a good language for
 Artificial Intelligence (AI) programming.
 
 @item doc/bc_notes