Stackless: Recent advancements and future goals
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Part Number | 33 | |
| Number of Parts | 119 | |
| Author | ||
| License | CC Attribution 3.0 Unported: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/19955 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language | ||
| Production Place | Berlin |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
| |
| Keywords |
00:00
GoogolProjective planeMathematicsAsynchronous Transfer ModePresentation of a groupDrop (liquid)Vector spaceComputer animationMeeting/Interview
01:48
Revision controlMetropolitan area networkState of matterFunction (mathematics)System callMenu (computing)Dedekind cutModule (mathematics)Extension (kinesiology)Computer programTask (computing)Message passingThread (computing)CoroutineAlgebraComputer multitaskingMountain passPermianLetterpress printingObject (grammar)Scheduling (computing)EmulationAcoustic shadowExistenceProduct (business)FreewareFunctional (mathematics)State of matterComputer programmingDivisorLie groupContent (media)Video gameCAN busCoroutineTask (computing)Constructor (object-oriented programming)Program slicingMultiplication signPhysical systemRight angleIdentity managementContext awarenessLimit (category theory)Order (biology)Different (Kate Ryan album)Pattern languagePerspective (visual)Vector spaceCausalityGraph (mathematics)Module (mathematics)Goodness of fitBitMathematicsImplementationCASE <Informatik>Exception handlingEndliche ModelltheoriePoint (geometry)Normal (geometry)MereologyType theoryVirtual machineInterpreter (computing)Extension (kinesiology)Communications protocolLevel (video gaming)Core dumpRecursionArithmetic meanFile formatRevision controlComputer animationLecture/ConferenceMeeting/Interview
08:39
ArmValue-added networkSubsetStack (abstract data type)SummierbarkeitContext awarenessScheduling (computing)Personal digital assistantCAN busVirtual machineSound effectForceThread (computing)IcosahedronComputer programState of matterInterpreter (computing)ImplementationSoftware developerDataflowRadio-frequency identificationLevel (video gaming)Letterpress printingFunction (mathematics)Scripting languagePort scannerExt functorMUDArtificial neural networkStorage area networkMetropolitan area networkMenu (computing)Bus (computing)System callWordFunctional (mathematics)State of matterComputer programmingVirtual machinePoint (geometry)Real numberTask (computing)Function (mathematics)WindowLevel (video gaming)Different (Kate Ryan album)Interpreter (computing)RecursionContext awarenessNP-hardForcing (mathematics)Computing platformDemo (music)MereologyMultilaterationComputer clusterBitMultiplication signStudent's t-testDivisorRootParameter (computer programming)Natural number1 (number)Sound effectCASE <Informatik>Cellular automatonCausalityLetterpress printingComputer animation
15:13
CAN busSpecial unitary groupMenu (computing)Metropolitan area networkMaizeUniform resource nameArtificial neural networkExecution unitPointer (computer programming)Arc (geometry)Computer clusterAmsterdam Ordnance DatumWoven fabricWindowComputer programmingRhombusUltimatum gameVirtual machineProduct (business)Inheritance (object-oriented programming)SupercomputerSampling (statistics)TimestampShared memoryIntegrated development environmentTask (computing)Gene clusterVirtualizationProcess (computing)Multiplication signRevision controlGame controllerComputer animation
17:13
Maxima and minimaCAN busLine (geometry)Function (mathematics)Scripting languageIntelLevel (video gaming)UsabilityGreen's functionModule (mathematics)Extension (kinesiology)State of matterComputer programTablet computerDomain nameStack (abstract data type)Order (biology)Electric generatorThread (computing)Cloud computingComputerPhysical systemDifferent (Kate Ryan album)Operations researchPoint cloudNumberSanitary sewerMereologyControl flowPersonal area networkData structureServer (computing)SynchronizationProcess (computing)Metropolitan area networkInterior (topology)Artificial neural networkSpecial unitary groupEmulationUniform resource nameConditional-access moduleAmsterdam Ordnance DatumSummierbarkeitTotal S.A.Computer clusterValue-added networkUniform boundedness principleExecution unit3 (number)Scalable Coherent InterfaceInclusion mapWater vaporComputer programmingOpen setNeuroinformatikGame theoryGraph coloringDifferent (Kate Ryan album)BitRight angleSpring (hydrology)Instance (computer science)QuicksortRegular graphMIDIPerspective (visual)Extension (kinesiology)Module (mathematics)Dependent and independent variablesField (computer science)Projective planeWindowVector spacePhysical systemCloud computingDemo (music)CASE <Informatik>Point cloudStandard deviationCodeRotationFinite differenceComputer animation
22:45
Task (computing)Local ringHuman migrationInstance (computer science)CircleComputer programmingLevel (video gaming)Scheduling (computing)Data structureBuildingControl flowAntiderivativeLecture/Conference
23:31
Stack (abstract data type)World Wide Web ConsortiumSoftware frameworkGame theorySystem programmingWindows InstallerSource codeRevision controlMultiplication signEquivalence relationWebsiteComa BerenicesBitComputer configurationInstallation artProcess (computing)Projective planeWindowRevision controlInstallation artSet (mathematics)Equivalence relationFamilyIntegrated development environmentOnline gameTheoryProduct (business)Image resolutionStructural loadOpen setSystem callLevel (video gaming)Library (computing)Game theoryTwitterPhysical systemPerspective (visual)Arithmetic progressionMereologyOrder (biology)Instance (computer science)InformationSocial classMultiplication signSpectrum (functional analysis)Module (mathematics)Vector spaceField (computer science)WordResultantSource codeDistancePattern languageBitStandard deviationVarianceSpectroscopyComputer fileSolid geometryNeuroinformatikAnalytic continuationFile archiverWeb 2.0Address spaceExtension (kinesiology)Software maintenanceFile formatMagnetic stripe cardData loggerVirtual machineInterpreter (computing)Software frameworkMathematicsVirtualizationMehrplatzsystemXML
30:32
CompilerStack (abstract data type)MereologyAreaBitOpen setElectronic mailing listScheduling (computing)Thread (computing)Level (video gaming)Task (computing)DebuggerExt functorSource codeMathematicsCycle (graph theory)Queue (abstract data type)Function (mathematics)Video gameIcosahedronCoroutineFlow separationLibrary (computing)Computer programmingComputer programmingSet (mathematics)Functional (mathematics)Library (computing)Operator (mathematics)Complete metric spaceSystem callCycle (graph theory)Solid geometryEmailSource codeWebsiteElectronic mailing listParameter (computer programming)1 (number)WikiPosition operatorMultiplication signScheduling (computing)Task (computing)NeuroinformatikCalculusWordIndependence (probability theory)Medical imagingInstance (computer science)Cartesian coordinate systemDebuggerScatteringEndliche ModelltheorieQuicksortConnectivity (graph theory)ImplementationExtension (kinesiology)PiPerspective (visual)MereologyPhysical systemPoint (geometry)Service (economics)View (database)Term (mathematics)Right angleVideo gameLogical constantVector spacePattern languageState of matterLatent heatMathematicsHeat transferSensitivity analysisArrow of timeCommunications protocolGame controllerSoftware bugModule (mathematics)Software testingTheory of everythingBitRevision controlComputer fileAdditionBuildingParallel computingBoolean functionXML
37:32
Task (computing)Software bugRegular graphBinary fileExtension (kinesiology)Stack (abstract data type)DebuggerIntrusion detection systemRevision controlCAN busCurve fittingSpecial unitary groupPersonal area networkMetropolitan area networkUniform resource nameComputer cluster3 (number)Execution unitChemical equationSineMaxima and minimaInterior (topology)SummierbarkeitMenu (computing)Tap (transformer)Library (computing)Software testingMalwareCovering spaceImplementationCompilerExplosionNumberSource codeBlock (periodic table)Logical constantInformation privacySubsetScheduling (computing)Library (computing)Computer programmingMultiplication signConnectivity (graph theory)Functional (mathematics)CompilerBranch (computer science)MereologyTask (computing)Physical systemPatch (Unix)Mixture modelScatteringPerspective (visual)Point (geometry)Set (mathematics)Vector spaceRange (statistics)Source codeRepository (publishing)Greatest elementGroup actionForcing (mathematics)Context awarenessMathematicsSoftware maintenanceGraph (mathematics)Tape driveForm (programming)Revision controlQuicksortFrequencyExistenceOrder (biology)Cellular automatonStack (abstract data type)DebuggerGame controllerInstallation artImplementationExploratory data analysisRun time (program lifecycle phase)Visualization (computer graphics)Different (Kate Ryan album)Thread (computing)Software bugFunction (mathematics)Computer animation
Transcript: English(auto-generated)
00:16
Today we want to talk about Stackless, the former name was Stackless Python, I don't
00:22
know how many people know about this project already, it is a rather old one. And in the last couple of months a lot of changes have been made, a lot of enhancements which really make Stackless very usable and a drop-in replacement for CPython, and that's
00:47
mostly the work of my colleagues, and one of them is Anselm Coes who is giving the majority of this talk today. Today I think to do an introduction about what Stackless Python is, and then we get
01:10
to the new things. But please interrupt me when I'm quibbling too much, I will do the same for you.
01:39
So, what is Stackless?
01:51
It has been around since 1998 and had its shadow existence
02:00
behind regular Python, and it is kind of a niche product which tries to do things that normal Python cannot do. So it is called that Stackless is a Python that does not use the C-Stack.
02:21
That's a lie because of course it does use the C-Stack. It does not have problems because of that, because the C-Stack is always built up and removed again, so Stackless means that there is no dependency from the C-Stack.
02:51
And that is the main reason to be able to do task switching and other stuff. So actually Stackless is a Python version that does not keep state on the C-Stack.
03:05
It has some state sometimes, but at certain times where it can perform some context switch, this stack state is removed completely, so it's breathing up and down until something
03:25
else has to be run. So this is theoretically, in an ideal world it would work this way, but in the real world in 90% of all cases it works in this cooperative manner, but not always.
03:47
So Stackless is like C-Python, unless you import the Stackless module there is nothing changed at all, not even the behavior, the creation of recursion level limits and all
04:08
of that, it's all original C-Python. It can do a little bit more than C-Python. So there is Stackless module and you can import the Stackless module and that suddenly
04:23
creates a few new functions with a lot of possibilities. So it looks a little bit like an extension module, but it is no extension module because Stackless Python requires quite a lot of changes to the interpreter.
04:41
This does not change the way how you use it and it does not change the format of pickled things or anything else, but the way the virtual machine is working is different from C-Python and I think Stackless does it the right way and C-Python does not,
05:04
but that's a long fight I will probably lose in the end. So what is it about Stackless? Stackless, you have a little tiny programs, these tiny programs can be switched forth
05:28
and back, you can communicate over channels between these tiny programs, the tiny programs are called tasklets, it's similar to so-called micro-threads, but there are no
05:46
threads at all, a tasklet is just a tiny piece of program that runs a wire and at some point it decides to yield its time slice to someone else and then it continues
06:02
in another place in the program. And that's the difference to C-Python, that's something that was invented for C-Python in 3.3 or 3.4 I think by using yield from constructions or so, Stackless had that since 2002 I think.
06:34
So actually we have tasklets which are a little like coroutines and this can switch
06:41
freely between each other and the ability to do so is the way the interpreter is constructed, which is non-recursive but it's only doing small cores and going back before it switches
07:01
to something else so we have no contention of the C-Stack which in C-Python you have the C-Stack and if you have three nested cores of a Python function you also have three nested cores of C-functions which do this Python function and that's exactly what Stackless
07:26
does not. Okay, here's an example, we have some cooperative multitasking, we import Stackless, we define two functions, a receiving tasklet and a sending tasklet and then we just start
07:52
them. I did some examples just in order to save me from typing because typing is not so well but we can have some examples afterwards.
08:05
So let me skim over this. So when the tasklets are communicating you see some protocol where you see that they are jumping from one context to the other and well.
08:25
Some people might say why don't you just use the greenlet? The greenlet is actually quite famous and very complete and good implementation of the task switching. It does that with some technology from Stackless Python which is called hard switching.
08:50
It does that by slicing the C-Stack into small pieces and really brute force context
09:01
switching so it is quite perfect because the greenlet has been unmaintained for many years and it's always working because it does not know anything about the things it is switching so it is very stable and very major but it has the drawback that
09:25
it's slower than Stackless Python and it has some things that it cannot do. So the technology of the greenlet is quite close to Stackless 2.0 where we only had this
09:42
hard switching grabbing pieces of the stack and moving them around. The soft switching does that in a cooperative manner so the stack is actively unwound and the context switching is built into the interpreter and that is much more work because
10:03
it's harder to maintain, it's also much more efficient and has some other advantages. We'll come to that later. So we might talk about the hard switching but I think maybe not now.
10:27
Hard switching and soft switching is some real difference between Stackless and greenlets. But the real thing actually is with Stackless Python we can pick a program state.
10:46
So we don't have only the ability to switch around like greenlets can do but we can pickle the program state, we can run a program to a certain point then take a snapshot of
11:00
the program and take that snapshot on another machine or tomorrow or whenever in the cloud and continue the program from where it was pickled.
11:22
So I have a little demonstration that takes a simple recursive function just to show how that you have a recursive function that calls itself until a certain level and then winds back and, well, if you run that then you see the function prints one to
11:53
nine then some word and then it goes back, comes out of its recursion.
12:03
And the interesting thing is when we restart that program later on then we can see it continues exactly at the point where the program state was saved and continues to run that part of the execution.
13:05
We have that as a running demo as well and I think we should show it right now or later? Now. Now? Okay. Okay.
13:27
So I have, well, do I need to make this bigger? Is it visible? Yes, it's perfect. Okay, I run the program.
13:41
This is the recursive run and it's a little bit enhanced. The example I worked on that yesterday. Okay, the recursive function goes to a certain point, comes back and then it says, well,
14:02
I was recorded on Darwin. So it was recorded on this platform. I can now run it. It has written its output as a pickle into a task.pickle and I can run the program
14:20
again and give it the pickle as an argument. And you can see here at the point where at the high the program state was written to the pickle and here where we restarted the pickle it came out of the recursion.
14:44
So the stack with all the recursive calls was pickled and was now revived and continued to run. And we can do even more because I will now, it's dangerous because I'm now starting
15:11
Windows and I have prepared a Windows share, let me see if it works, okay, yeah.
15:29
We are now in the same, on the same virtual drive in the virtual parallelist Windows machine and we have the same program here and I can run that, okay.
15:52
So I started the same program on Windows, it returned from the version and tells us
16:02
I was recorded on Darwin but continued on Win32. And it's actually really the same task pickle we recorded, you look at the time stamp, just four minutes from now. And actually we are using this technique in production at large, at important German
16:27
auto manufacturers, automakers to control high performance computing jobs where you start on the desktop of an engineer running Windows and then move a program to an HPC
16:45
cluster running Linux. So that's working well. Okay so we'll do the same thing the other way around and then close the Windows shell because, okay, so I did the same thing here.
17:05
Now I'm stopping the parallelist desktop and I run the same thing on the other side
17:22
and let's see what it tells us now, yeah. I was recorded on Win32 but continued on Darwin. So just so everybody believes that we moved a running program from Mac OS 64 bit to Windows
17:42
32 bit and it still works. Okay.
18:04
Well, it's just a summary, I think about what you already told us. Krinde versus Stackless. So perhaps we skipped this slide. Yeah, I think I said it all right.
18:26
Okay, so the reason why Stackless really makes a difference is, oh, it's still a bug. We have the persistence. We can use persistence, cloud computing, move running programs around, use a different computer,
18:49
use a different operating system, do it in a cloud. The cloud is the only thing that I didn't show right now. We can save snapshots.
19:00
You can also use multiple snapshots and whatever you want. So actually you can do with Stackless everything you can do with regular Python. It's fully compatible to regular C Python and it's even much more fully compatible
19:26
now as it was before. Yes, indeed. We fixed some corner cases where extension modules that didn't adhere to the coding
19:41
standards for Python extension modules didn't work with Stackless and unfortunately there are quite a few and important extension modules of this kind. For instance, PySight. PySight is a very important thing. I'm working with PySight since 2011 and I could not use Stackless Python.
20:01
It was crazy. In spring this year this problem has been solved. Now it runs really well with – yeah, right. Actually I have another thing to show.
20:27
What you see here is a little puzzle game and this puzzle game – is that visible?
20:46
It's on top of Stackless Python. So the old problem has been solved. We can – well, and so on.
21:02
Another little demo is for instance – so we have a little painter demo.
21:30
Some different colors which are painted with different styles and certain rotations.
21:41
So all great things. It's actually stuff for an extra PyQT or PySight talk. I was just so happy that this now really works with Stackless so I had to show that. The last thing – nice embedded dialogues.
22:05
Here we go. This is a projection of a dialogue into an OpenGL perspective and so it's very sophisticated, huge stuff here.
22:20
And you can have that all in Stackless Python now. I think that was about what I wanted to show and say. I might pass it over to you now.
22:42
Okay, so there's also a few things that Stackless can use for – that Christian didn't mention yet. So you can use it as a primitive function Stackless provides, especially as a task in the channels to build control structures for higher level scheduling paradigmas.
23:06
So we can implement for instance C Sharp style async programming or we can implement the Go-less things. Christian could tell something about it.
23:22
I'm not so in this business, I'm more in the pickling and migration of programs. So now we have seen what Stackless is and we have to talk about the Stackless project too. The Stackless project – well, who is it? That's all.
23:41
So we are of course the maintainers but also all Stackless users. So who is using Stackless? Well, there are a few well-known users. Nagare – I hope I pronounced this correctly – web framework is based on Stackless.
24:01
Then CCP Games, the company behind their Eve Online multi-user online game. You probably know it, it has some spacecraft flying around and so very cool graphics. I can show it here, I have it on the machine.
24:22
Well, actually they use Stackless since many years and have built a large part of their infrastructure on Stackless. Then there are a few less known users. Customers of the company I work for, Science and Computing, are using Stackless Pisons on a few thousand systems.
24:47
The systems all together have over 100,000 cores. So that's quite a bit. Well, then there are also unknown users.
25:01
So I recently looked at the access log files of www.stackless.com and I was very surprised to find that we have about 220 downloads of the Windows installer each day and 85 downloads of the source archive.
25:21
So I don't know who is downloading it but obviously someone does it. We also see that 98% of the Windows installer downloads are for Python 2.7 and for the source archive 96% for Python 2.
25:42
So it looks like the production usage of the Python 3 is quite low. So Kirsten already talked about the history and Stackless was formerly known as Stackless Python.
26:00
I will probably say something about it. It's invented by Christian and I think the first version was 1.5, is that correct? Yes, the first was Python 1.5 and it was continuation based and much more complicated.
26:21
So the history is the thing Christian knows best. But this talk is not about ancient times and the history of Stackless Python but about the recent changes. Some more information about the Stackless project. Who is working on it? Well, we are just a few volunteers.
26:43
Christian and then Kristin Waller-Johnson, Richard Q. What's the pronunciation of Richard? Richard Q, yes. And myself and all in all we have, it's less than one full time equivalent.
27:01
We can't do very much. We have a few resources such as Stackless website, stackless.com So you can get Stackless Python and it's a primary address for this project.
27:22
Then we have the documentation, it's now hosted on ReadTheDocs. And that's very fortunate because we can now host the documentation for every version of Stackless. So that's a really good thing. And since a short time we have moved the development environment to Bitbucket and we have the project Stackless Dev Stackless.
27:50
And also I have a project for Stackless as a installer that can be used with the installer pip.
28:01
And I have to say we are really really happy that there is a wonderful infrastructure provided by Bitbucket and ReadTheDocs. Without this infrastructure it wouldn't be possible to maintain such a project. So how can you use Stackless? Well you have to install it obviously.
28:23
Yes, and there are a few options. The simplest and most common way is probably to get the installer from stackless.com. And the installer is available for Windows and for Macintosh OS X.
28:40
So just download it and install it. It's a usual MSR installer but I don't know the format of Mac. Yes, and that's something really great because the installer for OS X I used that the first time now. It just replaced my standard CPython from python.org.
29:01
It continued to run with all installed extensions because it simply swapped out the interpreter so I was very pleased with that. It's a great experience now to have installers. I never used installers but now I'm very keen on that. Sorry. Yes, that's fine.
29:21
And then we have for the Linux people and also for Windows. If you're on Windows and using virtual end for instance, a great way to install Stackless. We made an installer, an umbrella installer that's a Stackless Python here.
29:44
And if you install this umbrella installer with pip or easy install, it detects your system and then in a second stage downloads a pre-compiled package that almost only contains the Python library and the executable.
30:07
And three or four library modules and install them in a way that doesn't hurt your existing Python installation. You get a new command, SL Python, Stackless Python and well, it's working because Stackless is
30:27
almost CPython so we have no problem to implant this new command into an existing installation. Of course in Linux, if you do this for the system Python, you need appropriate access wise, probably you have to be root.
30:50
And finally, you can get the source code and compile it just as you can do it for the regular CPython. And if you need something like a debug build or special installation options, then that's the way to go.
31:06
So, if something doesn't work, that's all final theory but the practice is sometimes different. But first, Stackless is major, yes? For the biggest part, it's just CPython and 2.7 is now really solid and it has many users so usually things work.
31:33
Stackless 3.3 is also good. That's currently the only maintained version of Python 3. We don't maintain 3.2 or we don't release 3.2 anymore.
31:49
May I add that right now we have Stackless Python 2.7.8 which is very complete and working.
32:01
We failed to finish the Stackless 3.4 version and we want to do that on the sprint in the next few days, maybe it works. Actually, my intent is to support Python 3 as much as possible but it's quite some hacking and fixing.
32:24
Yes, there are a few bugs in the era of pick-linkers. That's where we have Stackless specific extensions and also, Python 3.4 got a new version of the pick-link protocol.
32:42
But we're invited to participate in this. Yes, so if something still doesn't work, we have the mailing list and you can always open an issue on our big bucket site and sometimes you might need commercial support.
33:07
Unfortunately, that's a bit of a difficult topic. You can ask Christian, he is probably going to help you if he can and you could negotiate an agreement with Science and Computing.
33:22
But we are more focused on bigger companies so the agreement might be too expensive. But we can provide Stackless support around the world 24 hours a day and sometimes a week if it is necessary.
33:43
I think you had something you wanted to show interactively and we're running out of time. Okay, fine. Yes, good. I will just go to the recent at one month. We switched, I already told it, we improved Stackless a bit. Low-level test methods are now much more complete.
34:04
Importance of custom and inter-switch scheduling is working more stable. We're about to have a better compatibility with CPython and the documentation has been updated and we got a better debugger support recently. So that's very important and a few other bug fixes.
34:22
We also did something that didn't work out. The documentation, it's now on ReadTheDocs and that's the most important point. And it is the actual CPython documentation and a Stackless specific addendum and additional chapter. And this chapter is now also complete and correct. It wasn't some time ago.
34:47
And we also adhere to the Python Software Foundation trademark uses policy for the trademark Python. And that's also the reason we changed the name because as PSF says you should not use the name Python alone.
35:08
So the source code also contains a well-maintained changelog file now and our wiki pages still need some love.
35:24
I probably will go over the technical details very quick. We have a more complete set of low-level methods and you can find that in the documentation it's usually not so interesting. But we have here an image and it shows you that we have added a state chart of a task set.
35:47
And the task set is created, it's not alive and then it's alive and scheduled eventually. And you see we have added a few red arrows that weren't available previously so you are now much more flexible.
36:02
We have an enhanced functionality in the schedulers. It's not long necessary to run the scheduler from the main tasklet. You can run it from every other tasklet or from within a library or something like that.
36:22
Christian value Johnson implemented it and he was very excited about it. But it's fairly new and I don't know any application of this new functionality yet. Custom scheduling is now possible using the new method tasklet switch. It simply transfers the control from the caller to the argument of the tasklet switch function.
36:47
And that's independent from the scheduler and it's an atomic operation so you can build your own scheduling based on it. There are known applications, for instance we have in Stackless Libs that's a
37:04
library collection of functions you could use for your programs with Stackless Yarn. And it's not really necessary to use them now but there's a module called Async and it's C Sharp style asynchronous programming.
37:21
And it also provides some Python features based on tasklets. Can you quickly show your interactive settings? So let's move on. Mult inter-stretch scheduling is probably not so interesting.
37:44
Subclassing also. We have bug fixes already. Christian showed you the PySight working. And we have better debugger support now. Because we added some hooks for debuggers and we got two new EDAs working.
38:05
The wing-ware debugger supports Stackless since ever. But now PyDef and also PyCharm started supporting Stackless.
38:21
Here we are. So I will show the PyDef debugger. We have a very, very simple program. It's a demonstration program from the Stackless source. And it shows you how to implement a move text using channels and tasklets.
38:41
That's really not important. If you run this program, simply run it. Yes, it has some output. We have here this renamed tasklets.
39:00
The tasklet function is this function f. It acquires a lot of the move text. Then it schedules. It passes the control back to the scheduler. And then it releases the move text again. And if you wanted to see the expected output.
39:21
So run interleaved into each other. So let's debug it. I already set a breakpoint here. And we debug it as a Python run. PyDef switches to the Python debug perspective. And we are here.
39:41
So we step over. That's the creation of the tasklets. Debug is false. So now let's step into. And here you see actually the threads or rain stacks that are known to the debugger. Now I switch here and we see how we got.
40:02
Still the main thread is now f. But we got a post main tasklet of main thread. And if you look here, that's the run. That was the main tasklet. So now it's a different tasklet running. So let's stop. This one. We will get the lock.
40:20
That's not surprising because we are the first tasklet. So. Hey. We are back here. But now if we look. Oh, there's another tasklet. So we have now three. And you see that's a scheduled task that ticks. It was a task that we have seen previously. And it's sitting here in the schedule.
40:44
And waiting to be reactivated. And again. But now if we look. Go into lock here.
41:00
We will see here. It blocks. Yes. Now we have the third tasklet. So. You see the debugger perfectly supports the switching between the task and the switching between the context of the execution. And that's important. Without this support you wouldn't be able to debug this reasonably.
41:22
So. I just continue it. I'm done with it now. And. I think we have. Very. Few things still to say.
41:42
Future goals. In the immediate future we would like to find additional volunteers to help us. Let's take us 3.4.1. And. We also would like to install the pip installer to cover more versions. Especially person 3.
42:01
Later yes. We will probably still need additional opportunities. And. I also would like to update the stackless implementation that is contained in PyPy. Yes that's also something we could try on a sprint to work on. Yes. Because that's a few changes and it's quite a mixture of stackless programming with the PyPy guys may be interesting.
42:29
Well there are some things we also have done that didn't work out. We had problems with the Visual Studio install compiler with the old Visual Studio 2008.
42:46
And. Then we made a patch to build Python 2.7 with the Visual Studio 2010. If you don't change the name of the Python DLLs then you can get serious problems.
43:04
Because if the DLL was compiled with a different compiler it uses a different C runtime library and this can cause all sorts of problems. In the end we currently can't publish it because we have no resources.
43:22
So it's a possible violation of the trademark Python and so it's still in our repository. Well that's the question. Do we want to support non-existent Python 2.8 in the form of a stackless 2.8 which grabs all the things that are missing from C Python?
43:52
Or do we not want to do that? I know there are a couple of people who think it's a great idea and other people are there who think it's a very bad idea.
44:03
So we are really undecided and wanted to leave that to hear your opinions about. Should we do something about that? Surely we can't do it without participation and probably it would need some funding.
44:24
So that's all and any questions so far?