--> You are now talking on #python-csp

<snim2> aha!

<FabianEP> Hello Sarah

--> You are now talking on #python-csp

<snim2> Just pushing a fix for the tokenring benchmark now...

Russel has kindly agreed to help people battling with MacOS issues!

<-- FabianEP has quit (Ping timeout: 240 seconds)

<yrvyzz> welcome back snim :)

--> FabianEP (~fabian@245.adsl2.freecom.net) has joined #python-csp

<FabianEP> Where to?

google?

I can help with any hg/mercurial issues

There are no new changes on google for me

http://code.google.com/p/python-csp/issues/list

<yrvyzz> snim: Have you uploaded your talk anywhere?

<-- FabianEP has quit (Ping timeout: 246 seconds)

--> FabianEP (~fabian@245.adsl2.freecom.net) has joined #python-csp

<-- simon___ has quit (Read error: Connection timed out)

wout has quit (Read error: Connection timed out)

--> FabianEP_ (~fabian@245.adsl2.freecom.net) has joined #python-csp

wout (~wtankink@245.adsl2.freecom.net) has joined #python-csp

simon___ (~simon@245.adsl2.freecom.net) has joined #python-csp

You are now talking on #python-csp

<-- snim2 has quit (Ping timeout: 260 seconds)

<FabianEP> I found my destiny

I will work with the tutorial

<yrvyzz> Fabian :-)

<-- FabianEP_ has quit (Ping timeout: 240 seconds)

--> FabianEP_ (~fabian@245.adsl2.freecom.net) has joined #python-csp

You are now talking on #python-csp

<snim2> yrvyzz: haven't uploaded talk yet but will sort it now!

<-- yrvyzz has quit (Ping timeout: 240 seconds)

--> Neo-- (~neo@245.adsl2.freecom.net) has joined #python-csp

yrvyzz (~schwa@245.adsl2.freecom.net) has joined #python-csp

<snim2> Talk slides can now be found here: http://wiki.europython.eu/Talks/Bringing%20Occam%20To%20Python

<yrvyzz> snim: I just had switched to IRC to ask :)

<snim2> :)

--> You are now talking on #python-csp

MS- (~kamaelian@thwackety.plus.com) has joined #python-csp

<MS-> Hello all.

* MS- looking at writing a demuxer using pycsp.

<FabianEP_> Hi

Who's MS-?

<MS-> MS- == Michael Sparks

<FabianEP_> Raie your hand?

<MS-> (I'm over here)

(100 miles away)

:)

<FabianEP_> Oh

<MS-> I had to go back to work, but it's lunchtime, so I thought I'd drop in

and have a play

<FabianEP_> Cool

<snim2> Hi Michael

<FabianEP_> You know that this is the sprint at Europython?

<MS-> snim2: Hiya

<MS-> Yep

<FabianEP_> Great

<MS-> I would've wanted to be there in person, but had to go home

<snim2> What's a demuxer?

<FabianEP_> There is something called Delta2 of which we just find out, that we could call it DeMux

But decided for Splitter

<-- yrvyzz has quit (Ping timeout: 240 seconds)

<MS-> Demultiplexer - used in taking single source, and distributing to multiple outputs, which consume data at different speed

In particular, I'm thinking of a DVB or similer demuxer

<snim2> Ah, the at different speeds bit makes it different from Fabian's splitter

<FabianEP_> :) My ;)

--> yrvyzz (~schwa@245.adsl2.freecom.net) has joined #python-csp

<FabianEP_> Sounds great. Let's make a splitter for different consumption speed, so I will not rename Delt2

<MS-> We have splitters of lots of kinds in kam, but a demuxer is an interesting one, because you add and subtract producers and consumers of data often

I kinda view it as a kata for this sort of thing

<snim2> You can rename Delta2, Michael's one will be different

MS: sounds interesting!

<FabianEP_> Will a new consumer start from the begining of the input?

<MS-> My purpose is to see whether it's valid to have an (Axon.PyCSPComponent) in addition to others

<FabianEP_> You'll need a buffer, possibly very large

<snim2> MS: wow, that would be interesting. Different sorts of channels mixing together

<MS-> Indeed - we have threaded & process based components

so we already have multiple channel types, so it should be doable

Whether it's sensible is another :)

Should be interesting either way :)

(DVB data is around 24Mbit/s BTW, and has real time constraints)

* MS- goes off to read for a bit

<-- joe202 has quit (Ping timeout: 240 seconds)

<MS-> oh, snim2 I didn't get a chance to chat properly, but you may find our *incredibly simple* STM implementation useful for sharing state more slowly than channels

<snim2> MS: more slowly than channels?! I know the Haskell library for csp (Neil Brown's CHP) is built on STM. It's interesting, but I think pretty low level. Does it work well for K?

<MS-> It was written to help with publishing & finding other things in a system cleanly

Also, critique welcome :) http://www.kamaelia.org/STM.html

It's packaged up seperately from everything else here: http://code.google.com/p/kamaelia/source/browse/trunk/Code/Python/Bindings/STM/

Well, I use a biological metaphor. Channels are like the neural system, whereas STM is more like the hormonal

One is fast acting and localised, the other is more systemic information.

Also think unix pipes vs unix environment. (eg $EDITOR)

It's very useful in that context

(ie rarely used, but nice for safety)

--> Neo--- (~urbans@245.adsl2.freecom.net) has joined #python-csp

<MS-> I don't use it as an execution model

<-- FabianEP_ has quit (Ping timeout: 240 seconds)

--> FabianEP_ (~fabian@245.adsl2.freecom.net) has joined #python-csp

<simon___> Interesting, cspthread works on Mac python 2.5, while cspprocess requires 2.6.

<yrvyzz> simon: The multithreading library has been added in Python 2.6

--> RichardTaylor (~RichardTa@245.adsl2.freecom.net) has joined #python-csp

<snim2> I think I would be hormonal if I was using STM!

<yrvyzz> simon: and the csp process stuff is based on that library

<-- wout has quit (Read error: Connection timed out)

<yrvyzz> (I suppose at least :) )

<snim2> 2.6 is needed for multiprocessing or processing, depending on how it's named, I think, but it usually comes as standard in 2.6?

<MS-> snim2: heh. Indeed. I hadn't though of that :)

--> wout (~wtankink@245.adsl2.freecom.net) has joined #python-csp

<yrvyzz> snim: yes, the multiprocessing library was added in Python 2.6

<MS-> You can download it seperately though

<-- RichardTaylor has quit (Ping timeout: 240 seconds)

<snim2> it's called python-multiprocessing on google code

<-- yrvyzz has quit (Ping timeout: 276 seconds)

--> yrvyzz (~schwa@245.adsl2.freecom.net) has joined #python-csp

<simon___> If multi processing is 2.6 or later, the examples should either user threads, or be marked as 2.6+.

<-- simon___ has quit (Read error: No route to host)

<snim2> simon__: Thanks, we should add this to the Issues list

--> wout_ (~wtankink@245.adsl2.freecom.net) has joined #python-csp

<-- yrvyzz has quit (Ping timeout: 240 seconds)

wout has quit (Ping timeout: 265 seconds)

--- wout_ is now known as wout

--> yrvyzz (~schwa@245.adsl2.freecom.net) has joined #python-csp

<-- Neo--- has quit (Read error: Connection timed out)

FabianEP_ has quit (Ping timeout: 258 seconds)

--> Neo--- (~urbans@245.adsl2.freecom.net) has joined #python-csp

FabianEP_ (~fabian@245.adsl2.freecom.net) has joined #python-csp

<-- Neo-- has quit (Read error: Connection timed out)

--> Neo-- (~neo@245.adsl2.freecom.net) has joined #python-csp

joe202 (~joe@245.adsl2.freecom.net) has joined #python-csp

<yrvyzz> snim: I got it to work :-)

<-- Neo--- has quit (Read error: Connection timed out)

--> Neo--- (~urbans@245.adsl2.freecom.net) has joined #python-csp

<-- FabianEP_ has quit (Ping timeout: 264 seconds)

yrvyzz has quit (Remote host closed the connection)

--> yrvyzz (~schwa@245.adsl2.freecom.net) has joined #python-csp

FabianEP_ (~fabian@245.adsl2.freecom.net) has joined #python-csp

<snim2> yrvyzz: Ace! Fantastic news

<-- wout has quit (Read error: Connection timed out)

--> wout (~wtankink@245.adsl2.freecom.net) has joined #python-csp

<-- yrvyzz has quit (Ping timeout: 248 seconds)

--> yrvyzz (~schwa@245.adsl2.freecom.net) has joined #python-csp

RichardTaylor (~RichardTa@245.adsl2.freecom.net) has joined #python-csp

<FabianEP_> Hello

I'm waving at you

<RichardTaylor> hi

--- FabianEP_ is now known as FabianKreutz

--> simon___ (~simon@245.adsl2.freecom.net) has joined #python-csp

<yrvyzz> snim: :-) I entered a ticket/issue for the unittests and start working on them.

<-- RichardTaylor has quit (Ping timeout: 258 seconds)

--> russel (~russel@245.adsl2.freecom.net) has joined #python-csp

<yrvyzz> What about changing csp.cspprocess to csp.process (and the thread variant correspondingly) to reduce naming redundancy?

<-- russel has quit (Ping timeout: 246 seconds)

<yrvyzz> I thought I'd work on test_forever.py first because it's fairly short. When I run the original versions, it spits out a lot of numbers. Is that the expected behavior? (I want to make sure the tests work as expected _before_ I convert them.)

<-- FabianKreutz has quit (Ping timeout: 276 seconds)

--> FabianKreutz (~fabian@245.adsl2.freecom.net) has joined #python-csp

<Neo--> yrvyzz, as far as I can see thats normal since there is an infinite loop (while True)

<FabianKreutz> Do all tests succeed for others?

<-- yrvyzz has quit (Remote host closed the connection)

FabianKreutz has quit (Remote host closed the connection)

--> yrvyzz (~schwa@245.adsl2.freecom.net) has joined #python-csp

FabianKreutz (~fabian@245.adsl2.freecom.net) has joined #python-csp

<-- Neo--- has quit (Read error: Connection timed out)

--> Neo--- (~urbans@245.adsl2.freecom.net) has joined #python-csp

<-- simon___ has quit (Read error: No route to host)

--> russel (~russel@245.adsl2.freecom.net) has joined #python-csp

simon___ (~simon@245.adsl2.freecom.net) has joined #python-csp

<snim2> yrvyzz yes, I think that is the right behaviour

<-- FabianKreutz has quit (Ping timeout: 252 seconds)

<snim2> Re. naming consistency, yes, we need to sort something before pushing to PyPI but it's going to be a big change

--> FabianKreutz (~fabian@245.adsl2.freecom.net) has joined #python-csp

<-- russel has quit (Ping timeout: 260 seconds)

<MS-> It's wierd going back and looking at blocking channels. Reminds me why we don't use them. A non blocking channel is equivalent to a channel & a buffer process after all.

<FabianKreutz> yes

<yrvyzz> I think the renaming should be done "outside" the sprint, because it would disturb all the coding now.

<FabianKreutz> Of course all renaming would retain backwards-compatibility

with deprec-warning though

But hey, I'm not doing it

Also, it can be inside the sprint, but in my own repo :)

You don't need to pull my changes...

<yrvyzz> Do we have a common expression or word for "process" and "thread". Having a common word would ease writing documention.

<FabianKreutz> But I still have now the multiprocessing problem

<yrvyzz> Fabian: I'm pulling from time to time.

(from your repo)

<snim2> CSPProcess is the base object type?

<-- FabianKreutz has quit (Ping timeout: 248 seconds)

--> russel (~russel@245.adsl2.freecom.net) has joined #python-csp

<-- simon___ has quit (Read error: Connection timed out)

--> simon___ (~simon@245.adsl2.freecom.net) has joined #python-csp

<-- russel has quit (Ping timeout: 260 seconds)

<MS-> yrvyzz: "Do we have a common expression or word for "process" and "thread". " I tend to say "concurrent thing" since I generally mean process, thread or co-routine. It's not very academic or clear though :)

I'd also welcome a better word :)

People tend to also use words like task and activity in varying OSs when they're trying to generalise the idea

IIRC Tripos used the word Task

<-- yrvyzz has quit (Ping timeout: 264 seconds)

simon___ has quit (Quit: simon___)

--> yrvyzz (~schwa@245.adsl2.freecom.net) has joined #python-csp

FabianKreutz (~fabian@245.adsl2.freecom.net) has joined #python-csp

<yrvyzz> snim: I can use that for the moment but we should see if we can come up with a more abstract term. It would be nice if it was immediately understandable, but even if not it would help writing documentation.

I was inclined to use "model" (like in process/thread model), but I'd be glad if we could find something less abstract, i. e. more meaningful.

<-- Neo-- has quit (Read error: Connection timed out)

--> Neo-- (~neo@245.adsl2.freecom.net) has joined #python-csp

<snim2> yrvyzz: some people might use "tasks". I'm not sure what's best though

<MS-> We should pick the word process in someone else's language since we've exhausted english. :)

<-- Neo--- has quit (Read error: Connection timed out)

--> Neo--- (~urbans@245.adsl2.freecom.net) has joined #python-csp

<-- FabianKreutz has quit (Ping timeout: 265 seconds)

--> FabianKreutz (~fabian@245.adsl2.freecom.net) has joined #python-csp

<-- joe202 has quit (Quit: Ex-Chat)

yrvyzz has quit (Ping timeout: 248 seconds)

--> yrvyzz (~schwa@245.adsl2.freecom.net) has joined #python-csp

russel (~russel@245.adsl2.freecom.net) has joined #python-csp

<-- Neo--- has quit (Read error: Connection reset by peer)

<yrvyzz> MS *lol*

<MS-> yrvyzz: Why not? Television wasn't an english word either :)

--> Neo--- (~urbans@245.adsl2.freecom.net) has joined #python-csp

<-- russel has quit (Ping timeout: 260 seconds)

<MS-> If I'm trying to be more formal than "concurrent things" I'll say "logical processes" - to try and make it clear that I don't mean a process.

But it's not great

<snim2> I like the idea of having Process from some other language, P and V (for semaphores) is pretty amusing :)

BTW Could people committing code please add their names to __credits__ or __author__ metadata for modules? Thanks!

<yrvyzz> MS: I think it's possible to use a word which only vaguely expresses what we mean. But we should make sure we always use _this_ word for the intended meaning.

<-- FabianKreutz has quit (Ping timeout: 246 seconds)

<yrvyzz> MS: "logical process" is a bit too long

I mean, maybe a bit too long to use it frequently in docstrings

--> FabianKreutz (~fabian@245.adsl2.freecom.net) has joined #python-csp

<yrvyzz> I must admit "Xftywe" would be short, but it has rather little mnemonic value ;-)

So this rules it out. :)

<snim2> Maybe we should choose something from the Python Sketches. NorweigenBlue?

<-- wout has quit (Read error: Connection timed out)

--> wout (~wtankink@245.adsl2.freecom.net) has joined #python-csp

russel (~russel@245.adsl2.freecom.net) has joined #python-csp

<-- FabianKreutz has quit (Ping timeout: 240 seconds)

yrvyzz has quit (Remote host closed the connection)

--> yrvyzz (~schwa@245.adsl2.freecom.net) has joined #python-csp

FabianKreutz (~fabian@245.adsl2.freecom.net) has joined #python-csp

<-- russel has quit (Ping timeout: 240 seconds)

<MS-> hehehe

Oh, I am now so tempted.

I've had a rather awful work day, and a NorweigenBlue is exactly what I needed

thanks :-)

<snim2> You':-)

bah, I mean You're Welcome!

<MS-> Thing is, is a NorweigenBlue in an uninterruptable D state merely resting or dead ?

<-- yrvyzz has quit (Ping timeout: 246 seconds)

<snim2> I poisoned channel is an ex channel, it has ceased to be.

<-- FabianKreutz has quit (Ping timeout: 248 seconds)

<MS-> :)

lol actually :-)

--> yrvyzz (~schwa@245.adsl2.freecom.net) has joined #python-csp

FabianKreutz (~fabian@245.adsl2.freecom.net) has joined #python-csp

<-- wout has quit (Quit: wout)

FabianKreutz has quit (Quit: leaving)

--> You are now talking on #python-csp

--- anthony.freenode.net sets mode +n #python-csp

anthony.freenode.net sets mode +s #python-csp

<snim2> snim2

hi guys, running late today but will be there soon -- sorry!

--- Disconnected (Connection timed out).

--> You are now talking on #python-csp

HippySurfer (~HippySurf@82-68-127-150.dsl.in-addr.zen.co.uk) has joined #python-csp

<snim2> Hi Richard

<HippySurfer> Hi

I have been reading my unix programming text books

I think that there is a strategy to use System V message queue to implement the channels

they have a number of advantages over using shared memory

<snim2> Cool, is that the same as the new POSIX message queues?

<HippySurfer> hmm, not sure

the messages are typed so it is possible to separate the real messages from the control message e.g. poison

because you are not using file descriptors it should also be possible to pass channels between processes, not sure if this is a good thing but it can be done.

<snim2> oh wow, that is a very good thing to have mobility, that would be brilliant

<HippySurfer> Still thinking about how to use semphore sets to avoid the busy wait cycles, but I think there is a strategy there somewhere.

<snim2> thanks Richard :)

<HippySurfer> is there a good decription of the channel/guard semantics somewhere? Something that walks through the order of set/wait for semaphore, readlock, writelock etc. that happens in the channel? It would be good to check that my understanding is correct as I think through the implementation options.

<snim2> er, there isn't a great document on it, sorry. The algorithm is essentially a rendezvous.

A writing process signals its intention to read by releasing the _available semaphore, and the reading process blocks on that

then when the writing process has written something to the pipe, it blocks on the _taken semaphore, which the reading process releases once it has finished reading from the pipe

Both of these are wrapped with a read-lock / write-lock to prevent multiple readers/writers from interfering from one another

<HippySurfer> OK, i think that using the message queue might eliminate the need for the _taken semaphore at least because it is possible to use the queues in a synchronous mode. I will look into it further. Enjoy the rest of the sprint.

<snim2> thanks for all your help Richard!

* Loaded log from Sat Jul 24 11:16:40 2010

--> You are now talking on #python-csp

<-- yrvyzz has quit (Quit: leaving)

--> Neo--- (~urbans@245.adsl2.freecom.net) has joined #python-csp

<Neo---> snim2, an example like this for multiple channels or did you have something else in mind? http://pastebin.com/2icHD2Lz

<snim2> Looks ace to me! Did I give you commit access to the Google repo?

<Neo---> snim2, I don't think so

<Neo---> you gave me access to wiki pages

if that also includes google repo...

<snim2> It should do...

it's all the same stuff. When you use your "password" you need to use the special password that Google creates for you on Google code

See Source > Checkout on the website

<Neo---> ah

ok

<-- wout has quit (Quit: wout)