Simple, clean interfaces
Currently, for software developers working in groups towards a single goal, there tend to be very few options regarding collaboration. Either the teammates have to pair-program, effectively sacrificing half their capacity, or they have to work on separate pieces, hoping that their changes do not cause merge conflicts.
When pair-programming, at least one of the members must give up not only their ability to develop in parallel but also their familiar workflow. This disruption reduces effectiveness and causes a loss in overall performance of the team. When working in parallel, many teams frequently commit changes to a shared version control system (VCS) in order to avoid conflicts. This generates a massive changelog, as well as incurring the overhead of stopping, synchronizing, and then trying to pick back up.
What it does
Our solution, CodeCollaborate, brings entire projects into synchronization via the same algorithm that underpins Google Docs. By propagating changes in real-time, CodeCollaborate ensures that merge conflicts never occur, and allows teams to effectively collaborate without the added overhead of ensuring code synchronization themselves.
In addition, as an eclipse plugin (and with more plugins coming!), CodeCollaborate allows for developers to maintain the same workflow that they have grown familiar with over the years. By synchronizing across multiple Integrated Development Environments (IDEs) and text editors, CodeCollaborate allows each developer to use the tool of their choice, reducing barriers to collaboration.
As a cloud solution, CodeCollaborate allows developers to exercise the standard peer-programing practices, even if they are thousands of miles apart! By removing the need for screen sharing, this process can become more interactive, and engaging.
How we built it
CodeCollaborate was built on three principles - that the system would be easy to use, available outside of programming sessions, and highly responsive. This necessitated a clean interface, a centralized server and lots of optimizations.
By building on some prior work regarding the operational transform algorithm, we built a system that synchronized the changes in real-time and deployed it to the cloud for scalability options.
Challenges we ran into
Many of the challenges we ran into were minor implementation details, but one stands out as a major challenge: synchronization. Even though the Operational Transformation algorithm had already been designed, implementation of such an algorithm was technically complex and exciting.
Accomplishments that we're proud of
Getting the entire synchronization subsystem working was the proudest moment we had. Seeing two documents synchronized across multiple clients was extremely exciting and rewarding.
What we learned
Building this system as a cloud service, we learned a lot about how systems scale, as well as how they are maintained.
What's next for CodeCollaborate
Next, we intend to refactor and clean up our design, improving maintainability, and then attempt to bring this to market. Perhaps this can be the next big developer tool?
Some prior work was contributed by Austin Fahsl, Gene Logan and Joel Shapiro.