[Stackless] quick layout and timeline of my pycon talk planned

Christian Tismer tismer at stackless.com
Sat Nov 11 15:13:37 CET 2006

Hi Pycon Organizers!
My apologies that I didn't hit yesterday's deadline.
I'm trying to provide some schedule information, anyway.
Some additional info is at the end.

Summary (unchanged):

As a surprise for people who think they know Stackless,
we present the new Stackless implementation For PyPy,
which has led to a significant amount of new insight
about parallel programming and its possible implementations.
We will isolate the known Stackless as a special case of
a general concept.

This is a Stackless, not a PyPy talk. But the insights presented
here would not exist without PyPy's existance.

Description (unchanged):

Stackless has been around for a long time now. After several
versions with different goals in mind, the basic concepts of
channels and tasklets turned out to be useful abstractions,
and since many versions, Stackless is only ported from version
to version, without fundamental changes to the principles.

As some spin-off, Armin Rigo invented Greenlets at a Stackless
sprint. They are some kind of coroutines and a bit of special
semantics. The major benefit is that Greenlets can run on
unmodified CPython.

In parallel to that, the PyPy project is in its fourth year
now, and one of its goals was Stackless integration as an option.
And of course, Stackless has been integrated into PyPy in a very
nice and elegant way, much nicer than expected. During the design
of the Stackless extension to PyPy, it turned out, that tasklets,
greenlets and coroutines are not that different in principle,
and it was possible to base all known parallel paradigms on
one simple coroutine layout, which is as minimalistic as possible.

It is a side effect of PyPy's simplicity, that even led to a
pretty new concept for Stackless, that allows all the different
switching paradigms to co-exist without interference. Users
could go further and implement their own concurrency model,
and it would neither interfere with others nor cost performance.

Today's Stackless can be seen as a special case of the more general
implementation given for PyPy. This implementation can also be taken
as a reference about how Stackless is meant to be implemented.
This reference implementation is completely written in Python.

The talk will try to isolate the crucial design decisions in
Stackless from implementation details. The reduced concepts
are together the essentials of Stackless.

Addition to the description:

Here a little breakdown of topics and how much time is planned:
Although there is some theory, everything will be accompanied
by code examples. People will at least enjoy the interaction.

7 minutes:
A rough summary of the Stackless API
Channels, tasklets, small sample programs
slides + interactive session

8 minutes:
Extracting the basics
Coroutines and Greenlets
switchable code in general
generators as a special case with limits

9 minutes
A coroutine-based implementation
with co-existing, user-extendable switching methods
quick sketch of the implementation
Examples running on top of PyPy
slides + interactive session

6 minutes
Discussion, questions

cheers - chris

Christian Tismer             :^)   <mailto:tismer at stackless.com>
tismerysoft GmbH             :     Have a break! Take a ride on Python's
Johannes-Niemeyer-Weg 9A     :    *Starship* http://starship.python.net/
14109 Berlin                 :     PGP key -> http://wwwkeys.pgp.net/
work +49 30 802 86 56  mobile +49 173 24 18 776  fax +49 30 80 90 57 05
PGP 0x57F3BF04       9064 F4E1 D754 C2FF 1619  305B C09C 5A3B 57F3 BF04
       whom do you want to sponsor today?   http://www.stackless.com/

Stackless mailing list
Stackless at stackless.com

Stackless mailing list
Stackless at stackless.com

More information about the Stackless mailing list