doc: Filled out Introduction and Acknowledgement sections

* doc/8sync.texi: Updated docs

diff --git a/doc/8sync.texi b/doc/8sync.texi
index af4580b6601ed23cc363f8676c78bc64c52dd8c8..231ddde9beba446fd5ffe3a60fa63f2bd29d5d00 100644 (file)
--- a/doc/8sync.texi
+++ b/doc/8sync.texi
@@ -50,19 +50,79 @@ Foundation Web site at @url{http://www.gnu.org/licenses/lgpl.html}.
 @c Generate the nodes for this menu with `C-c C-u C-m'.
 
 
+@c Update all node entries with `C-c C-u C-n'.
+@c Insert new nodes with `C-c C-c n'.
+
 @menu
-* Introduction::                About 8sync
+* Introduction::
+* Acknowledgements::
 * Copying This Manual::
-* Index::                       Complete index.
+* Index::
 @end menu
 
-@c Update all node entries with `C-c C-u C-n'.
-@c Insert new nodes with `C-c C-c n'.
-
 @node Introduction
 @chapter Introduction
 
-8sync 8sync 8sync!
+8sync's goal is to make asynchronous programming easy.  If you've worked
+with most other asynchronous programming environments, you know that it
+generally isn't.  Usually asynchronous programming involves entering
+some sort of ``callback hell''.  Some nicer environments like Asyncio
+for Python provide coroutines, but even these require a lot of work to
+carefully line up.
+
+Coding in 8sync, on the other hand, looks almost entirely like coding
+anywhere else.  This is because 8sync makes great use of a cool feature
+in Guile called ``delimited continuations''.  Because of this, you can
+invoke your asynchronous code with a small wrapper around it, and that
+code will pop off to complete whatever other task it needs to do, and
+resume your function when it's ready passing back the appropriate value.
+
+Now that's pretty cool!
+
+@node Acknowledgements
+@chapter Acknowledgements
+
+8sync has a number of inspirations:
+
+@itemize @bullet
+@item
+@uref{https://docs.python.org/3.5/library/asyncio.html, asyncio}
+for Python provides a nice asynchronous programming environment, and
+makes great use of coroutines.  It's a bit more difficult to work with
+than 8sync (or so thinks the author) because you have to ``line up''
+coroutines.
+
+@item
+@uref{http://dthompson.us/pages/software/sly.html, Sly}
+by David Thompson is an awesome functional reactive game programming
+library for Guile.  If you want to write graphical games, Sly is almost
+certainly a better choice than 8sync.  Thanks to David for being very
+patient in explaining tough concepts; experience on hacking Sly greatly
+informed 8sync's development.  (Check out Sly, it rocks!)
+
+@item
+Reading @uref{https://mitpress.mit.edu/sicp/, SICP}, particularly
+@uref{https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-19.html#%_chap_3,
+      Chapter 3's writings on concurrent systems},
+greatly informed 8sync's design.
+
+@item
+Finally, @uref{https://docs.python.org/3.5/library/asyncio.html, XUDD}
+was an earlier ``research project'' that preceeded 8sync.  It attempted
+to bring an actor model system to Python.  However, the author
+eventually grew frustrated with some of Python's limitations, fell in
+love with Guile, and well... now we have 8sync, which is much more
+general anyway.
+
+@end itemize
+
+The motivation to build 8sync came out of
+@uref{https://lists.gnu.org/archive/html/guile-devel/2015-10/msg00015.html, a conversation}
+at the FSF 30th party between Mark Weaver, David Thompson, Andrew
+Engelbrecht, and Christopher Allan Webber over how to build
+an asynchronous event loop for Guile and just what would be needed.
+
+A little over a month after that, hacking on 8sync began!
 
 
 @node Copying This Manual