Allow real-time collaboration of many transcribers on a single video with minimal management.

All users will access the same video simultaneously. They can start editing and adjusting the
timings of any of the subtitles they choose, provided that no one else is already editing it.

There is no need to manually delegate video segments to each transcriber. The transcribers freely
choose what part and length of the video they want to transcribe.

When a user creates a new subtitle, all other user’s UI are also updated, showing a new subtitle
created from time X to Y. Now other users are prevented from creating new subtitle that overlaps
with the first subtitle

Using this real-time approach to subtitling we can scale to 30-40 users on the same video
To speed up the transcription, we also first run the video through a voice-recognition system and
create the initial subtitles. Then the transcribers only perform corrections of the subtitles.

We achieve this by keeping a master document on a server. Each user client-side editor will
synchronize themselves to this master document. Any edits are immediately pushed to the master
and forwarded to all other users. Everybody sees the exact document in real-time without having
to reload the page.

The system maintains the correctness of the subtitles. It prevents users from overlapping each
other’s timings by keeping each client synchronized to the master document
To prevent conflicts, only one user can edit a segment at any time.

When the client-side opens on browser, it downloads the project details and subtitles from the
database. It also maintains a polling connection to receive any updates

The subtitles are stored in an array in memory. Then the computer receives update, the array is
reconstructed in memory to reflect the changes on the server. A notification is sent to the UI to
indicate that the data has changes. The UI re-renders to reflect the changes in the data

The client-side maintains a copy of the subtitles. Any changes to this copy is pushed to the server.
We push only changes and not the whole subtitle.

Real-time applications always present a latency issue which will affect its user experience. We
deal with this problem in 2 ways:
1. Categorizing updates into 2 sections: immediate updates and delayed updates to reduce
network load.
2. Perform server replication so that users are physically closer to their selected servers, hence
 reducing latency.

We separate the updates into 2 types:

1. Immediate updates
Immediate updates are performed when many users are able to perform the same action of a
subtitle at the same time. This introduces the potential for a lot of conflicts. The changes must
immediately pushed to the server so that other users can only perform valid actions based to
the new updates.. Examples of immediate updates include ownership claims. A user is must
claim ownership of a subtitle before he can start writing. To prevent multiple users trying to
claim the same subtitle, we have to update the UI of all other users to indicate that the subtitle
is no longer available for claim.

2. Delayed updates
When the user performs an action, we start a timer. Every time the user makes a new action.
We restart the timer. At the end of the timer we push the updates. This is done for e.g text changes.
The updates are frequent and is not time critical. Also since the user must claim writing ownership
before typing text, we only have one user who is allowed to type in this specific subtitle. Hence
text-typing is safe from collisions, unlike status changes

There are 6 types of updates that are synced with the server. Each has to be dealt in a separate
manner in terms of how the updates are pushed to the server. Ideally we would like to minimize
the number of updates to allow more users to participate
1. Claim – immediate
A user is must claim ownership of a subtitle before he can start writing. To prevent multiple
users trying to claim the same subtitle, we have to update the UI of all other users to indicate that
the subtitle is no longer available for claim.
Conflict management: if a conflict occurs during claim, we choose the first user who claimed
as the winner unless the second user has higher clearance.
2. Change text – delayed- to prevent overloading of updates, we need to delay text updates
3. Change time – delayed
Transcribers sometimes need to adjust the timings many times to get the proper value. Until
the user chooses a final value, we delay this update so that not to overload other users with too
many updates. If we delay to much, other users might create overlapping subtitles. A good
comprise for this delay is 5 seconds for 10 users
4. Delete - delayed
One must claim ownership before deleting a subtitle so it is safe from conflicts i.e multiple
users cannot try to delete or edit subtitle at the same time. Also this allows a user to delete many
subtitles but not overload other users with too many updates
5. Insert – immediate
When a subtitle is inserted, the new subtitle is updated on all users screens to prevent them
from creating a subtitle at the same location or overlapping existing subtitles
Conflict management: if 2 subtitles are created at the same time, we choose the first subtitle as
the winner unless the second user has higher clearance.
6. Mass Subtitle importing
When a subtitle file is imported, all the news subtitles are pushed to the server 1 one request.
Conflict management: mass subtitle involves high possibility of overwriting data that the user
is not aware of. So we only allow users with ‘project-manager’ clearance to import subtitles.

Server Replication.
Since this application works in real-time, latency is a very critical factor. Users having high
latency would experience a high number of conflicts, For example trying to claim subtitles that
have already been claimed or trying to create a subtitle in a location that another subtitle already
exist.
To reduce latency, we work with replicated, time-critical synchronized database in different
locations. The client-side on connection will perform tests to identify the sever with the lowest
latency and connect to it. This allows the user to have good experience when using the application.
Also any updates that the user will push to this server will also be replicated to other servers in
other locations as fast as possible using replication databases like couchdb. This allows for user all
across the world to work on the same video with low latency in most situations.