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.
+for Python provide generator-based 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.
+in Guile called ``delimited continuations'' to power natural-feeling
+coroutines. 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. (No need to manually chain
+the coroutines together, and no callback hell at all!)
Now that's pretty cool!
@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.
+makes great use of generator-style coroutines. It's a bit more
+difficult to work with than 8sync (or so thinks the author) because you
+have to ``line up'' the coroutines.
@item
@uref{http://dthompson.us/pages/software/sly.html, Sly}
A little over a month after that, hacking on 8sync began!
+@node 8sync's license and general comments on copyleft
+@chapter 8sync's license and general comments on copyleft
+
+8sync is released under the GNU LGPL (Lesser General Public License),
+version 3 or later, as published by the Free Software Foundation. The
+short version of this is that if you distribute a modifications to
+8sync, whether alone or in some larger combination, must release the
+corresponding source code. In general, it is best to contribute them
+back to 8sync under the same terms; we'd appreciate any enhancements or
+fixes to be contributed upstream to 8sync itself. (This is an
+intentional oversimplification for brevity, please read the LGPL for the
+precise terms.)
+
+This usage of the LGPL helps us ensure that 8sync and derivatives of
+8sync as a library will remain free. However, we cannot provide the
+same freedom-protecting requirements for applications built on top of
+8sync. Though it is not a requirement, we request you use 8sync to
+build free software rather than use it to contribute to the growing
+world of proprietary software.
+
+The choice of the LGPL for 8sync was a strategic one, though in general,
+we encourage stronger copyleft. (For more thinking on this position, see
+@uref{https://www.gnu.org/licenses/why-not-lgpl.html,
+ Why you shouldn't use the Lesser GPL for your next library}.)
+
+In particular, if you are building a library or application that uses
+8sync in some useful way, consider releasing your program under the GNU
+GPL or GNU AGPL! In a world where more and more software is locked
+down, where software is used to restrict users, we could use every
+chance we can get to provide protections so that software which is free
+remains free, and encourages even more software freedom to be built upon
+it.
+
+So to answer the question, ``Can I build a proprietary program on top of
+8sync?'' our response is ``Yes, but please don't. Choose to release
+your software under a freedom-respecting license. And help us turn the
+tide towards greater software freedom... consider a strong copyleft
+license!''
+
+
@node Copying This Manual
@appendix Copying This Manual
projects / 8sync.git / blobdiff