[Gzz-commits] manuscripts/storm article.rst buoyframe0.png bu...

[Benja Fallenstein]

CVSROOT:        /cvsroot/gzz
Module name:    manuscripts
Changes by:     Benja Fallenstein <address@hidden>      03/02/15 11:05:30

Modified files:
        storm          : article.rst 
Added files:
        storm          : buoyframe0.png buoyframe0.ps 

Log message:
        cut more, down to 10 1/2 pages

CVSWeb URLs:
http://savannah.gnu.org/cgi-bin/viewcvs/gzz/manuscripts/storm/buoyframe0.png?rev=1.1
http://savannah.gnu.org/cgi-bin/viewcvs/gzz/manuscripts/storm/buoyframe0.ps?rev=1.1
http://savannah.gnu.org/cgi-bin/viewcvs/gzz/manuscripts/storm/article.rst.diff?tr1=1.167&tr2=1.168&r1=text&r2=text

Patches:
Index: manuscripts/storm/article.rst
diff -u manuscripts/storm/article.rst:1.167 manuscripts/storm/article.rst:1.168
--- manuscripts/storm/article.rst:1.167 Sat Feb 15 10:50:15 2003
+++ manuscripts/storm/article.rst       Sat Feb 15 11:05:29 2003
@@ -110,7 +110,7 @@
 modifying them on each; when two people collaborate on a document, 
 sending each other versions of the document by email; 
 when someone downloads a document, modifies it, and publishes
-the modified version (e.g., a manual licensed under the Gnu FDL [gnu-fdl]_),
+the modified version,
 or when a group of people collaborate on a set of documents,
 synchronizing irregularly with a central server (as in CVS [cvs]_),
 a network of servers (as in Lotus Notes) or directly with each other 
@@ -894,13 +894,11 @@
 each with only small changes. Instead, we use the well-known
 technique of storing only the differences between versions.
 
-Even though we use diffs,
-we *pretend* to store whole versions: We refer to a version
-by the id of a block containing it.
-However, we do not necessarily store this block,
+We still refer to a version by the id of a block containing it.
+However, we do not necessarily *store* this block,
 even though we refer to it. Instead, we may create a *diff block*,
-containing a difference and the ids of the versions this
-is a difference between. When we want to load a version
+containing the ids of two versions and the differences between them.
+When we want to load a version
 and do not have the block, we use Storm indexing to find
 all diff blocks from or to that version, trying to find
 a chain of differences starting at a known version. Then,
@@ -916,25 +914,25 @@
 an untrusted network source because we can check whether a block
 has given us version X or Y by checking the cryptographic hash.
 
-In this scheme, we can easily drop a previous version
-by merging differences: If we have stored the differences
-from version ``A`` to ``B``, and ``B`` to ``C``, 
-to drop version ``B``, we compute
-the difference from ``A`` to ``C``, and replace the two
-previous differences by it. If we also store a difference
-between version ``C`` and ``D``, it does not need
-to be altered, because it refers to *version* ``C`` and not
-the difference to ``C`` from ``B`` (as in the simplistic scheme).
-
-We can also store the block containing version ``D``
-in addition to storing the versions above. Then, we can reconstruct
-version ``C`` in two ways: By using the diffs from ``A`` to ``B``
-and ``B`` to ``C``, or, more efficiently, by applying the inverse
-of the diff from ``C`` to ``D`` to version ``D`` [#]_.
-
-.. [#] Of course, in reality the number of differences
-   that can be 'skipped' will have to be much higher
-   for this mechanism to be useful.
+.. In this scheme, we can easily drop a previous version
+   by merging differences: If we have stored the differences
+   from version ``A`` to ``B``, and ``B`` to ``C``, 
+   to drop version ``B``, we compute
+   the difference from ``A`` to ``C``, and replace the two
+   previous differences by it. If we also store a difference
+   between version ``C`` and ``D``, it does not need
+   to be altered, because it refers to *version* ``C`` and not
+   the difference to ``C`` from ``B`` (as in the simplistic scheme).
+
+   We can also store the block containing version ``D``
+   in addition to storing the versions above. Then, we can reconstruct
+   version ``C`` in two ways: By using the diffs from ``A`` to ``B``
+   and ``B`` to ``C``, or, more efficiently, by applying the inverse
+   of the diff from ``C`` to ``D`` to version ``D`` [#]_.
+
+   .. [#] Of course, in reality the number of differences
+      that can be 'skipped' will have to be much higher
+      for this mechanism to be useful.
 
 Our current implementation is a layer above Storm block storage
 and indexing. This layer implements a ``load(version-id) -> version``