I am using Dynamic and DynamicModule to display graphics/statistics generated from a long-running set of parallel tasks. The data to display is passed from the workers to the main kernel via a SharedFunction (which handles any of the concurrency issues), and then copied over from the SharedFunction variable to a local (on the FrontEnd, actually) variable that is then used to generate the graphics and statistics.

The copying from the SharedFunction variable to the local/FE variable happens within the Dynamic 'loop'.

The problem is that of course if the Dynamic object moves off the screen, then all of the copying from the SharedFunction variable to the local/FE variable stops. If I wait too long, then a whole lot of copying queues up, and when the Dynamic object regains visibility, the whole thing can hang while a lot of copying is being performed. I believe that the SharedFunction variable then gets locked while all of the copying occurs, and then the workers also get blocked, waiting for their chance to update the SharedFunction variable. So my entire parallel calculation gets delayed, defeating the benefits of using parallel.

Of course I introduced this two-stage mechanism - copying from the SharedFunction to the local/FE variable - in the hopes of avoiding this sort of issue as I know that some of my graphs take a long time to generate. I hoped to minimize the access to the SharedFunction variable, so I don't access it directly from the graphics routines. Nevertheless, like I say, the copying mechanism itself is also sufficiently costly as to now be its own bottleneck.

I have looked over the Advanced Dynamic Functionality section of the manual, and have seen the section concerning Refresh:

Refresh can also be used to cause updates at regular time intervals. It is important to understand that this is not a feature that should be used lightly. It is fundamental to the design of Dynamic that it does not need to update on any fixed schedule, because it simply always updates immediately whenever doing so would be useful. But there are some situations where this either cannot, or just unfortunately does not, happen.

But this only refers to the timing of updates, not how they are triggered.

And I think I have read every(!) entry here on MMA.SE concerning Dynamic/DynamicModuleand Refresh. However I am still pretty certain that there is no such thing as Dynamic updates when the Dynamic object is off the screen.

This question sounds like my question. However the consensus seems to be that trying to have Dynamic objects update in this fashion is a poor design. FrontEndDynamicExpression is mentioned, but it looks a little bit daunting.

As a simple example (nicked from somewhere here on MMA.SE) I have

DynamicModule[{showclock = True, ii = 0}, {Checkbox[Dynamic[showclock]], 
  Dynamic[If[showclock, Refresh[ii++, UpdateInterval -> 0.1], 
    ToString[ii] <> "-No count"]]}]

which illustrates that neither Refresh nor UpdateInterval are useful for what I want (the updating of ii is stopped when the object moves off the screen).

The only thing I can think of here is to try one of the ScheduledTasks functions. I have avoided this only because I have never used one any of these functions so far, and keep hoping that Dynamic has some feature itself.

I think that my issue might be further aggravated by the fact that I am running my program on another machine via Remote Desktop, and I get the feeling that disconnecting the session - even though the Dynamic NB is still open and 'visible' - also triggers Dynamic to take a break.

My question therefore is: Is there any way to force Dynamic/DynamicModule to update even when the Dynamic object is not visible?

I apologize of course for not offering any sort of minimal working example or useful code.

My version is MMA 9 and Windows 8.1.

  • $\begingroup$ Could you prepare a minimal example of code which mimics your setup? $\endgroup$
    – Kuba
    Jun 2, 2015 at 21:25
  • $\begingroup$ Both, FrontEndDynamicExpression and ScheduledTasks seem to be the solutions but I also feel like your approach is strange. $\endgroup$
    – Kuba
    Jun 2, 2015 at 21:30
  • $\begingroup$ Thanks @Kuba, I really would post a minimal example if I could, but the thing is just way too big. Essentially it sets up the SharedFunction communications variable to which all of the workers write their results as they generate them (its a genetic algorithm, so they write something each generation, maybe a few hundred K). These results are monitored within the Dynamic loop and whenever something new appears, it gets copied over to the 'local/FE' variable. The user has a number of graphics he can play with to visualize what is in the local/FE variable. $\endgroup$ Jun 3, 2015 at 0:36

1 Answer 1


It's hard to say much without details but let's try:

globalVar = 0;

DynamicModule[{ localVar = 0},
   Button["Stop", RemoveScheduledTask@ScheduledTasks[]],
 Initialization :> (
     If[localVar != globalVar, localVar = globalVar; FinishDynamic[]], 
     1, 2

This is kind of listener that checks if the globalVar was updated once per second. You can minimize the notebook and set globalVar=5 e.g. in new one.


  • ScheduledTasks have to be run from Initialization so the full scoped (by DM) symbol name is sent to the kernel.

    ScheduledTask with scoped variables

  • Dynamic@localVar alone is not enough to update it, just because there are some undocumented ways Dynamic handles just symbols and more nested expressions, so I added List.

  • localVar != globalVar may be time consuming so you can introduce additional variable/flag that will be set to 0 after assignment and to 1 by your external tasks after their are done.

  • $\begingroup$ Yeah, see, you are a nice guy @Kuba. I would have just told myself 'go read the documentation on RunScheduledTask'... Let me give this a try then and get back. $\endgroup$ Jun 3, 2015 at 14:28

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.