How can I set up a versioning system within a notebook?

Question

Since the Frontend crashes a lot, for important work it would be nice to have the notebook automatically branch and save itself every so many minutes.

For instance, commands like StartSavingCopies[5] would save a copy with a new name "BackupFileNumberX.nb" every 5 minutes.

How can we do this behind the scenes dynamically?

Answer 1

I don't like to answer my own question, but to give an idea of what an answer might be here's my first stab at this (in the form of a toolbar), just try running UtilityDock[] and click "Branch" after saving it.

(Note: I think the best answer wouldn't make use of a toolbar)

 UtilityDock := (c = 
    Cell[BoxData[
      ToBoxes[Grid[{{Item[
           Row[{" ", 
             DynamicModule[{state = 1}, 
              Button[Dynamic[If[state == 1, "Hover", "Sink"]], 
               Dynamic@If[state == 1,

                 SetOptions[EvaluationNotebook[], 
                  "WindowFloating" -> True]; state = 2,

                 SetOptions[EvaluationNotebook[], 
                  "WindowFloating" -> False]; state = 1], 
               BaseStyle -> {15, FontFamily -> "Bank Gothic", White}, 
               Appearance -> None]], Style[" | ", White],

             DynamicModule[{state = 1}, 
              Button[Dynamic[If[state == 1, "Collapse", "Expand"]], 
               Dynamic@If[state == 1,

                 SetOptions[EvaluationNotebook[], 
                  "WindowSize" -> {Automatic, 40}]; state = 2,

                 SetOptions[EvaluationNotebook[], 
                  "WindowSize" -> {Automatic, 700}];
                 state = 1], 
               BaseStyle -> {15, FontFamily -> "Bank Gothic", White}, 
               Appearance -> None]], Style[" | ", White], 
             Button["Branch", (SetDirectory[
                NotebookDirectory[EvaluationNotebook[]]];

               thisName = 
                StringTake[
                 Last[FileNameSplit[NotebookFileName[InputNotebook[]]]], {1, -4}];

               latestBranch = 
                Max@Join[{0}, (ToExpression /@ 
                    Flatten[
                    StringCases[
                    Thread@
                    StringTake[
                    Pick[FileNames[], 
                    Not /@ 
                    StringFreeQ[FileNames[], thisName]], {1, -4}], 
                    "B" ~~ x_ :> x]])];
               Print[ToString[latestBranch + 1]];

               NotebookSave[EvaluationNotebook[], 
                FileNameJoin[{NotebookDirectory[], 
                  thisName <> " B" <> ToString[latestBranch + 1] <> 
                   ".nb"}]];

               NotebookSave[EvaluationNotebook[], 
                FileNameJoin[{NotebookDirectory[], 
                  thisName <> ".nb"}]];), 
              BaseStyle -> {15, FontFamily -> "Bank Gothic", White}, 
              Appearance -> None]}], ItemSize -> Scaled[0.8], 
           Alignment -> Left],
          Item[Row[{

             ActionMenu[
              "Zoom", {"75" :> 
                SetOptions[EvaluationNotebook[], 
                 "Magnification" -> 0.75], 
               "100" :> 
                SetOptions[EvaluationNotebook[], "Magnification" -> 1],

               "150" :> 
                SetOptions[EvaluationNotebook[], 
                 "Magnification" -> 1.5],

               "200" :> 
                SetOptions[EvaluationNotebook[], 
                 "Magnification" -> 2]}, 
              BaseStyle -> {15, FontFamily -> "Bank Gothic", White}, 
              Appearance -> None], " "}]
           , ItemSize -> Scaled[0.2], Alignment -> Right]}}, 
        BaselinePosition -> Scaled[0.3], ItemSize -> All]]], 
     "DockedCell", Background -> Black, ImageMargins -> 0, 
     CellMargins -> {{0, 0}, {0, 0}}, 
     CellFrameMargins -> {{0, 0}, {0, 0}}];
   SetOptions[EvaluationNotebook[], "DockedCells" -> c]);

Answer 2

As a software developer, I'd suggest a non-mathematica solution to the general problem of versioning. Use a version control system, such as git, that supports text files (i.e. notebooks).

If you both (1) use an external version control system, where you explicitly commit after any "interesting" change, and (2) setting the default configuration to auto-save as detailed in this answer:

Is there a notebook autosave frequency configuration?

An example create-a-notebook workflow (using git) is:

• create a notebook, say besselPlot.nb, and save it to a directory in my git repository (~/physicsplay/mathematica say)

• from a command line (I happen to use a Windows cygwin on the laptop that I've got Mathematica on)

  cd ~/physicsplay/mathematica

  git add besselPlot.nb

At points of interest, from the shell, commit your changes

cd ~/physicsplay/mathematica

git commit besselPlot.nb

# or

git commit -a

You'll get a chance to add a commit comment ("plot without labels", say), so that you can use your commit logs if you want to roll back to an older version (i.e. should you screw up what you are doing and get it auto-saved at an undesirable time).

While I've just only started using the autosave mechanism, I think that with a version control system as a backend for the notebooks, this should work out nicely as a general solution, without requiring you to sort through piles of BackupFileNumberX.nb's.

Answer 3

On Linux, you can combine your favorite version control system (Git in this example) with inotify to automatically commit your changes to the repository whenever your .nb file is saved.

Create a Git repository, and save your notebook (say notebook.nb) in the repository. Use inotifywait to automatically run git commit notebook.nb --allow-empty-message -m '' whenever notebook.nb changes. Start editing your notebook in Mathematica.

Then, to save a new version, simply press Ctrl-S, and it will automatically commit to the repo.

If you want to add a commit message after saving, run git commit --amend -m 'The commit message'. Alternatively, if you intend to always add a commit message, remove --allow-empty-message -m '' from the Git command, and set your preferred text editor; then whenever you save, your editor will pop up and prompt you for a commit message.