Next version of Waldo will have stm-like semantics as well.  These libraries are the beginnings of providing these semantics in Waldo.
Simple test script for testing basic interface of reading/writing on
stm-like Waldo objects.
Added several other basic value types.
Making interfaces to handle stm value types more flexible so that it's easier to mix in maps and lists with the same interface.
Added more flexibility to dirty map elements to support eventual non-value types, like lists.
Added a basic container class (parent class of struct, list, map).  Current version only supports holding value types.  Will update soon.
Added a test case to exercise some of value map logic.
Added a value list type.
Tests for value list operations.
For lists, used wrong criteria to select whether to write.
Beginning of restructuring.  Want to make it so that variables can hold references to list and map objects.
Major restructuring of code so that naming is more consistent.  At
this point, have several major variable types (numbers, texts,
truefalses, maps, and lists).  Each of these variables has stm-like
properties.

Numbers, texts, and truefalses all have immediate types.  We only use
their wrapped, variable, versions when we assign them to externals,
peered, or endpoint-local data.

Correspondingly, we use InternalMap and InternalList for maps' and
lists' immediates and wrap them as variables when assigning to
externals, peered, or endpoint-local data.

Still need to add user structs type.
Two minor bug fixes:

  1) Fixed some typos with contains key

  2) Removed _deep_copy call because can't call pickle on objects with
     locks.  When we want to create a dirty version of a value, then
     we call _non_waldo_copy to generate a dirty value.
Re-organizing tests to make testing more automated.
Added test for lists of lists.
Updated test_num so that it follows basic test format.  (Has a run method that returns True if test succeeded and False otherwise.)
Removed test of other value types.  test_num pretty much tests the same relevant code.
Added a little bit of testing infrastructure for v4's stm-like approach.
Basic benchmark reporting for incrementing a single number over and over again.  Hopefully, will give some sense of how can speed code.
Trying to get a sense of how fast can perform certain operations.  In this case, determining how many times can increment a single value in a single thread.