<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	>
<channel>
	<title>Comments on: Continuations: What is the deal?</title>
	<atom:link href="http://www.coderjoe.net/archive/2007/09/07/continuations-what-is-the-deal/feed/" rel="self" type="application/rss+xml" />
	<link>http://www.coderjoe.net/archive/2007/09/07/continuations-what-is-the-deal/</link>
	<description>Me, myself, and my code.</description>
	<pubDate>Wed, 07 Jan 2009 12:56:08 +0000</pubDate>
	<generator>http://wordpress.org/?v=2.7</generator>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
		<item>
		<title>By: Joseph Pecoraro</title>
		<link>http://www.coderjoe.net/archive/2007/09/07/continuations-what-is-the-deal/comment-page-1/#comment-1870</link>
		<dc:creator>Joseph Pecoraro</dc:creator>
		<pubDate>Sat, 08 Sep 2007 05:22:43 +0000</pubDate>
		<guid isPermaLink="false">http://www.coderjoe.net/archive/2007/09/07/continuations-what-is-the-deal/#comment-1870</guid>
		<description>I have a very limited experience with continuations but in my opinion they are rather misleading.  As you and Wikipedia both point out they are basically managed goto's where the language is wrapping the goto in the necessary logic in order for the programmer to not do anything stupid.

The popular reasoning for abandoning goto statements was Dijkstra's letter "Go To Statement Considered Harmful," in which Dijkstra's placed immense value on being able to track program execution deterministically.  Hence the popularity of structured programming with the flow structure we are familiar with today.  An excellent source on this topic (which I just scanned) is:
http://david.tribble.com/text/goto.html

However Dijkstra did not say that goto should be completely eliminated, just that they often trash a program's clarity.  They did not help produce succinct programs.  (There are of course some exceptions).

Still I tend to look at continuations as throwaways.  They are a language supported way to put a pre-condition (a guarantee) inside of a function.  Any "block" of code in a continuation could just as easily have been handled outside of the function and passed in as a parameter.  I am thinking of functions as functions, not as generators, so that is probably my fault.  My idea sounds close to how tail recursion is implemented and indeed Wikipedia points that out (http://en.wikipedia.org/wiki/Continuation#Kinds_of_continuations).  They also point out exception handling.

I would agree with you that Closures are far more useful and exciting.

What Seaside has done is rather clever but I would need to know more about the low level components to judge if it is a worthy.

Interesting read, it really had me thinking about a lot of different things that I don't normally think about.</description>
		<content:encoded><![CDATA[<p>I have a very limited experience with continuations but in my opinion they are rather misleading.  As you and Wikipedia both point out they are basically managed goto&#8217;s where the language is wrapping the goto in the necessary logic in order for the programmer to not do anything stupid.</p>
<p>The popular reasoning for abandoning goto statements was Dijkstra&#8217;s letter &#8220;Go To Statement Considered Harmful,&#8221; in which Dijkstra&#8217;s placed immense value on being able to track program execution deterministically.  Hence the popularity of structured programming with the flow structure we are familiar with today.  An excellent source on this topic (which I just scanned) is:<br />
<a href="http://david.tribble.com/text/goto.html" rel="nofollow">http://david.tribble.com/text/goto.html</a></p>
<p>However Dijkstra did not say that goto should be completely eliminated, just that they often trash a program&#8217;s clarity.  They did not help produce succinct programs.  (There are of course some exceptions).</p>
<p>Still I tend to look at continuations as throwaways.  They are a language supported way to put a pre-condition (a guarantee) inside of a function.  Any &#8220;block&#8221; of code in a continuation could just as easily have been handled outside of the function and passed in as a parameter.  I am thinking of functions as functions, not as generators, so that is probably my fault.  My idea sounds close to how tail recursion is implemented and indeed Wikipedia points that out (http://en.wikipedia.org/wiki/Continuation#Kinds_of_continuations).  They also point out exception handling.</p>
<p>I would agree with you that Closures are far more useful and exciting.</p>
<p>What Seaside has done is rather clever but I would need to know more about the low level components to judge if it is a worthy.</p>
<p>Interesting read, it really had me thinking about a lot of different things that I don&#8217;t normally think about.</p>
]]></content:encoded>
	</item>
</channel>
</rss>

<!-- Dynamic Page Served (once) in 0.902 seconds -->
