John,

Thanks for the nice note! I'm glad if it came across comprehensibly.

I think that CALL FORM and CALL WORKER are fantastic commands and really
like them. So I used them to build a Publish/Subscribe system in 4D. It
really makes it easy to reuse form widgets, add new windows into your UI,
log events...very nice stuff.

While the CALL FORM/CALL WORKER calls are hidden away in the component (the
source is there for you), there are some discussions on the commands in the
presentation. I approach them from a different history and perspective than
4D does. That's why I don't think their 'about workers' page is at all
useful. Although the basic command reference pages are top-notch. You'll
hear about that in the presentation.

Thanks to Brent for hosting the meeting, it's a great resource.

And thanks again to Thomas Maul for his presentation a year ago to the
group on CALL FORM/CALL WORKER:

4DMethod #18 | Messaging with 4D v16, Thomas Maul
https://www.youtube.com/watch?v=eEjrHR2BelE

I think Thomas starts around 45 minutes in? There are a few AV glitches
first and then Thomas. Perhaps Brent or someone can post the minute marker?
Anyway, I *strongly* recommend that anyone digging into CALL FORM and CALL
WORKER should do this:

-- Watch Thomas' presentation.
-- Spend +- and hour in a scratch database playing with the commands and
getting what and how they work.
-- Watch Thomas' presentation again.

It's excellent and technically fully on the mark.

Once you've bashed around a bit and tried the commands, if you've run into
trouble...there's a next step. 4D's docs talk about a "queue", describe the
commands as "asynchronous" and put a lot of emphasis on pre-emptive
(thread-safe) processes. Well, do everything you can to ignore *all* of
that. That stuff all makes sense if you're 4D and if you're talking about
the stories that lead to these features. They're nearly irrelevant from out
point of view. What you really need to understand completely to grasp these
commands is that they're variants on EXECUTE. You need to really know

     Where is the code executing?
     When is the code executing?

If you can always answer those questions, you've mastered these commands.
At that point, you can work out in your head design that take advantage of
them and are easy to use. Always keep in mind that a 4D process
(cooperative or not) is a *single* thread of control. Therefore, anything
that blocks or occupies the thread blocks pending lines of code. The
"messages" in the "queue" are EXECUTE statements that are run in that
thread of control (process) only when everything else is done. There are no
asynchronous interrupts here, it's not like that. There's no discrete queue
that we can poll or inspect here, it's not like that. And, again, this has
nothing at all to do with pre-emptive mode. You *can* use these commands in
a thread-safe context, but they're not required. In fact, you can launch a
thread-safe process using New process and leave workers out of it complete.
Note that we didn't have time to talk about pre-emptive mode tonight, but
Brent or someone may do a presentation on it later, who knows?

Regarding the diagrams from the presentation, I'll glue something together
and send them to Brent for posting.
**********************************************************************
4D Internet Users Group (4D iNUG)
FAQ:  http://lists.4d.com/faqnug.html
Archive:  http://lists.4d.com/archives.html
Options: http://lists.4d.com/mailman/options/4d_tech
Unsub:  mailto:[email protected]
**********************************************************************

Reply via email to