On 8/3/07, Martin Ahnelöv wrote:

...

loops, but wanted them to run "side-by-side", but looping at different speeds, how would you do it?

Yes, you can do that. FYI, it's called threading in traditional

programming languages and is often a pain in the ass, but since chuck isn't a traditional language it's called sporking and is as simple as running a chuck file.

That's right!

You can also do sporking in the code, but I haven't looked at that enough - it's in the help pages, though.

That's also quite simple. You can run threads (we call them shreds) next to the main one. You define those as functions and you "spork" the function. ======================================= //let's define a function fun void paralel() { while(true) { //this will loop forever <<<"beep">>>; second => now; } } //let's try sporking it spork ~ paralel(); //now we write the main loop that will run next to it while(true) { //this will also loop forever <<<"boop">>>; .75::second => now; } //anything that you would write here will never get executed because the program will always be stuck in that last loop. you could still define functions here though. ----------------------------- See? not at all hard. You can run as many functions next to eachother as you like, they can all be different or they could all be the same. If they are all the same you only need to define it once and can spork it as many times as you'd like (untill the cpu gives up! Notice that they can all run at different speeds if you'd like, in my example above one loops in .75 seconds while the other takes a whole second so they will drift in and out of phase. Cheers, Kas.

All, That was very well explained, folks. Personally, I think that the area of the manual describing concurrency in Chuck is a little bit thin. It would really help people new to Chuck (like myself) to have a series of examples of what can be done with the concurrency features, syncing, & c. It's one of Chuck's most important and powerful features. Maybe we could add a little section of the Wiki for concurrency examples? Chuck/Programs/Concurrency or something like that. I wish I had some examples of sporked shreds sharing data with each other, for instance. Just thinking out loud... Mike On 8/3/07, Martin Ahnelöv wrote:

...

That's also quite simple. You can run threads (we call them shreds) next to the main one. You define those as functions and you "spork" the function. ======================================= //let's define a function fun void paralel() { while(true) { //this will loop forever <<<"beep">>>; second => now; } }

//let's try sporking it spork ~ paralel();

//now we write the main loop that will run next to it while(true) { //this will also loop forever <<<"boop">>>; .75::second => now; }

//anything that you would write here will never get executed because the program will always be stuck in that last loop. you could still define functions here though.

-----------------------------

See? not at all hard. You can run as many functions next to eachother as you like, they can all be different or they could all be the same. If they are all the same you only need to define it once and can spork it as many times as you'd like (untill the cpu gives up! Notice that they can all run at different speeds if you'd like, in my example above one loops in .75 seconds while the other takes a whole second so they will drift in and out of phase.

Cool! Thanks!

_______________________________________________ chuck-users mailing list chuck-users@lists.cs.princeton.edu https://lists.cs.princeton.edu/mailman/listinfo/chuck-users

-- http://shadowofaculture.blogspot.com

spork ~ writer(); spork ~ reader();

By the way Kassen, what do we call the ~-symbol in chuck? (I know it's a tilde, but does it have a nifty name like Sporker or something like that, since => is named Chuck and not Arrow) Gasten

what do we call the ~-symbol in chuck? (I know it's a tilde, but does it have a nifty name like Sporker or something like that, since => is named Chuck and not Arrow)

This is a very good question (thanks Kassen for the redirect though I believe he is as much of an authority on spork/chuck-related issues as anyone. FYI: I do love sea salt, especially on deep-fried triple cheeseburgers - don't bother tossing those over your shoulder, unless of course I am standing directly behind you). Okay, for those who may be wondering about its function/origin, the ~ after the spork really serves no practical purpose that we are aware of (since sporking is such a fundamental operation in chuck, we thought it deserves its own syntactic sugar/wasabi/etc, and so the ~ was added to make the spork more prominent in code - quite possibly a horrible idea except it might be extended to other operators for different flavors of spork in the future). Anyway, as for a name for the ~, we ain't thought much about it. Let's make one up right here! How about: the sporkilator operator? shred assimilation facilitator? spork-to-shred warp vector? the twisty noodle of spork? spork syntax compensator? sporker? (short and sweet, good job Martin) spork linguini? Um, other suggestions? Thoughts? Best, Ge! On Aug 3, 2007, at 4:06 PM, Kassen wrote:

On 8/3/07, Martin Ahnelöv wrote:

...

spork ~ writer(); spork ~ reader();

By the way Kassen, what do we call the ~-symbol in chuck? (I know it's a tilde, but does it have a nifty name like Sporker or something like that, since => is named Chuck and not Arrow)

This is such a advanced subject that I dare not speak on it. I porpose that we all chant in the direction of Princeton while chucking ceremonial salt over our shoulder and hope Ge will speak on this. I believe Ge is font of eating so using real sea salt or celery salt might speed up the process.

;¬) Kas. _______________________________________________ chuck-users mailing list chuck-users@lists.cs.princeton.edu https://lists.cs.princeton.edu/mailman/listinfo/chuck-users

On 8/7/07, Ge Wang wrote:

This is a very good question (thanks Kassen for the redirect though I believe he is as much of an authority on spork/chuck-related issues as anyone.

Oh, thank you, but I don't think it would be good for me to go make up new naming conventions independantly. Before you know it there would be one naming convention on the forum, one on the list, various classrooms would have their own... There would be Southern ChucKish, Northern ChucKish, nobody would understand anyone anymore untill somebody designed a "ChucKish (simplified)" font. FYI: I do love sea salt, especially on deep-fried triple cheeseburgers -

don't bother tossing those over your shoulder, unless of course I am standing directly behind you).

Ah, triple cheesburgers! A important element in the fat-rich diet! I'm sadened to have to report that Dutch fastfood places have a rather unfortunate inclination towards being reasonable and so triples are hard to come by.... unless of cource one makes them onself. Um, other suggestions? Thoughts?

I was thinking about "you". I'll explain, this would make the pronounciation of the whole line like; "spork you reader" (brackets are silent) This could be taken as a reference to Pokemon with it's "I choose you" when fielding Pokemon which is fitting since we are realy summoning functions to do our bidding and "Frankenstein", "Dracula" and "quintesson" already reference pop-culture. We would maintain that that is what it means and that there is no link at all to "spork" somehow seeming like a naughty word. ;¬) Kas.

On 8/3/07, mike clemow wrote:

Okay, I'm having a bit of an "ah-ha!" moment here.

Great! I'm having coffee here :¬). It makes sense to

me when described like this. If I understand this process correctly, data-sharing aside, this is functionally equivalent to using the "chuck --loop" invocation to start the VM and sporking shreds with "chuck + this.ck" and "chuck + that.ck." Or is that more like Machine.add()?

Actually, Machine.add() and "chuck +" are basically equivalent (aside from returning a Id in the .add() case). Sporking also results in new code being run in a new shred but it's different in that it shares the name-space of the parent. Also; if a shred sporks a new shred and then "dies" all it's sporked childeren will be "killed" too, shreds it has added using Machine.add() won't die in that case. According the manual, sporking a shred will return a reference to the

shred, while using Machine.add() will return the ID. Can one pass messages between shreds in the VM like in Erlang processes using this information? Using a shared variables to store state information might get kind of hairy in big programs.

Yes, you definately could. You could, for example use events, extended to have a id as a parameter and have sporked shreds listen for that event, then compare that "id parameter" to it's own. I sugest you read the manual section on events, events are cool; quite simple, very powerfull and they can be extended. If that's not enough you might need to look into classes. Classes can also spork their own shreds upon construction and in that case you can use the class instance's name. I hope that answers your question, if you are after something more specific we can look into that as well. Happy to have been able to contribute to your "Ah-ha!", Kas.

this aspect is great!! i think i"ll do a lot of function things going on in the near future ah!! i cannot help myself from becoming greedy but if i have SinOsc s1 => Gain g1 => dac; somewhere(where?) related to the main while could the s1.freq() be used for calculation in defining the function? looking for a global something might be a better solution? i have some sort of fake indian music structure in mind making a note "sa" should have function "ri"~"ni" floating around them sub-note "ri"~"ni" should own jointly "sa"'s freq in that way i think we can make music in a .ck = harmony = melody = raga way blablabla On 8/3/07, Kassen wrote:

On 8/3/07, Martin Ahnelöv wrote:

...

...

loops, but wanted them to run "side-by-side", but looping at different speeds, how would you do it?

...

Yes, you can do that. FYI, it's called threading in traditional programming languages and is often a pain in the ass, but since chuck isn't a traditional language it's called sporking and is as simple as running a chuck file.

That's right!

...

You can also do sporking in the code, but I haven't looked at that enough - it's in the help pages, though.

That's also quite simple. You can run threads (we call them shreds) next to the main one. You define those as functions and you "spork" the function. ======================================= //let's define a function fun void paralel() { while(true) { //this will loop forever <<<"beep">>>; second => now; } }

//let's try sporking it spork ~ paralel();

//now we write the main loop that will run next to it while(true) { //this will also loop forever <<<"boop">>>; .75::second => now; }

//anything that you would write here will never get executed because the program will always be stuck in that last loop. you could still define functions here though.

-----------------------------

See? not at all hard. You can run as many functions next to eachother as you like, they can all be different or they could all be the same. If they are all the same you only need to define it once and can spork it as many times as you'd like (untill the cpu gives up! Notice that they can all run at different speeds if you'd like, in my example above one loops in .75 seconds while the other takes a whole second so they will drift in and out of phase.

Cheers, Kas.

_______________________________________________ chuck-users mailing list chuck-users@lists.cs.princeton.edu https://lists.cs.princeton.edu/mailman/listinfo/chuck-users

-- 2g http://micro.ispretty.com