# Reading Your Own Writes

A view lags behind the events that have been written, by however long its projection takes. To read your own writes, wait until the view has seen the events you have written.

The ID of the last event a view has seen is its revision. Since the database assigns event IDs in ascending order across all subjects, revisions can be compared.

## Tracking Revisions

To track the revision of a view, wrap the projection with the `Tracking` function and hand over the view. It records every event that reaches the projection, including the ones the projection ignores:

```go
trackedProjection := architecturekit.Tracking(catalog, catalogProjection)
```

Then run `trackedProjection` instead of `catalogProjection` (see [Running Projections](/docs/architecturekit/projections#running-projections)).

`Tracking` accepts every view that implements the `RevisionSink` interface, which consists of the `Seen` function. `ItemView` implements it.

The tracked projection keeps the mode and the batch sizes of the projection it wraps. A transactional projection can not be tracked, since it has no `Apply` function. Record its revision within the transaction instead.

To get the revision your own write has produced, call the `RevisionOf` function with the written events. It returns the highest event ID, or an empty string if no events were written:

```go
revision := architecturekit.RevisionOf(writtenEvents)
```

## Waiting for Revisions

To wait until a view has reached a revision, call the `WaitFor` function with a context and the revision. It returns immediately if the view has already reached the revision, and otherwise once it does, or when the context ends:

```go
ctx, cancel := context.WithTimeout(context.TODO(), 5*time.Second)
defer cancel()

err := catalog.WaitFor(ctx, revision)
if err != nil {
  // ...
}
```

To get the current revision of a view, call the `Revision` function. It returns an empty string as long as the view has not seen any event:

```go
current := catalog.Revision()
```

Both functions form the `Revisioned` interface, which `ItemView` implements. To wait for revisions of a view of your own, implement it as well.

## Comparing Revisions

To compare two revisions, call the `CompareRevisions` function. Like `cmp.Compare`, it returns `-1`, `0`, or `1`. An empty revision comes before every other one. If a value is not a revision, it returns `ErrNotARevision`:

```go
result, err := architecturekit.CompareRevisions("9", "10")
// result == -1
```