How do I maintain notebook state variables between front end/kernel sessions, if those variables are set programmatically rather than via UI widgets?

Question

I need to give a notebook a few simple state variables (counters) that will be saved with the notebook, persist across kernel restarts, etc. From what I've read, using variables defined within a DynamicModule is the appropriate strategy, especially since I'm going to have a cell (docked at the top of the notebook) that displays the current value of those variables.

My problem is that these variables should NOT be changed via UI widgets, by the user. Instead, I need to change them programmatically, from code that's resident in a package the notebook loads. I can't figure out how to do that. I've read the documentation on DynamicModule "Wormholes", but that only discusses state variables that are changed by UI widgets (sliders, buttons, etc.). I've also read this post, which might be relevant, but I don't grok it well enough to see how.

A different approach might possibly be to store the state variables in TaggingRules associated with the notebook, and have the display area query those within a Dynamic[] function... but that seems like it's well outside the intended purpose of Dynamic, and the subtleties involved -- wrapping Dynamic around a TaggingRule value query, probably with some string-to-number coercion involved -- daunts me.

So: Can I programmatically alter the values of variables within a DynamicModule from outside that module? Or is there a different/better way to proceed?

Edit: What makes my question different from others I've found on this site, and other discussions of DynamicModule wormholes, is that they all use a UI widget to change the state variable. I'm specifically asking how to do it programmatically.

Edit 2: As the discussion here has evolved, I realize that the question I originally posted did not in fact capture my ultimate aim. Therefore, the perfectly good answers below don't answer the question stated in the title, although they do match the intent communicated in the description. Therefore, I've changed the title.

Answer 1

After commenters and answerers pushed me to investigate TaggingRules rather than DynamicModule as a strategy, I've worked out a solution. After the fact, it's actually embarrassingly simple. In the package that supports this notebook (or, equivalently, in notebook initialization cells), I define helper functions:

SetAttributes[getCounter,Listable];
getCounter[counterName_String]:=
  Module[{value},value=CurrentValue[EvaluationNotebook[],
    {TaggingRules,"persistentCounters",counterName}];
    If[value===Inherited,initializeCounter[counterName],value]
  ];

initializeCounter[counterName_String]:=
  CurrentValue[EvaluationNotebook[],
    {TaggingRules,"persistentCounters",counterName}]=0;

incrementCounter[counterName_String]:=
  CurrentValue[EvaluationNotebook[],
    {TaggingRules,"persistentCounters",counterName}
  ]=1+getCounter[counterName];

deleteAllCounters[]:=
  CurrentValue[EvaluationNotebook[],
    {TaggingRules,"persistentCounters"}]=None;

I can then display any counter value anywhere (such as in a docked cell), like this:

Dynamic[getCounter[{"one", "two", "three"}]]

(* ==> {0, 0, 0} *)

All counters are created and initialized to zero when they are first checked. I can then increment any counter value like this:

incrementCounter["one"];

and the Dynamic display will automatically update. If the notebook is closed and reopened, and/or the kernel is quit, the counter values persist (once the initialization cells have been evaluated or the relevant package loaded, of course).

For my purposes, this seems entirely adequate. No wormholes necessary! Thanks, @Szabolcs.

Answer 2

Some useful information are in this post from Szabolcs, however your question is a little different. Indeed, actually you only need to save an information (the counter value) inside a notebook and preserve it across frontend sessions. For such cases TaggingRules seems to be the best solution. DynamicModule could eventually be another option to save information across kernels sessions, but I have not been able to achieve the result with it. So, defined the use of TagginRules as metainformation keeper, what we have to focus on is how to change the value assigned to TagginRules before the notebook is saved, and without any widget interation (button, slider or anything else). I tried using something like TaggingRules->Dynamic[mycounter] with no success. Finally, I moved to another idea: have a Dynamic object that sets the TaggingRules for the EvaluationNotebook each time the counter changes the value. I used DynamicWrapper to trigger the SetOptions evaluation as soon as the counter is updated. Here is the code

SetOptions[InputNotebook[], DockedCells -> Cell[BoxData@ToBoxes[
     DynamicModule[{}, 
      Row[{DynamicWrapper["my counter value is ", 
         SetOptions[InputNotebook[], 
          TaggingRules -> {"counter" -> mycounter}], 
         TrackedSymbols :> {mycounter}], Dynamic[mycounter]}], 
      Initialization :> {mycounter = 
         CurrentValue[InputNotebook[], {TaggingRules, "counter"}]}]]]]

I used DynamicModule just to have the possibility to set Initialization, so to read the current value saved into the notebook as soon as the notebook is opened. After evaluate the above code, try changing the value of variable mycounter and see is is updated in the DockedCell. Close the notebook and exit Mathematica and when reopen the notebook the counter is still there. I hope this is what you was looking for.