[Fenfire-dev] Starting on pointers bullet points

[Benja Fallenstein]

So I've discovered I needed to think about this more, thought about it 
all night in fact, finally realizing what the main contribution of this 
article is (as so often, learning a lot by getting thoughts lined up in 
order to be able to write an article).

The main new and *useful* thing is the idea to handle updating simply by 
adding pointer records (i.e., adding a block signed by the pointer's 
owner), and resolving references by searching for the *newest* of those 
blocks (given by its timestamp).

Current systems either have no updating, or centralized updating (a 
central server keeping track of the current version), or a special 
network-level feature that replaces the current version with a new one.

Our system is much simpler, as it doesn't require reaching network-wide 
agreement, and in fact allows the same addressing scheme to be used with 
different networks-- like with hashes: you have the SHA-1 hash of a 
file, you can use Gnutella or Storm/GISP or whatnot to find the file.

So this is the main contribution, as it is very transferable to other 
systems that don't have much to do with us.

The other realization was that actually, nobody seems to have proposed a 
location-independent Web, in the sense of replacing the Web with 
something completely based on location-independent, self-verifying 
identifiers. (Nobody but us, that is.) It's not far from what e.g. 
Freenet does-- but Freenet is not a Web replacement. SFR (Semantic-Free 
Referencing, IPTPS'03) is a Web replacement, but it just replaces DNS-- 
you still have a Web server or small set of Web servers maintained by 
the publisher of a Web page.

Now, the real location-independent Web is really made possible by our 
pointer record technology-- before that, there isn't really any 
self-verifying updateable referencing (well, it's debatable, but if the 
network has to keep state (what's the current version) I wouldn't really 
call it completely self-verifying).

So that's the *point* of the article-- location-independent Web made 
possible by pointer records.

Ok, and here's the preliminary bullet point list, not perfect, but I 
need to go to bed and want you to have something to chew on.

(BTW, the first draft has to be ready by Monday evening, or we'll forget 
about the deadline, by our new rules. But we'll make that easily ;-))

- Introduce location-independent Web idea (citing
  benefits from hash-based addressing)

  - Problems with location-depencence, other articles
    recognizing these
  - Location-independent, semantic-free, *self-verifying*
    identifiers (ref SFR paper (Balakrishnan et.al. IPTPS'03))
  - Benefits of hash-based addressing:

    - Pages easily movable between servers
    - Data accessible as long as anyone keeps a copy
    - Load balancing (download from everyone who has a copy)
    - Can use one addressing scheme with different protocols,
      searching different networks for the content behind a hash
      (see the ``hash`` URN namespace proposal)

  - Closest thing to location-independent is actually, it seems, Freenet
  - SFR (semantic-free referencing) not all that close,
    though semantic-free idea shared (SFR takes along
    many problems of the Web)
  - Other projects exploit some of the advantages of hash-based
    (storage systems: CFS, PAST; web caching: Squirrel),
    but don't address the Web.
  - Possibility of desktop integration in ways that the location-dependent
    Web cannot archieve, through the unique combination of
    network transparency and location independence (ref ourselves).

- However, there's a problem with this: versioning

  - Basic problem: Hash-based addressing allows no updates

- Contributions; structure of this paper

  - Main contrib: Pointer records for implementing updating
  - Other contribs:

    - The idea of a location-independent Web including
      location-independent version management
    - Non-linear versioning through obsoletion

- Related work: How current systems deal with it

  - No updates:

    - PAST
    - Free Haven

  - Centralized updates (destructive):

    - SFS &c
    - Publius (apparently)
    - Oceanstore

  - Network-level destructive updates:

    - Freenet
    - SFR (apparently)
    - CFS

  - Conclusion: Doesn't provide the benefits of
    hash-based addressing; doesn't allow accessing
    past versions

- Pointer records

  - Basic model of underlying system: Only blocks and reverse indexing
    (nicely provided through DHT)
  - Key idea: Pointers are abstract references that *point*
    to different blocks (versions) over time
  - The association between a pointer and a version is formed
    by a special kind of block, the *pointer record*
  - Signatures
  - Timestamp for ordering the records/versions (note on problems
    this entails-- if a computer's clock is set into future etc)
  - Implementable in other systems, too
  - Carries over the four benefits from hash-based addressing:

    - Version references movable between servers
    - Past versions accessible as long as anyone keeps a copy
    - Load balancing (download the pointer record from whoever has it)
    - Can use one addressing scheme for *updateable* information,
      searching different networks for versions

- Non-linear versioning for asynchronous collaboration

  - (also one person using more than one computer)

- Permanent signatures

- Conclusions


\- Benja