phd thesis on pair programing

american government essay paper

A full set of resources to accompany this feature can be downloaded for free here. Calling all English teachers: does this sound familiar? As structure gcse english lit essay go through extracts in the last lesson on Friday afternoon, you ask carefully crafted questions, and note with satisfaction how students shoot their hands up in a flash, like Barry Allen on the run. Later, back at home, you mark them. What went wrong?

Phd thesis on pair programing sigchi finland thesis

Phd thesis on pair programing

Both of these collaboration methods provide unique benefits to programmers, but there has not been major implementations of collaborative programming systems which combine these two methods. CodePilot supports both real-time and non-real-time collaborative editing, finally bringing together real-time programming and non-real-time collaboration.

It allows its users to import a repository of code from GitHub and start collaborating synchronously on a project, and still periodically commit updated versions. The larger a software team grows, the more overhead in communication and synchronization there is.

People are less able to collaborate effectively on a project due to this overhead Brooks The relationship between workers and productivity in software is complex: perhaps 2 workers could complete a project faster than a single worker, but what about workers? Designing and writing software is an incredibly complex process, and combining this with the coordination required for software teams to work efficiently may actually make smaller teams perform better than larger teams.

According to Brooks, there are four essential difficulties that the essence of software contains:. CodePilot aims to tackle some of the challenges presented from these difficulties. CodePilot increases visibility through its web renderer, allowing programmers to see the representation of their code. It handles changeability with its operational transform syncing mechanism and the GitHub-backed repository branching and version control. It encourages conformity with its HTML, CSS, and Javascript debugger and its GitHub issue integration, by allowing revisions of the software to be examined and marked with any errors that are found.

Complexity is not directly handled by CodePilot, but other tools such as Python Tutor offer in-browser tools that help with both invisibility and better understanding complexity even if not reducing it Guo Web browsers are an essential part of modern computer use, and developers frequently use them to access the internet, looking up documentation or asking questions on StackOverflow Brandt et al.

Increasingly, sites have come out such as HackerRank, Interview Cake or Python Tutor which allow users to evaluate dynamic code execution in the browser. One limitation of these sites is that they usually limit evaluation targets to code snippets that cannot be very complex. There is very limited support for executing larger projects, although continuous integration testing sites such as Travis-CI allow this.

Dynamic user interfaces are not easily tested, but our feedback generation tool captures a significant amount of relevant information about the page, creates a GitHub link with the entire state of the page and provides a link for the issue to be re-rendered and examined by others in the future. It does not entirely address software complexity, since evaluating the correctness of code automatically in the browser is a problem that is not fully solved.

CodePilot allows novice programmers to use version control together, in a manner that promotes self-efficacy and reduces frustration. The key findings are that a mix of real-time and non-real-time version control systems can improve novice programmers sense of self-efficacy when using version control systems, and also that they can be used to help parallelize software development and reduce the amount of unnecessary merge conflicts.

We will discuss relevant collaborative editors, pair programming and education research, the sync-async collaboration paradigm, the CodePilot system implementation, evaluation of the CodePilot system, results of the evaluation study, discussion of study results, and finally conclusions and future work.

A good amount of relevant work has been done on other real-time collaborative editors, as well as editors that integrate more blended forms of asynchronous and synchronous collaboration features. There are also relevant studies of how people work best together on software projects, along with studies of how effective different types of pairs of students are together. This body of work was influential on the design of CodePilot.

Collaborative learning and education is an active area of research which explores how students best work together. This work effects teaching practices, and therefore students who later become developers who collectively shape industry practice. Increasingly, code is stored and distributed on GitHub, the popular git repository hosting website.

It can act as a library of guides and example code for beginners to work through. GitHub also offers a dedicated educational tool, GitHub Classroom, allowing programmers to easily learn both version control and coding fundamentals GitHub Even so, this often focuses on non-real time collaboration or single developer workflows. Still, there is exciting work being done on how collaborative editors can allow programmers to work together more effectively both synchronously and asynchronously.

These are less tied to version control than CodePilot, and mainly provide a real time syncing mechanism. More recently, there is MadEye and Cloud9 - web editors that allow you to share your session with someone else MadEye ; Cloud9 Both of these make great improvements over traditional pair programming schemes, but are designed for simply dropping in and solving an issue with the code.

One notable system that provides a similar intermediate mix of real-time and non-real-time collaboration is Collabode Goldman, Little, and Miller , which allowed users to have concurrent editors, but filtered out the error messages a single user would see to those that they themselves had generated. Merging actual copies of divergent copies of code could be delayed until the errors generated from the changes had been resolved, efficiently combining real-time changes with a software verification gating system.

Other tools such as Syde seek to better synchronize developer awareness by providing contextual awareness beyond version control changes, by notifying developers of changes in source code in real time Hattori and Lanza Developers use the internet as a resource to learn and remind themselves of coding concepts or syntax. Some developers even reported visiting the same site many times, acting as a sort of external memory bank.

As the code stored on the internet grows, example-centric programming will become more popular, as developers fork relevant code and modify it to their ends Brandt et al. A web IDE such as CodePilot allows and encourages this information to be cached and accessed with less of a major context switch, as the user remains in the browser. In a large quantitative study, code produced from pair programming contained fewer bugs, leading to overall higher quality code Williams et al.

There is also something to be said about the social dynamics of working together, specifically between pairs in pair programming Thomas, Ratcliffe, and Robertson If there is a mutual perception of technical capabilities, then pairs worked better together. This is opposed to pairs where skilled programmers work with novice programmers. Furthermore, students with a good amount of confidence enjoy the pair programming experience most and students did their best work when working with similarly skilled programmers Katira, Williams, and Osborne Overall, students liked pair programming and believe that it helped them achieve effective solutions.

Side by side programming is another paradigm where people are at adjacent workstations, and both work on coding, differs from co-piloting code. They cite a study comparing distributed and co-located pair programming: distance does not matter. Also relevant is concurrent programming and browsing - one person codes, the other person reviews the code or requirements documents Dewan et al.

Another programming paradigm is a rapid development cycle in which two developers work together in test-driven development, where one of them will work primarily on the implementation and one of them will work primarily on the tests. This idea was tested with the Collabode system, and the developers reported that this split was very natural Goldman and Miller In a similar vien, PatchWorks provides an interesting methodology on methods for allowing easier navigation of code Henley et al.

While CodePilot simply uses a standard single pane text editor, working with more advanced views of code could be integrated into CodePilot. This could be a shared view that shows which portion of code is currently being viewed by your collaborator. There is also the option of having many people contribute to the codebase, rather than a few trusted collaborators. Systems such as CrowdCode LaToza et al. Fleshing out psuedocode, creating unit tests, and writing additional documentation for a codebase can be effectively distributed many workers, given the appropriate back-end coordination system.

Computing education is growing in popularity, as a new CS for all initiative was launched recently. However, coding is not done in pure isolation, and nearly all production software involves a great deal of collaboration between developers. While there has been much effort in analyzing how content or presentation may be augmented, it is important to also focus on how the methods of collaboration can be improved.

When used in educational setting, pair programming serves as effective collaborative learning instance Preston Work has been done that suggests that activity streams with individual programming assignments can positively influence learning outcomes. This served as a guide when implementing the activity feed. Pair programming can also be a effective to spread expertise among programmers, which is useful information for both industrial and computing education professionals.

This adds to the value that programming together has, adding more weight to the argument that collaborating with others not only produces more ideas and potential solutions but also can be a form of training and educating programmers Jones and Fleming When pair programming, students tend to get stuck less and explore ideas more. Contrastingly, students reported that when programming alone they were more confident and understood their programs better after they were done Simon and Hanks CodePilot seeks to strike a middle ground between these two workflow patterns.

Implementing a curriculum where students can collaborate on projects early on can lead to much better retention rates, both in the class and the major Williams et al. Using the JavaGrinder was as web IDE while pair programming has been found to positively effect student retention in introductory computer science classes. CodePilot can help support this by fostering more collaboration. We hypothesize that combining both real-time and non-real-time collaborative tools will lead to a richer and more cohesive collaborative programming experience, as opposed to either of those methods alone.

Synchronous editing, such as that supported by Google Docs, is excellent at keeping collaborators in tune with what each other is working and focusing on. Seeing edits performed in real time gives a sense of dynamism to the work being done, and allows potential misunderstandings to be cleared easily by presenting the same shared context.

Issues can arise if communications between programmers editing the same codebase suffer significant delay. A common trope of multi-developer version control scenario is the commonality of the merge conflict. Before the second developer pulls from the main repository host GitHub, Bitbucket, etc. When the second developer makes another commit locally based on the last seen commit from GitHub and tries to push it to GitHub, they might see an error like:.

This frustrates programmers since they simply want to share their work with their teammates, but now they must coordinate with the first committer and resolve the merge conflict by manually by creating a new version of the code from the two branches which incorporates both changes, or rebasing the head of their local branch off of the newly updated remote and then merging in the changes again.

The benefit of synchronous collaboration systems is that there are no merge conflicts. The syncing mechanism such as Operational Transform automatically merges the changes coming in from each programmer and keeps a single persistent document for all collaborators. A diagram of the differences in merging strategies is shown in the figure below. This is not to say that the synchronous collaborative editor is the perfect programming tool.

Conversely, asynchronous collaboration through version control provides its users with the ability to update their versions of the codebase as they please, rather than keeping a single persistent shared state. Collaboration with version control through platforms such as GitHub and Bitbucket has been steadily growing more popular, and will likely continue to be a way that future developers collaborate together on software projects. There is often a significant overhead when learning to use git outside of a single developer context for budding coders, though.

They are already building their fundamental computer science skills, on top of learning how to use git or mercurial. CodePilot aims to take the best of real-time and non-real-time systems and combine them in a system that is more intuitive for novice programmers. This mix between two prevalent paradigms is demonstrated in the above figure. The ability to verify that code is working as expected is a fundamental part of the software development process, and any capable web IDE integrated development environment will provide some means of doing so.

While there have been efforts to compile and evaluate code in the browser, the latency between running your code and seeing the results is still quite high. However, the technology in this domain continues to improve, and may reach the point where the simplicity and latency no longer dissuades developers from using online IDEs.

CodePilot currently found at codepilot. It allows users to import a repository of code from GitHub. Once this is complete, they can edit their project and make a new commit based on their edited version of the document and push the new version back to GitHub. Once a repository has been updated on GitHub, changes can be pulled in from the head of a branch, along with whatever commits that have occurred since the last time CodePilot updated its local copy of the repository. CodePilot Basic Programming Interface.

CodePilot is a tool meant to help people collaborate on code more seamlessly. The collaboration model was based on that of a pilot and a co-pilot, where the pilot does most of the actual programming, and the co-pilot performs background coding tasks. This can include version control management, system testing, online reference lookup, and commenting or documenting source code.

A screenshot of the main programming interface is shown in the above figure. When users first login, they see a link to the configuration panel where they can change which repository and branch they are working on. A list of the files in the repository is presented, with a prompt to begin editing them. This interface is shown in the figure below.

Coming back to the main coding page in the future will simply show the file that was opened last. Clicking on the setup link above will bring them configuration page, where users are able to select which repository and branch they would like to work on. This setup panel is shown in the figure below.

They are also able to view additional information about their account, such as who the other CodePilot collaborators are for their current repository, a link to the GitHub account that created their CodePilot profile, and the option to select which role they would have in the development process.

These roles were designed to guide parallel development, encouraging the pilot to take charge of the software development process and the copilot to help with testing, documentation, and source control. The UI for the copilot does not contain the commit panel, and the order of the testing pane was rearranged to feature the issues and tasks more prominently. The motivation for this was that to make collaboration even easier, a link could be generated that could be sent to anyone, who can drop in on your session without having to login in or be a collaborator of the GitHub repository.

This functionality was not built out however, so the interface differences previously mentioned are the only differences between pilots and copilots. The actual editing pane is based on the popular Ace web editor, which features language recognition, syntax highlighting, and code auto-completion shown in the figure below.

A syncing library ShareJS ShareJS is used to relay edits back to the server and then to all other connected users working on this same project. The file name and path are listed in the upper left corner of the pane, with testing and saving buttons in the upper right. This is to provide easy access to the other cycles of the software development process. CodePilot Autocompletion Example. CodePilot has an integrated activity and chat feed which updates in real time with the actions of each collaborator.

Notifications appear when anyone creates a file, renames a file, opens a file, creates an issue, closes an issue, switches branches, makes a commit, and switches in or out of a repo. It also features a link to opening up a Google Hangouts session where you can video or audio chat with others collaborating on this repository in CodePilot. This feature of CodePilot is displayed in the the task list below. Tasks are able to created, completed and optionally deleted by collaborators.

This system is designed to help outline the work that remains to be done. Working with tasks also triggers the activity feed to update, so the main programmer can see the tasks and links coming in. This decision was made primarily due to the ease of having the browser render these.

Since the browser is already made to render websites from these materials, we hypothesized that it would be a most natural to render basic website code since the synchronous nature of application best fit inside a web browser. It features links back to the coding pane, an option to reload code from the editor and re-render it, and a button to move to the full screen debugger.

A choice was made to separate the code that was being edited and that which was being inspected in the renderer so it would not reset on a tester who was inspecting the code every time that their partner typed in a new character. CodePilot Web Interface Debugger. This allows the pilot to keep making changes while the tester debugs the code that was loaded into the browser, making it easier for the work to be done in parallel. Any change that was made by the pilot will not be loaded into the renderer until the reload button is pressed.

Inside the debugging pane, an iframe with injected code renders the users code, parsed from the HTML, CSS, and Javascript files found in their project. This way, the developers can easily view the output of their code while debugging. It also features support for jQuery, the popular Javascript library that makes accessing the DOM tree more direct.

Finally, in the top-right corner there is a report issue button, which is hooked into GitHub issues and allows users to easily track problems with their code, or make clear certain parts of the site that they want to change. The issue tracker records all of the state of the rendering, and when an issue is generated such as in , it includes a link back to the live, rendered, version of the website. These issues along with any issues imported from GitHub are displayed in the CodePilot testing pane.

Once you click an issue, a dropdown button list is shown, allowing users to view the issue on GitHub, close the issue both in CodePilot and in GitHub , and if the issue was generated by CodePilot view the live demonstration of the rendered web code. This interface is shown in the above figure. CodePilot Issue Management Interface. This is because when an issue is created, the content of each aspect of the renderer HTML, CSS, Javascript, and console output is saved, and can be reloaded into the renderer template.

This issue will be visible to everyone working on the repository or if it is a public repository, then the entire public. An example issue that was generated by CodePilot is shown in as it appears on GitHub. Additionally, the link to the live version where the issue was found does not require users to be logged in with CodePilot, so if there are other collaborators using the standard git platform, they are still able to view and understand the issue.

It should be noted that this testing approach is much more general than web development. Nothing prevents this from being extended to any language or automated testing framework. The testing here could feature sending the code to a server to run test cases, or even compiling to Javascript in the browser in the future with Opal, Emscripten, or other Javascript source compilers Opal.

Users are able to select and import any repository that they are a collaborator on, or repositories that their organization owns and they have access to. This selection pane is shown in the figure below. In addition to this, they are able to easily fork any existing repository through the GitHub API , and begin working on that in Codepilot. Branches can also be browsed and selected, so that you are able to work on any branch from GitHub.

Users are also able to create a new branch based off the your current CodePilot branch, and this change is immediately synced back to with GitHub. CodePilot Repository Selection Interface. Once a repository is imported, you can use the programming interface to edit the contents of any text files that are located. Images in project repositories may be opened, but no interface is provided to edit them.

Also relevant is concurrent programming and browsing - one person codes, the other person reviews the code or requirements documents Dewan et al. Another programming paradigm is a rapid development cycle in which two developers work together in test-driven development, where one of them will work primarily on the implementation and one of them will work primarily on the tests.

This idea was tested with the Collabode system, and the developers reported that this split was very natural Goldman and Miller In a similar vien, PatchWorks provides an interesting methodology on methods for allowing easier navigation of code Henley et al. While CodePilot simply uses a standard single pane text editor, working with more advanced views of code could be integrated into CodePilot.

This could be a shared view that shows which portion of code is currently being viewed by your collaborator. There is also the option of having many people contribute to the codebase, rather than a few trusted collaborators. Systems such as CrowdCode LaToza et al. Fleshing out psuedocode, creating unit tests, and writing additional documentation for a codebase can be effectively distributed many workers, given the appropriate back-end coordination system. Computing education is growing in popularity, as a new CS for all initiative was launched recently.

However, coding is not done in pure isolation, and nearly all production software involves a great deal of collaboration between developers. While there has been much effort in analyzing how content or presentation may be augmented, it is important to also focus on how the methods of collaboration can be improved. When used in educational setting, pair programming serves as effective collaborative learning instance Preston Work has been done that suggests that activity streams with individual programming assignments can positively influence learning outcomes.

This served as a guide when implementing the activity feed. Pair programming can also be a effective to spread expertise among programmers, which is useful information for both industrial and computing education professionals. This adds to the value that programming together has, adding more weight to the argument that collaborating with others not only produces more ideas and potential solutions but also can be a form of training and educating programmers Jones and Fleming When pair programming, students tend to get stuck less and explore ideas more.

Contrastingly, students reported that when programming alone they were more confident and understood their programs better after they were done Simon and Hanks CodePilot seeks to strike a middle ground between these two workflow patterns. Implementing a curriculum where students can collaborate on projects early on can lead to much better retention rates, both in the class and the major Williams et al.

Using the JavaGrinder was as web IDE while pair programming has been found to positively effect student retention in introductory computer science classes. CodePilot can help support this by fostering more collaboration. We hypothesize that combining both real-time and non-real-time collaborative tools will lead to a richer and more cohesive collaborative programming experience, as opposed to either of those methods alone.

Synchronous editing, such as that supported by Google Docs, is excellent at keeping collaborators in tune with what each other is working and focusing on. Seeing edits performed in real time gives a sense of dynamism to the work being done, and allows potential misunderstandings to be cleared easily by presenting the same shared context.

Issues can arise if communications between programmers editing the same codebase suffer significant delay. A common trope of multi-developer version control scenario is the commonality of the merge conflict. Before the second developer pulls from the main repository host GitHub, Bitbucket, etc. When the second developer makes another commit locally based on the last seen commit from GitHub and tries to push it to GitHub, they might see an error like:. This frustrates programmers since they simply want to share their work with their teammates, but now they must coordinate with the first committer and resolve the merge conflict by manually by creating a new version of the code from the two branches which incorporates both changes, or rebasing the head of their local branch off of the newly updated remote and then merging in the changes again.

The benefit of synchronous collaboration systems is that there are no merge conflicts. The syncing mechanism such as Operational Transform automatically merges the changes coming in from each programmer and keeps a single persistent document for all collaborators. A diagram of the differences in merging strategies is shown in the figure below. This is not to say that the synchronous collaborative editor is the perfect programming tool.

Conversely, asynchronous collaboration through version control provides its users with the ability to update their versions of the codebase as they please, rather than keeping a single persistent shared state. Collaboration with version control through platforms such as GitHub and Bitbucket has been steadily growing more popular, and will likely continue to be a way that future developers collaborate together on software projects.

There is often a significant overhead when learning to use git outside of a single developer context for budding coders, though. They are already building their fundamental computer science skills, on top of learning how to use git or mercurial. CodePilot aims to take the best of real-time and non-real-time systems and combine them in a system that is more intuitive for novice programmers. This mix between two prevalent paradigms is demonstrated in the above figure.

The ability to verify that code is working as expected is a fundamental part of the software development process, and any capable web IDE integrated development environment will provide some means of doing so. While there have been efforts to compile and evaluate code in the browser, the latency between running your code and seeing the results is still quite high. However, the technology in this domain continues to improve, and may reach the point where the simplicity and latency no longer dissuades developers from using online IDEs.

CodePilot currently found at codepilot. It allows users to import a repository of code from GitHub. Once this is complete, they can edit their project and make a new commit based on their edited version of the document and push the new version back to GitHub. Once a repository has been updated on GitHub, changes can be pulled in from the head of a branch, along with whatever commits that have occurred since the last time CodePilot updated its local copy of the repository.

CodePilot Basic Programming Interface. CodePilot is a tool meant to help people collaborate on code more seamlessly. The collaboration model was based on that of a pilot and a co-pilot, where the pilot does most of the actual programming, and the co-pilot performs background coding tasks. This can include version control management, system testing, online reference lookup, and commenting or documenting source code.

A screenshot of the main programming interface is shown in the above figure. When users first login, they see a link to the configuration panel where they can change which repository and branch they are working on. A list of the files in the repository is presented, with a prompt to begin editing them.

This interface is shown in the figure below. Coming back to the main coding page in the future will simply show the file that was opened last. Clicking on the setup link above will bring them configuration page, where users are able to select which repository and branch they would like to work on.

This setup panel is shown in the figure below. They are also able to view additional information about their account, such as who the other CodePilot collaborators are for their current repository, a link to the GitHub account that created their CodePilot profile, and the option to select which role they would have in the development process. These roles were designed to guide parallel development, encouraging the pilot to take charge of the software development process and the copilot to help with testing, documentation, and source control.

The UI for the copilot does not contain the commit panel, and the order of the testing pane was rearranged to feature the issues and tasks more prominently. The motivation for this was that to make collaboration even easier, a link could be generated that could be sent to anyone, who can drop in on your session without having to login in or be a collaborator of the GitHub repository.

This functionality was not built out however, so the interface differences previously mentioned are the only differences between pilots and copilots. The actual editing pane is based on the popular Ace web editor, which features language recognition, syntax highlighting, and code auto-completion shown in the figure below. A syncing library ShareJS ShareJS is used to relay edits back to the server and then to all other connected users working on this same project.

The file name and path are listed in the upper left corner of the pane, with testing and saving buttons in the upper right. This is to provide easy access to the other cycles of the software development process. CodePilot Autocompletion Example. CodePilot has an integrated activity and chat feed which updates in real time with the actions of each collaborator. Notifications appear when anyone creates a file, renames a file, opens a file, creates an issue, closes an issue, switches branches, makes a commit, and switches in or out of a repo.

It also features a link to opening up a Google Hangouts session where you can video or audio chat with others collaborating on this repository in CodePilot. This feature of CodePilot is displayed in the the task list below. Tasks are able to created, completed and optionally deleted by collaborators. This system is designed to help outline the work that remains to be done. Working with tasks also triggers the activity feed to update, so the main programmer can see the tasks and links coming in.

This decision was made primarily due to the ease of having the browser render these. Since the browser is already made to render websites from these materials, we hypothesized that it would be a most natural to render basic website code since the synchronous nature of application best fit inside a web browser. It features links back to the coding pane, an option to reload code from the editor and re-render it, and a button to move to the full screen debugger.

A choice was made to separate the code that was being edited and that which was being inspected in the renderer so it would not reset on a tester who was inspecting the code every time that their partner typed in a new character. CodePilot Web Interface Debugger. This allows the pilot to keep making changes while the tester debugs the code that was loaded into the browser, making it easier for the work to be done in parallel.

Any change that was made by the pilot will not be loaded into the renderer until the reload button is pressed. Inside the debugging pane, an iframe with injected code renders the users code, parsed from the HTML, CSS, and Javascript files found in their project. This way, the developers can easily view the output of their code while debugging. It also features support for jQuery, the popular Javascript library that makes accessing the DOM tree more direct.

Finally, in the top-right corner there is a report issue button, which is hooked into GitHub issues and allows users to easily track problems with their code, or make clear certain parts of the site that they want to change. The issue tracker records all of the state of the rendering, and when an issue is generated such as in , it includes a link back to the live, rendered, version of the website. These issues along with any issues imported from GitHub are displayed in the CodePilot testing pane.

Once you click an issue, a dropdown button list is shown, allowing users to view the issue on GitHub, close the issue both in CodePilot and in GitHub , and if the issue was generated by CodePilot view the live demonstration of the rendered web code. This interface is shown in the above figure. CodePilot Issue Management Interface. This is because when an issue is created, the content of each aspect of the renderer HTML, CSS, Javascript, and console output is saved, and can be reloaded into the renderer template.

This issue will be visible to everyone working on the repository or if it is a public repository, then the entire public. An example issue that was generated by CodePilot is shown in as it appears on GitHub. Additionally, the link to the live version where the issue was found does not require users to be logged in with CodePilot, so if there are other collaborators using the standard git platform, they are still able to view and understand the issue.

It should be noted that this testing approach is much more general than web development. Nothing prevents this from being extended to any language or automated testing framework. The testing here could feature sending the code to a server to run test cases, or even compiling to Javascript in the browser in the future with Opal, Emscripten, or other Javascript source compilers Opal.

Users are able to select and import any repository that they are a collaborator on, or repositories that their organization owns and they have access to. This selection pane is shown in the figure below. In addition to this, they are able to easily fork any existing repository through the GitHub API , and begin working on that in Codepilot.

Branches can also be browsed and selected, so that you are able to work on any branch from GitHub. Users are also able to create a new branch based off the your current CodePilot branch, and this change is immediately synced back to with GitHub. CodePilot Repository Selection Interface.

Once a repository is imported, you can use the programming interface to edit the contents of any text files that are located. Images in project repositories may be opened, but no interface is provided to edit them. Once any change is loaded into the renderer or the refresh button is pressed, a difference will be generated. CodePilot File Management Interface. There is a small reset button in the top right section of each diff, so that the user may reset changes that were made but does not want to commit.

This will pull down the latest commits from GitHub and load that version of the project into CodePilot. CodePilot Code Diffing Interface. The commit panel is only visible to pilots, excluding copilots. This goes with our theme of having the main pilot have the final say over what gets committed, but allowing others to help out on the code. Once a commit has been made, the differences will be reset, and the commit that was just created and pushed will be added to the list of commits in both CodePilot and GitHub.

This is demonstrated in the figure below. There is the possible use case of having a single main developer who frames the code and specifications, then guides other developers as they implement the basics. Additionally, this system could be used in a scenario where the pilot seeks help on a specific problem, and allows a copilot to enter the session and try to solve it.

The pilot still retains the sole access to push new versions of code to GitHub, but can now seek help from a broader pool of developers. We developed CodePilot , a real time collaborative text editor with GitHub integration. We wanted to test whether this tool allows novice programmers to effectively use the git version control system in a collaborative environment, and whether the development tools inside CodePilot encourage members to parallelize their development efforts.

We recruited six pairs of students that were familiar with both web development and version control to participate in an 1 hour study evaluating how CodePilot performed as a collaborative development tool. We also took screen recordings of 10 out of the 12 study participants. The reason for not recording screencasts of the last 2 participants was that they did not have any screen recording software installed, and we were not prepared with a screen recorder for their operating system.

To avoid the study going over the allotted time, we continued without recording the screens of these two participants. All were fairly experienced with version control and web development, as shown in and. The study had eight male and four female students.

There were two graduate students, six seniors, three juniors, and one sophomore, represented in the figures below. Participant Version Control Skill. Participant Web Programming Skill. Participants were assigned the following web programming tasks with a single teammate emulating pair programming , and encouraged to complete as many of them as possible in a 30 minute time frame that was allocated in the middle of the experimental session.

The original repo with instructions can be found here:. Upon completion or the passing of 30 minutes from when the tasks were started, the first person who forked the repository would make a final commit of what they had to their version of the forked original repository.

Each participant would then complete a brief interview together about their experiences developing with CodePilot was like. They also were asked to complete a demographic survey afterwards, which asked about their student status year , gender, and web programming and version control experience. We also performed a short interview of both partners after programming together to learn more about their experience interacting with the system.

When each pair of students first arrived at the session, we discussed what the study would go over, had them sign consent forms for participating as part of our IRB review process, and then gave them an overview of CodePilot. They were instructed that they could leave at anytime and there would be no negative repercussions for them. After the initial overview and our CodePilot explanation and demonstration, they were given a set of web development tasks, divided up into the structure of the page HTML , the style of the page CSS , and the data and interactivity of the page Javascript.

The focus is less on what the task is though, and more on how they worked together to more efficiently complete these tasks. One could note that the division of these tasks could have lent itself to easier pair programming, since the tasks were already categorized into the type of work they required and also the file that work would be done in.

In hindsight, it would have been ideal to perform this study on public Mac computers, since those would have screen recording software built in, and did not want to take time to install additional screen recording software. Thus our data is somewhat fragmented, as we cannot entirely quantify the actions of those last two participants.

Ample qualitative notes were taken during the study however, and there was at least one screencast generated per session. Through the study, we measured the amounts of commits total and per team member. For those that were able to provide a screencast, we measured their time on task, the amount of web searches, and the amount of context switches from their screen recordings of their study sessions.

After the collaborative programming session, each pair was interviewed about what their experience using CodePilot to collaborate on web development was like. They were also asked about how it compared to more traditional, asynchronous collaborative workflows namely collaboration using git or other distributed version control systems.

I think its like a different kind of workflow. We were only able to do that because we were right next to each other at the same time… like for that, I think it was really great. It was great for pair programming. GitHub is always going to be the collaboration tool for large scale projects, but if you want to real time collaborate, this is perfect.

GitHub is definitely not for real time, I am not expecting to collaborate on the same code at the same time, or there will be a ton of merge conflicts. Sometimes it can get in the way if you are trying to get something done and there is a merge conflict it just takes more time, its annoying. Another echoed that, while also noting some of the downsides that come with real time synchronization:. It was nice to see changes being made in real time. When asked about if they had to work with another programmer who was not as experienced with version control if this would be a helpful tool, participants again agreed that it would be much easier to use than teaching that person all of how to use git, avoiding the headache of merge conflicts.

HOW TO WRITE A PROXY SERVLET

Your love and guidance showed me the importance of caring for others and working to benefit your greater community. I thank my research adviser Philip Guo for providing consistent support and invaluable advice. Working with you has been an absolute pleasure, and helped me grow both as a researcher and as a human being. I am also thankful to Dean Wendi Heinzelman for guiding my work in your research lab prior to my working with Professor Guo, as well as supervising my senior design project.

Your concise judgment and willingness to help were critical in many of my successes. Thank you to Professor Chen Ding, for reminding me that there is beauty to be found in the winter, where stars sharpen and glitter. Finally, thank you to the countless others that I have met and worked with at the University of Rochester. It brings me great joy to be a part of such a vibrant and positive environment weather notwithstanding. This thesis analyzes perceptions towards collaborating with version control and introduces a new system, CodePilot, for project-wide synchronous collaborative programming backed by version control.

We review our study of programmers using the system to collaborate on web development tasks, and suggest that combining synchronous collaborative programming with version control as asynchronous collaboration is a novel, powerful paradigm in programmer collaboration. It not only makes version control more accessible for novice programmers, but prompts more experienced programmers to coordinate and parallelize their development efforts.

All work conducted for the thesis was completed by the student independently. Software development is becoming more collaborative, popularized by GitHub and the open source movement. CodePilot is a web integrated development environment IDE which combines synchronous and asynchronous collaboration. It does this by allowing users to import any public repository of code from GitHub into CodePilot, where it syncs the state of the project across multiple users in real-time.

It does this in a fashion similar to that of Google Docs or other real-time online editors. However, CodePilot is not only limited to a single buffer of text and supports syncing changes across many files simultaneously. There are two main modes of synchronization in collaboration: real-time and non-real-time. Real-time synchronization usually applies operational transform syncing to maintain a persistent single state of a document as changes come in from multiple sources Fraser This is the technology that supports Google Docs and Spreadsheets - all edits are seen in real time.

There are also non-real-time collaboration systems, such as distributed version control. In this model, multiple copies of the same codebase are allowed to exist in different states, and periodically update themselves from each other. Commonly there is still a centralized repository host such as GitHub , and teams will use branches to split changes, or break the codebase into different relevant repositories if the complexity deems it necessary.

Coding with others cohesively is hard. This difficulty generally grows when distributed version control is used, since more people can program together using version control when compared to traditional pair programming. This often leads to frustration and an initial distaste for version control.

The budding programmer now must not only must learn the core computer science fundamentals, but become proficient with this new and unfamiliar system. Compare this to collaboration with Google Docs: powerful real-time syncing mechanisms allow users to work on the same document and see each others changes as they happen. This feature is heralded as revolutionizing document collaboration and often credited for allowing Google to weaken the stranglehold that Microsoft Office previously had on the document editing market.

Asynchronous version control such as git or mercurial provides a concise, discrete history of the changes that a codebase has endured. Each code save-point in version control known as a commit is labeled with a message which is generally used to describe what semantic meaning the change has, who wrote it, when it was wrote, and what exactly was changed. It may not be the most intuitive tool to learn how to use, but it has been embraced by the professional and open source software development communities, with GitHub hosting over 35 million git and subversion repositories from 14 million users GitHub Both of these collaboration methods provide unique benefits to programmers, but there has not been major implementations of collaborative programming systems which combine these two methods.

CodePilot supports both real-time and non-real-time collaborative editing, finally bringing together real-time programming and non-real-time collaboration. It allows its users to import a repository of code from GitHub and start collaborating synchronously on a project, and still periodically commit updated versions.

The larger a software team grows, the more overhead in communication and synchronization there is. People are less able to collaborate effectively on a project due to this overhead Brooks The relationship between workers and productivity in software is complex: perhaps 2 workers could complete a project faster than a single worker, but what about workers?

Designing and writing software is an incredibly complex process, and combining this with the coordination required for software teams to work efficiently may actually make smaller teams perform better than larger teams. According to Brooks, there are four essential difficulties that the essence of software contains:. CodePilot aims to tackle some of the challenges presented from these difficulties. CodePilot increases visibility through its web renderer, allowing programmers to see the representation of their code.

It handles changeability with its operational transform syncing mechanism and the GitHub-backed repository branching and version control. It encourages conformity with its HTML, CSS, and Javascript debugger and its GitHub issue integration, by allowing revisions of the software to be examined and marked with any errors that are found. Complexity is not directly handled by CodePilot, but other tools such as Python Tutor offer in-browser tools that help with both invisibility and better understanding complexity even if not reducing it Guo Web browsers are an essential part of modern computer use, and developers frequently use them to access the internet, looking up documentation or asking questions on StackOverflow Brandt et al.

Increasingly, sites have come out such as HackerRank, Interview Cake or Python Tutor which allow users to evaluate dynamic code execution in the browser. One limitation of these sites is that they usually limit evaluation targets to code snippets that cannot be very complex. There is very limited support for executing larger projects, although continuous integration testing sites such as Travis-CI allow this. Dynamic user interfaces are not easily tested, but our feedback generation tool captures a significant amount of relevant information about the page, creates a GitHub link with the entire state of the page and provides a link for the issue to be re-rendered and examined by others in the future.

It does not entirely address software complexity, since evaluating the correctness of code automatically in the browser is a problem that is not fully solved. CodePilot allows novice programmers to use version control together, in a manner that promotes self-efficacy and reduces frustration. The key findings are that a mix of real-time and non-real-time version control systems can improve novice programmers sense of self-efficacy when using version control systems, and also that they can be used to help parallelize software development and reduce the amount of unnecessary merge conflicts.

We will discuss relevant collaborative editors, pair programming and education research, the sync-async collaboration paradigm, the CodePilot system implementation, evaluation of the CodePilot system, results of the evaluation study, discussion of study results, and finally conclusions and future work.

A good amount of relevant work has been done on other real-time collaborative editors, as well as editors that integrate more blended forms of asynchronous and synchronous collaboration features. There are also relevant studies of how people work best together on software projects, along with studies of how effective different types of pairs of students are together. This body of work was influential on the design of CodePilot.

Collaborative learning and education is an active area of research which explores how students best work together. This work effects teaching practices, and therefore students who later become developers who collectively shape industry practice. Increasingly, code is stored and distributed on GitHub, the popular git repository hosting website.

It can act as a library of guides and example code for beginners to work through. GitHub also offers a dedicated educational tool, GitHub Classroom, allowing programmers to easily learn both version control and coding fundamentals GitHub Even so, this often focuses on non-real time collaboration or single developer workflows. Still, there is exciting work being done on how collaborative editors can allow programmers to work together more effectively both synchronously and asynchronously.

These are less tied to version control than CodePilot, and mainly provide a real time syncing mechanism. More recently, there is MadEye and Cloud9 - web editors that allow you to share your session with someone else MadEye ; Cloud9 Both of these make great improvements over traditional pair programming schemes, but are designed for simply dropping in and solving an issue with the code.

One notable system that provides a similar intermediate mix of real-time and non-real-time collaboration is Collabode Goldman, Little, and Miller , which allowed users to have concurrent editors, but filtered out the error messages a single user would see to those that they themselves had generated. Merging actual copies of divergent copies of code could be delayed until the errors generated from the changes had been resolved, efficiently combining real-time changes with a software verification gating system.

Other tools such as Syde seek to better synchronize developer awareness by providing contextual awareness beyond version control changes, by notifying developers of changes in source code in real time Hattori and Lanza Developers use the internet as a resource to learn and remind themselves of coding concepts or syntax.

Some developers even reported visiting the same site many times, acting as a sort of external memory bank. As the code stored on the internet grows, example-centric programming will become more popular, as developers fork relevant code and modify it to their ends Brandt et al. A web IDE such as CodePilot allows and encourages this information to be cached and accessed with less of a major context switch, as the user remains in the browser.

In a large quantitative study, code produced from pair programming contained fewer bugs, leading to overall higher quality code Williams et al. There is also something to be said about the social dynamics of working together, specifically between pairs in pair programming Thomas, Ratcliffe, and Robertson If there is a mutual perception of technical capabilities, then pairs worked better together.

This is opposed to pairs where skilled programmers work with novice programmers. Furthermore, students with a good amount of confidence enjoy the pair programming experience most and students did their best work when working with similarly skilled programmers Katira, Williams, and Osborne Overall, students liked pair programming and believe that it helped them achieve effective solutions. Side by side programming is another paradigm where people are at adjacent workstations, and both work on coding, differs from co-piloting code.

They cite a study comparing distributed and co-located pair programming: distance does not matter. Also relevant is concurrent programming and browsing - one person codes, the other person reviews the code or requirements documents Dewan et al. Another programming paradigm is a rapid development cycle in which two developers work together in test-driven development, where one of them will work primarily on the implementation and one of them will work primarily on the tests.

This idea was tested with the Collabode system, and the developers reported that this split was very natural Goldman and Miller In a similar vien, PatchWorks provides an interesting methodology on methods for allowing easier navigation of code Henley et al. While CodePilot simply uses a standard single pane text editor, working with more advanced views of code could be integrated into CodePilot.

This could be a shared view that shows which portion of code is currently being viewed by your collaborator. There is also the option of having many people contribute to the codebase, rather than a few trusted collaborators. Systems such as CrowdCode LaToza et al. Fleshing out psuedocode, creating unit tests, and writing additional documentation for a codebase can be effectively distributed many workers, given the appropriate back-end coordination system.

Computing education is growing in popularity, as a new CS for all initiative was launched recently. However, coding is not done in pure isolation, and nearly all production software involves a great deal of collaboration between developers. While there has been much effort in analyzing how content or presentation may be augmented, it is important to also focus on how the methods of collaboration can be improved.

When used in educational setting, pair programming serves as effective collaborative learning instance Preston Work has been done that suggests that activity streams with individual programming assignments can positively influence learning outcomes. This served as a guide when implementing the activity feed. Pair programming can also be a effective to spread expertise among programmers, which is useful information for both industrial and computing education professionals.

This adds to the value that programming together has, adding more weight to the argument that collaborating with others not only produces more ideas and potential solutions but also can be a form of training and educating programmers Jones and Fleming When pair programming, students tend to get stuck less and explore ideas more.

Contrastingly, students reported that when programming alone they were more confident and understood their programs better after they were done Simon and Hanks CodePilot seeks to strike a middle ground between these two workflow patterns. Implementing a curriculum where students can collaborate on projects early on can lead to much better retention rates, both in the class and the major Williams et al.

Using the JavaGrinder was as web IDE while pair programming has been found to positively effect student retention in introductory computer science classes. CodePilot can help support this by fostering more collaboration. We hypothesize that combining both real-time and non-real-time collaborative tools will lead to a richer and more cohesive collaborative programming experience, as opposed to either of those methods alone.

Synchronous editing, such as that supported by Google Docs, is excellent at keeping collaborators in tune with what each other is working and focusing on. Seeing edits performed in real time gives a sense of dynamism to the work being done, and allows potential misunderstandings to be cleared easily by presenting the same shared context. Issues can arise if communications between programmers editing the same codebase suffer significant delay.

A common trope of multi-developer version control scenario is the commonality of the merge conflict. Before the second developer pulls from the main repository host GitHub, Bitbucket, etc. When the second developer makes another commit locally based on the last seen commit from GitHub and tries to push it to GitHub, they might see an error like:.

This frustrates programmers since they simply want to share their work with their teammates, but now they must coordinate with the first committer and resolve the merge conflict by manually by creating a new version of the code from the two branches which incorporates both changes, or rebasing the head of their local branch off of the newly updated remote and then merging in the changes again. The benefit of synchronous collaboration systems is that there are no merge conflicts.

The syncing mechanism such as Operational Transform automatically merges the changes coming in from each programmer and keeps a single persistent document for all collaborators. A diagram of the differences in merging strategies is shown in the figure below. This is not to say that the synchronous collaborative editor is the perfect programming tool. Conversely, asynchronous collaboration through version control provides its users with the ability to update their versions of the codebase as they please, rather than keeping a single persistent shared state.

Collaboration with version control through platforms such as GitHub and Bitbucket has been steadily growing more popular, and will likely continue to be a way that future developers collaborate together on software projects. There is often a significant overhead when learning to use git outside of a single developer context for budding coders, though. They are already building their fundamental computer science skills, on top of learning how to use git or mercurial.

CodePilot aims to take the best of real-time and non-real-time systems and combine them in a system that is more intuitive for novice programmers. This mix between two prevalent paradigms is demonstrated in the above figure. The ability to verify that code is working as expected is a fundamental part of the software development process, and any capable web IDE integrated development environment will provide some means of doing so.

While there have been efforts to compile and evaluate code in the browser, the latency between running your code and seeing the results is still quite high. However, the technology in this domain continues to improve, and may reach the point where the simplicity and latency no longer dissuades developers from using online IDEs. CodePilot currently found at codepilot.

It allows users to import a repository of code from GitHub. Once this is complete, they can edit their project and make a new commit based on their edited version of the document and push the new version back to GitHub. Once a repository has been updated on GitHub, changes can be pulled in from the head of a branch, along with whatever commits that have occurred since the last time CodePilot updated its local copy of the repository.

CodePilot Basic Programming Interface. CodePilot is a tool meant to help people collaborate on code more seamlessly. The collaboration model was based on that of a pilot and a co-pilot, where the pilot does most of the actual programming, and the co-pilot performs background coding tasks.

This can include version control management, system testing, online reference lookup, and commenting or documenting source code. A screenshot of the main programming interface is shown in the above figure. When users first login, they see a link to the configuration panel where they can change which repository and branch they are working on.

A list of the files in the repository is presented, with a prompt to begin editing them. This interface is shown in the figure below. Coming back to the main coding page in the future will simply show the file that was opened last. Clicking on the setup link above will bring them configuration page, where users are able to select which repository and branch they would like to work on.

This setup panel is shown in the figure below. They are also able to view additional information about their account, such as who the other CodePilot collaborators are for their current repository, a link to the GitHub account that created their CodePilot profile, and the option to select which role they would have in the development process. These roles were designed to guide parallel development, encouraging the pilot to take charge of the software development process and the copilot to help with testing, documentation, and source control.

The UI for the copilot does not contain the commit panel, and the order of the testing pane was rearranged to feature the issues and tasks more prominently. The motivation for this was that to make collaboration even easier, a link could be generated that could be sent to anyone, who can drop in on your session without having to login in or be a collaborator of the GitHub repository. This functionality was not built out however, so the interface differences previously mentioned are the only differences between pilots and copilots.

The actual editing pane is based on the popular Ace web editor, which features language recognition, syntax highlighting, and code auto-completion shown in the figure below. A syncing library ShareJS ShareJS is used to relay edits back to the server and then to all other connected users working on this same project. The file name and path are listed in the upper left corner of the pane, with testing and saving buttons in the upper right.

This is to provide easy access to the other cycles of the software development process. CodePilot Autocompletion Example. CodePilot has an integrated activity and chat feed which updates in real time with the actions of each collaborator. Notifications appear when anyone creates a file, renames a file, opens a file, creates an issue, closes an issue, switches branches, makes a commit, and switches in or out of a repo. It also features a link to opening up a Google Hangouts session where you can video or audio chat with others collaborating on this repository in CodePilot.

This feature of CodePilot is displayed in the the task list below. Tasks are able to created, completed and optionally deleted by collaborators. This system is designed to help outline the work that remains to be done. The ability to verify that code is working as expected is a fundamental part of the software development process, and any capable web IDE integrated development environment will provide some means of doing so.

While there have been efforts to compile and evaluate code in the browser, the latency between running your code and seeing the results is still quite high. However, the technology in this domain continues to improve, and may reach the point where the simplicity and latency no longer dissuades developers from using online IDEs.

CodePilot currently found at codepilot. It allows users to import a repository of code from GitHub. Once this is complete, they can edit their project and make a new commit based on their edited version of the document and push the new version back to GitHub. Once a repository has been updated on GitHub, changes can be pulled in from the head of a branch, along with whatever commits that have occurred since the last time CodePilot updated its local copy of the repository.

CodePilot Basic Programming Interface. CodePilot is a tool meant to help people collaborate on code more seamlessly. The collaboration model was based on that of a pilot and a co-pilot, where the pilot does most of the actual programming, and the co-pilot performs background coding tasks. This can include version control management, system testing, online reference lookup, and commenting or documenting source code. A screenshot of the main programming interface is shown in the above figure.

When users first login, they see a link to the configuration panel where they can change which repository and branch they are working on. A list of the files in the repository is presented, with a prompt to begin editing them. This interface is shown in the figure below. Coming back to the main coding page in the future will simply show the file that was opened last. Clicking on the setup link above will bring them configuration page, where users are able to select which repository and branch they would like to work on.

This setup panel is shown in the figure below. They are also able to view additional information about their account, such as who the other CodePilot collaborators are for their current repository, a link to the GitHub account that created their CodePilot profile, and the option to select which role they would have in the development process.

These roles were designed to guide parallel development, encouraging the pilot to take charge of the software development process and the copilot to help with testing, documentation, and source control. The UI for the copilot does not contain the commit panel, and the order of the testing pane was rearranged to feature the issues and tasks more prominently. The motivation for this was that to make collaboration even easier, a link could be generated that could be sent to anyone, who can drop in on your session without having to login in or be a collaborator of the GitHub repository.

This functionality was not built out however, so the interface differences previously mentioned are the only differences between pilots and copilots. The actual editing pane is based on the popular Ace web editor, which features language recognition, syntax highlighting, and code auto-completion shown in the figure below.

A syncing library ShareJS ShareJS is used to relay edits back to the server and then to all other connected users working on this same project. The file name and path are listed in the upper left corner of the pane, with testing and saving buttons in the upper right.

This is to provide easy access to the other cycles of the software development process. CodePilot Autocompletion Example. CodePilot has an integrated activity and chat feed which updates in real time with the actions of each collaborator. Notifications appear when anyone creates a file, renames a file, opens a file, creates an issue, closes an issue, switches branches, makes a commit, and switches in or out of a repo.

It also features a link to opening up a Google Hangouts session where you can video or audio chat with others collaborating on this repository in CodePilot. This feature of CodePilot is displayed in the the task list below. Tasks are able to created, completed and optionally deleted by collaborators. This system is designed to help outline the work that remains to be done. Working with tasks also triggers the activity feed to update, so the main programmer can see the tasks and links coming in.

This decision was made primarily due to the ease of having the browser render these. Since the browser is already made to render websites from these materials, we hypothesized that it would be a most natural to render basic website code since the synchronous nature of application best fit inside a web browser.

It features links back to the coding pane, an option to reload code from the editor and re-render it, and a button to move to the full screen debugger. A choice was made to separate the code that was being edited and that which was being inspected in the renderer so it would not reset on a tester who was inspecting the code every time that their partner typed in a new character. CodePilot Web Interface Debugger.

This allows the pilot to keep making changes while the tester debugs the code that was loaded into the browser, making it easier for the work to be done in parallel. Any change that was made by the pilot will not be loaded into the renderer until the reload button is pressed. Inside the debugging pane, an iframe with injected code renders the users code, parsed from the HTML, CSS, and Javascript files found in their project.

This way, the developers can easily view the output of their code while debugging. It also features support for jQuery, the popular Javascript library that makes accessing the DOM tree more direct. Finally, in the top-right corner there is a report issue button, which is hooked into GitHub issues and allows users to easily track problems with their code, or make clear certain parts of the site that they want to change.

The issue tracker records all of the state of the rendering, and when an issue is generated such as in , it includes a link back to the live, rendered, version of the website. These issues along with any issues imported from GitHub are displayed in the CodePilot testing pane. Once you click an issue, a dropdown button list is shown, allowing users to view the issue on GitHub, close the issue both in CodePilot and in GitHub , and if the issue was generated by CodePilot view the live demonstration of the rendered web code.

This interface is shown in the above figure. CodePilot Issue Management Interface. This is because when an issue is created, the content of each aspect of the renderer HTML, CSS, Javascript, and console output is saved, and can be reloaded into the renderer template.

This issue will be visible to everyone working on the repository or if it is a public repository, then the entire public. An example issue that was generated by CodePilot is shown in as it appears on GitHub.

Additionally, the link to the live version where the issue was found does not require users to be logged in with CodePilot, so if there are other collaborators using the standard git platform, they are still able to view and understand the issue. It should be noted that this testing approach is much more general than web development.

Nothing prevents this from being extended to any language or automated testing framework. The testing here could feature sending the code to a server to run test cases, or even compiling to Javascript in the browser in the future with Opal, Emscripten, or other Javascript source compilers Opal. Users are able to select and import any repository that they are a collaborator on, or repositories that their organization owns and they have access to.

This selection pane is shown in the figure below. In addition to this, they are able to easily fork any existing repository through the GitHub API , and begin working on that in Codepilot. Branches can also be browsed and selected, so that you are able to work on any branch from GitHub. Users are also able to create a new branch based off the your current CodePilot branch, and this change is immediately synced back to with GitHub.

CodePilot Repository Selection Interface. Once a repository is imported, you can use the programming interface to edit the contents of any text files that are located. Images in project repositories may be opened, but no interface is provided to edit them. Once any change is loaded into the renderer or the refresh button is pressed, a difference will be generated. CodePilot File Management Interface. There is a small reset button in the top right section of each diff, so that the user may reset changes that were made but does not want to commit.

This will pull down the latest commits from GitHub and load that version of the project into CodePilot. CodePilot Code Diffing Interface. The commit panel is only visible to pilots, excluding copilots. This goes with our theme of having the main pilot have the final say over what gets committed, but allowing others to help out on the code. Once a commit has been made, the differences will be reset, and the commit that was just created and pushed will be added to the list of commits in both CodePilot and GitHub.

This is demonstrated in the figure below. There is the possible use case of having a single main developer who frames the code and specifications, then guides other developers as they implement the basics. Additionally, this system could be used in a scenario where the pilot seeks help on a specific problem, and allows a copilot to enter the session and try to solve it.

The pilot still retains the sole access to push new versions of code to GitHub, but can now seek help from a broader pool of developers. We developed CodePilot , a real time collaborative text editor with GitHub integration. We wanted to test whether this tool allows novice programmers to effectively use the git version control system in a collaborative environment, and whether the development tools inside CodePilot encourage members to parallelize their development efforts.

We recruited six pairs of students that were familiar with both web development and version control to participate in an 1 hour study evaluating how CodePilot performed as a collaborative development tool. We also took screen recordings of 10 out of the 12 study participants.

The reason for not recording screencasts of the last 2 participants was that they did not have any screen recording software installed, and we were not prepared with a screen recorder for their operating system. To avoid the study going over the allotted time, we continued without recording the screens of these two participants. All were fairly experienced with version control and web development, as shown in and.

The study had eight male and four female students. There were two graduate students, six seniors, three juniors, and one sophomore, represented in the figures below. Participant Version Control Skill. Participant Web Programming Skill.

Participants were assigned the following web programming tasks with a single teammate emulating pair programming , and encouraged to complete as many of them as possible in a 30 minute time frame that was allocated in the middle of the experimental session. The original repo with instructions can be found here:. Upon completion or the passing of 30 minutes from when the tasks were started, the first person who forked the repository would make a final commit of what they had to their version of the forked original repository.

Each participant would then complete a brief interview together about their experiences developing with CodePilot was like. They also were asked to complete a demographic survey afterwards, which asked about their student status year , gender, and web programming and version control experience. We also performed a short interview of both partners after programming together to learn more about their experience interacting with the system.

When each pair of students first arrived at the session, we discussed what the study would go over, had them sign consent forms for participating as part of our IRB review process, and then gave them an overview of CodePilot. They were instructed that they could leave at anytime and there would be no negative repercussions for them. After the initial overview and our CodePilot explanation and demonstration, they were given a set of web development tasks, divided up into the structure of the page HTML , the style of the page CSS , and the data and interactivity of the page Javascript.

The focus is less on what the task is though, and more on how they worked together to more efficiently complete these tasks. One could note that the division of these tasks could have lent itself to easier pair programming, since the tasks were already categorized into the type of work they required and also the file that work would be done in. In hindsight, it would have been ideal to perform this study on public Mac computers, since those would have screen recording software built in, and did not want to take time to install additional screen recording software.

Thus our data is somewhat fragmented, as we cannot entirely quantify the actions of those last two participants. Ample qualitative notes were taken during the study however, and there was at least one screencast generated per session. Through the study, we measured the amounts of commits total and per team member. For those that were able to provide a screencast, we measured their time on task, the amount of web searches, and the amount of context switches from their screen recordings of their study sessions.

After the collaborative programming session, each pair was interviewed about what their experience using CodePilot to collaborate on web development was like. They were also asked about how it compared to more traditional, asynchronous collaborative workflows namely collaboration using git or other distributed version control systems. I think its like a different kind of workflow. We were only able to do that because we were right next to each other at the same time… like for that, I think it was really great.

It was great for pair programming. GitHub is always going to be the collaboration tool for large scale projects, but if you want to real time collaborate, this is perfect. GitHub is definitely not for real time, I am not expecting to collaborate on the same code at the same time, or there will be a ton of merge conflicts. Sometimes it can get in the way if you are trying to get something done and there is a merge conflict it just takes more time, its annoying.

Another echoed that, while also noting some of the downsides that come with real time synchronization:. It was nice to see changes being made in real time. When asked about if they had to work with another programmer who was not as experienced with version control if this would be a helpful tool, participants again agreed that it would be much easier to use than teaching that person all of how to use git, avoiding the headache of merge conflicts.

Finally, another student told of how they had branched off on a project when working with others, and the large amount of merge conflicts when they tried to bring in their code:. Our participants maintained that version control is an essential skill which is worth learning, but can be challenging at first.

One suggested that a system as CodePilot could be nice to include novice programmers, slowly introducing them to version control concepts such as commits and branches which CodePilot supports :. Git is super useful to fully know… but that being said, this is definitely a good starting place so that they can at least have the idea that a commit is a save point in the code that they can go back to, and then later on introduce branches.

Overall, using a synchronous editor was found to be better at keeping developers in the same context than a standard distributed workflow, where programmers edit different code bases and then later merge them together. On the other hand, there is the chance that something will be edited by your collaborator, which would then impact what you were working on. One of the benefits of having a broad web editor is the diminished need to perform context switching, and the corresponding avoidance of mental flow disruptions.

Your partner can easily send you relevant links or even create a branch from the current system without having to distract you from whatever coding task you are working on. When asked if they had a good sense of what their teammate was doing, students responded positively, noting that the integrated activity feed helped them stay synced up:.

Participants tended to immediately divide up the work and then work on the separate parts right from the initial starting up. This would not be a conflict in traditional development workflows, but you would still face the problem of later merging code back into the central hosted repository and resolving whatever conflicts could be generated from that.

Interestingly, the distribution of commits between team members was distributed in a manner almost as if we had enforced the pilot and copilot programming schemes. On almost every team, there was one person who took over the version control duties, making all the commits as seen in the figure below.

There was one team where both partners authored and pushed commits back to GitHub, but they verbally communicated this, so there was some additional communication. This suggests that people work well when they split up the work, and make clear roles for themselves even if they are not assigned. When asked if using CodePilot was enjoyable to use, all participants generally responded positively.

One noted the unique workflow that it encouraged:. Overall, using it was a pretty pleasant experience, had a lot of fun. I would be a little bit worried using that as an alternative to version control, since I think it is important to learn how to use version control. We added the ability to check out any single commit, or the head of the current branch that they were on.

This provided users more flexibility in the state of the code that they were editing in the browser, if they wanted to check out what the state of code was at a given commit. CodePilot File Resetting Addition. This included improving the file contents difference recognition mechanism, so users could preview what the differences were between the cached version of their project and the last committed version from GitHub. It also provides users with the options to reset a file back to how it was from the last commit if they accidentally change a file that they did not mean to change.

This is shown in the figure above. We also improved the commit interface, notably disabling the ability to commit anything if there were no differences between the current state of the project in CodePilot and the latest version that was pulled in from GitHub, shown in the figure above.

Finally, we augmented navigation between code modes editing, testing, and saving so that the switching was less of a mental barrier, and allowed them to do so more easily. One of the most requested features in the feedback was to be able to see their collaborators cursors, but this has not been implemented at the time of writing. No longer does the single genius hack away in isolation to bring about the latest innovation. However, parallelization of software development is an incredibly complex task, noted famously by Fred Brooks in the mythical man month Brooks As the future generations of software developers gets trained, it is important to reconsider how we work together on large pieces of complex software, and to ponder on whether there are better ways that collaboration could be done.

Other modes of task collaboration could be explored, such as implementing a specification test from design documents, while others begin writing the implementation. Frequent checks and syncing mechanisms help avoid the large overhead of syncing massive code changes together. While making commits frequently and atomically is broadly considered best practice, more software can be developed that helps share and encourage these best practices. Developers could begin to embrace a broader set of collaborative models besides the traditional centralized repository, expanding the abilities teams to work dynamically, and for the relevant help to jump in more easily.

This could possibly be in return for a financial reward, creating bounty hunter style developers. In order for this to work there would be a need to objectively verify that the software bug as described in however it was advertised had since been removed after the novice was helped. One very viable route that online code evaluations systems could proceed in is extending CodePilot or other collaborative systems to allow the execution of arbitrary code in a browser sandbox, or improve the interfaces to back-end server compilers.

Languages such as Ruby already have an implementation in Javascript, the core language that modern web browsers execute. This implementation is called Opal. Currently, the committing pane of CodePilot where users make new commits is limited to committing entire files or sets of files.

ARGUMENT ESSAY SAMPLE FORMAT

CodePilot seeks to strike a middle ground between these two workflow patterns. Implementing a curriculum where students can collaborate on projects early on can lead to much better retention rates, both in the class and the major Williams et al. Using the JavaGrinder was as web IDE while pair programming has been found to positively effect student retention in introductory computer science classes.

CodePilot can help support this by fostering more collaboration. We hypothesize that combining both real-time and non-real-time collaborative tools will lead to a richer and more cohesive collaborative programming experience, as opposed to either of those methods alone. Synchronous editing, such as that supported by Google Docs, is excellent at keeping collaborators in tune with what each other is working and focusing on.

Seeing edits performed in real time gives a sense of dynamism to the work being done, and allows potential misunderstandings to be cleared easily by presenting the same shared context. Issues can arise if communications between programmers editing the same codebase suffer significant delay. A common trope of multi-developer version control scenario is the commonality of the merge conflict.

Before the second developer pulls from the main repository host GitHub, Bitbucket, etc. When the second developer makes another commit locally based on the last seen commit from GitHub and tries to push it to GitHub, they might see an error like:.

This frustrates programmers since they simply want to share their work with their teammates, but now they must coordinate with the first committer and resolve the merge conflict by manually by creating a new version of the code from the two branches which incorporates both changes, or rebasing the head of their local branch off of the newly updated remote and then merging in the changes again.

The benefit of synchronous collaboration systems is that there are no merge conflicts. The syncing mechanism such as Operational Transform automatically merges the changes coming in from each programmer and keeps a single persistent document for all collaborators.

A diagram of the differences in merging strategies is shown in the figure below. This is not to say that the synchronous collaborative editor is the perfect programming tool. Conversely, asynchronous collaboration through version control provides its users with the ability to update their versions of the codebase as they please, rather than keeping a single persistent shared state.

Collaboration with version control through platforms such as GitHub and Bitbucket has been steadily growing more popular, and will likely continue to be a way that future developers collaborate together on software projects. There is often a significant overhead when learning to use git outside of a single developer context for budding coders, though.

They are already building their fundamental computer science skills, on top of learning how to use git or mercurial. CodePilot aims to take the best of real-time and non-real-time systems and combine them in a system that is more intuitive for novice programmers. This mix between two prevalent paradigms is demonstrated in the above figure. The ability to verify that code is working as expected is a fundamental part of the software development process, and any capable web IDE integrated development environment will provide some means of doing so.

While there have been efforts to compile and evaluate code in the browser, the latency between running your code and seeing the results is still quite high. However, the technology in this domain continues to improve, and may reach the point where the simplicity and latency no longer dissuades developers from using online IDEs. CodePilot currently found at codepilot.

It allows users to import a repository of code from GitHub. Once this is complete, they can edit their project and make a new commit based on their edited version of the document and push the new version back to GitHub. Once a repository has been updated on GitHub, changes can be pulled in from the head of a branch, along with whatever commits that have occurred since the last time CodePilot updated its local copy of the repository.

CodePilot Basic Programming Interface. CodePilot is a tool meant to help people collaborate on code more seamlessly. The collaboration model was based on that of a pilot and a co-pilot, where the pilot does most of the actual programming, and the co-pilot performs background coding tasks. This can include version control management, system testing, online reference lookup, and commenting or documenting source code.

A screenshot of the main programming interface is shown in the above figure. When users first login, they see a link to the configuration panel where they can change which repository and branch they are working on. A list of the files in the repository is presented, with a prompt to begin editing them.

This interface is shown in the figure below. Coming back to the main coding page in the future will simply show the file that was opened last. Clicking on the setup link above will bring them configuration page, where users are able to select which repository and branch they would like to work on. This setup panel is shown in the figure below. They are also able to view additional information about their account, such as who the other CodePilot collaborators are for their current repository, a link to the GitHub account that created their CodePilot profile, and the option to select which role they would have in the development process.

These roles were designed to guide parallel development, encouraging the pilot to take charge of the software development process and the copilot to help with testing, documentation, and source control. The UI for the copilot does not contain the commit panel, and the order of the testing pane was rearranged to feature the issues and tasks more prominently. The motivation for this was that to make collaboration even easier, a link could be generated that could be sent to anyone, who can drop in on your session without having to login in or be a collaborator of the GitHub repository.

This functionality was not built out however, so the interface differences previously mentioned are the only differences between pilots and copilots. The actual editing pane is based on the popular Ace web editor, which features language recognition, syntax highlighting, and code auto-completion shown in the figure below. A syncing library ShareJS ShareJS is used to relay edits back to the server and then to all other connected users working on this same project.

The file name and path are listed in the upper left corner of the pane, with testing and saving buttons in the upper right. This is to provide easy access to the other cycles of the software development process. CodePilot Autocompletion Example. CodePilot has an integrated activity and chat feed which updates in real time with the actions of each collaborator. Notifications appear when anyone creates a file, renames a file, opens a file, creates an issue, closes an issue, switches branches, makes a commit, and switches in or out of a repo.

It also features a link to opening up a Google Hangouts session where you can video or audio chat with others collaborating on this repository in CodePilot. This feature of CodePilot is displayed in the the task list below. Tasks are able to created, completed and optionally deleted by collaborators. This system is designed to help outline the work that remains to be done. Working with tasks also triggers the activity feed to update, so the main programmer can see the tasks and links coming in.

This decision was made primarily due to the ease of having the browser render these. Since the browser is already made to render websites from these materials, we hypothesized that it would be a most natural to render basic website code since the synchronous nature of application best fit inside a web browser. It features links back to the coding pane, an option to reload code from the editor and re-render it, and a button to move to the full screen debugger. A choice was made to separate the code that was being edited and that which was being inspected in the renderer so it would not reset on a tester who was inspecting the code every time that their partner typed in a new character.

CodePilot Web Interface Debugger. This allows the pilot to keep making changes while the tester debugs the code that was loaded into the browser, making it easier for the work to be done in parallel. Any change that was made by the pilot will not be loaded into the renderer until the reload button is pressed.

Inside the debugging pane, an iframe with injected code renders the users code, parsed from the HTML, CSS, and Javascript files found in their project. This way, the developers can easily view the output of their code while debugging. It also features support for jQuery, the popular Javascript library that makes accessing the DOM tree more direct.

Finally, in the top-right corner there is a report issue button, which is hooked into GitHub issues and allows users to easily track problems with their code, or make clear certain parts of the site that they want to change. The issue tracker records all of the state of the rendering, and when an issue is generated such as in , it includes a link back to the live, rendered, version of the website.

These issues along with any issues imported from GitHub are displayed in the CodePilot testing pane. Once you click an issue, a dropdown button list is shown, allowing users to view the issue on GitHub, close the issue both in CodePilot and in GitHub , and if the issue was generated by CodePilot view the live demonstration of the rendered web code.

This interface is shown in the above figure. CodePilot Issue Management Interface. This is because when an issue is created, the content of each aspect of the renderer HTML, CSS, Javascript, and console output is saved, and can be reloaded into the renderer template.

This issue will be visible to everyone working on the repository or if it is a public repository, then the entire public. An example issue that was generated by CodePilot is shown in as it appears on GitHub. Additionally, the link to the live version where the issue was found does not require users to be logged in with CodePilot, so if there are other collaborators using the standard git platform, they are still able to view and understand the issue.

It should be noted that this testing approach is much more general than web development. Nothing prevents this from being extended to any language or automated testing framework. The testing here could feature sending the code to a server to run test cases, or even compiling to Javascript in the browser in the future with Opal, Emscripten, or other Javascript source compilers Opal.

Users are able to select and import any repository that they are a collaborator on, or repositories that their organization owns and they have access to. This selection pane is shown in the figure below. In addition to this, they are able to easily fork any existing repository through the GitHub API , and begin working on that in Codepilot.

Branches can also be browsed and selected, so that you are able to work on any branch from GitHub. Users are also able to create a new branch based off the your current CodePilot branch, and this change is immediately synced back to with GitHub.

CodePilot Repository Selection Interface. Once a repository is imported, you can use the programming interface to edit the contents of any text files that are located. Images in project repositories may be opened, but no interface is provided to edit them.

Once any change is loaded into the renderer or the refresh button is pressed, a difference will be generated. CodePilot File Management Interface. There is a small reset button in the top right section of each diff, so that the user may reset changes that were made but does not want to commit. This will pull down the latest commits from GitHub and load that version of the project into CodePilot.

CodePilot Code Diffing Interface. The commit panel is only visible to pilots, excluding copilots. This goes with our theme of having the main pilot have the final say over what gets committed, but allowing others to help out on the code. Once a commit has been made, the differences will be reset, and the commit that was just created and pushed will be added to the list of commits in both CodePilot and GitHub.

This is demonstrated in the figure below. There is the possible use case of having a single main developer who frames the code and specifications, then guides other developers as they implement the basics. Additionally, this system could be used in a scenario where the pilot seeks help on a specific problem, and allows a copilot to enter the session and try to solve it.

The pilot still retains the sole access to push new versions of code to GitHub, but can now seek help from a broader pool of developers. We developed CodePilot , a real time collaborative text editor with GitHub integration. We wanted to test whether this tool allows novice programmers to effectively use the git version control system in a collaborative environment, and whether the development tools inside CodePilot encourage members to parallelize their development efforts.

We recruited six pairs of students that were familiar with both web development and version control to participate in an 1 hour study evaluating how CodePilot performed as a collaborative development tool. We also took screen recordings of 10 out of the 12 study participants.

The reason for not recording screencasts of the last 2 participants was that they did not have any screen recording software installed, and we were not prepared with a screen recorder for their operating system. To avoid the study going over the allotted time, we continued without recording the screens of these two participants.

All were fairly experienced with version control and web development, as shown in and. The study had eight male and four female students. There were two graduate students, six seniors, three juniors, and one sophomore, represented in the figures below. Participant Version Control Skill. Participant Web Programming Skill. Participants were assigned the following web programming tasks with a single teammate emulating pair programming , and encouraged to complete as many of them as possible in a 30 minute time frame that was allocated in the middle of the experimental session.

The original repo with instructions can be found here:. Upon completion or the passing of 30 minutes from when the tasks were started, the first person who forked the repository would make a final commit of what they had to their version of the forked original repository. Each participant would then complete a brief interview together about their experiences developing with CodePilot was like.

They also were asked to complete a demographic survey afterwards, which asked about their student status year , gender, and web programming and version control experience. We also performed a short interview of both partners after programming together to learn more about their experience interacting with the system. When each pair of students first arrived at the session, we discussed what the study would go over, had them sign consent forms for participating as part of our IRB review process, and then gave them an overview of CodePilot.

They were instructed that they could leave at anytime and there would be no negative repercussions for them. After the initial overview and our CodePilot explanation and demonstration, they were given a set of web development tasks, divided up into the structure of the page HTML , the style of the page CSS , and the data and interactivity of the page Javascript.

The focus is less on what the task is though, and more on how they worked together to more efficiently complete these tasks. One could note that the division of these tasks could have lent itself to easier pair programming, since the tasks were already categorized into the type of work they required and also the file that work would be done in. In hindsight, it would have been ideal to perform this study on public Mac computers, since those would have screen recording software built in, and did not want to take time to install additional screen recording software.

Thus our data is somewhat fragmented, as we cannot entirely quantify the actions of those last two participants. Ample qualitative notes were taken during the study however, and there was at least one screencast generated per session. Through the study, we measured the amounts of commits total and per team member. For those that were able to provide a screencast, we measured their time on task, the amount of web searches, and the amount of context switches from their screen recordings of their study sessions.

After the collaborative programming session, each pair was interviewed about what their experience using CodePilot to collaborate on web development was like. They were also asked about how it compared to more traditional, asynchronous collaborative workflows namely collaboration using git or other distributed version control systems. I think its like a different kind of workflow. We were only able to do that because we were right next to each other at the same time… like for that, I think it was really great.

It was great for pair programming. GitHub is always going to be the collaboration tool for large scale projects, but if you want to real time collaborate, this is perfect. GitHub is definitely not for real time, I am not expecting to collaborate on the same code at the same time, or there will be a ton of merge conflicts. Sometimes it can get in the way if you are trying to get something done and there is a merge conflict it just takes more time, its annoying.

Another echoed that, while also noting some of the downsides that come with real time synchronization:. It was nice to see changes being made in real time. When asked about if they had to work with another programmer who was not as experienced with version control if this would be a helpful tool, participants again agreed that it would be much easier to use than teaching that person all of how to use git, avoiding the headache of merge conflicts.

Finally, another student told of how they had branched off on a project when working with others, and the large amount of merge conflicts when they tried to bring in their code:. Our participants maintained that version control is an essential skill which is worth learning, but can be challenging at first. One suggested that a system as CodePilot could be nice to include novice programmers, slowly introducing them to version control concepts such as commits and branches which CodePilot supports :.

Git is super useful to fully know… but that being said, this is definitely a good starting place so that they can at least have the idea that a commit is a save point in the code that they can go back to, and then later on introduce branches. Overall, using a synchronous editor was found to be better at keeping developers in the same context than a standard distributed workflow, where programmers edit different code bases and then later merge them together.

On the other hand, there is the chance that something will be edited by your collaborator, which would then impact what you were working on. One of the benefits of having a broad web editor is the diminished need to perform context switching, and the corresponding avoidance of mental flow disruptions. Your partner can easily send you relevant links or even create a branch from the current system without having to distract you from whatever coding task you are working on.

When asked if they had a good sense of what their teammate was doing, students responded positively, noting that the integrated activity feed helped them stay synced up:. Participants tended to immediately divide up the work and then work on the separate parts right from the initial starting up. This would not be a conflict in traditional development workflows, but you would still face the problem of later merging code back into the central hosted repository and resolving whatever conflicts could be generated from that.

Interestingly, the distribution of commits between team members was distributed in a manner almost as if we had enforced the pilot and copilot programming schemes. On almost every team, there was one person who took over the version control duties, making all the commits as seen in the figure below. There was one team where both partners authored and pushed commits back to GitHub, but they verbally communicated this, so there was some additional communication.

This suggests that people work well when they split up the work, and make clear roles for themselves even if they are not assigned. When asked if using CodePilot was enjoyable to use, all participants generally responded positively. One noted the unique workflow that it encouraged:.

Overall, using it was a pretty pleasant experience, had a lot of fun. I would be a little bit worried using that as an alternative to version control, since I think it is important to learn how to use version control. Notifications appear when anyone creates a file, renames a file, opens a file, creates an issue, closes an issue, switches branches, makes a commit, and switches in or out of a repo. It also features a link to opening up a Google Hangouts session where you can video or audio chat with others collaborating on this repository in CodePilot.

This feature of CodePilot is displayed in the the task list below. Tasks are able to created, completed and optionally deleted by collaborators. This system is designed to help outline the work that remains to be done. Working with tasks also triggers the activity feed to update, so the main programmer can see the tasks and links coming in. This decision was made primarily due to the ease of having the browser render these. Since the browser is already made to render websites from these materials, we hypothesized that it would be a most natural to render basic website code since the synchronous nature of application best fit inside a web browser.

It features links back to the coding pane, an option to reload code from the editor and re-render it, and a button to move to the full screen debugger. A choice was made to separate the code that was being edited and that which was being inspected in the renderer so it would not reset on a tester who was inspecting the code every time that their partner typed in a new character.

CodePilot Web Interface Debugger. This allows the pilot to keep making changes while the tester debugs the code that was loaded into the browser, making it easier for the work to be done in parallel. Any change that was made by the pilot will not be loaded into the renderer until the reload button is pressed. Inside the debugging pane, an iframe with injected code renders the users code, parsed from the HTML, CSS, and Javascript files found in their project.

This way, the developers can easily view the output of their code while debugging. It also features support for jQuery, the popular Javascript library that makes accessing the DOM tree more direct. Finally, in the top-right corner there is a report issue button, which is hooked into GitHub issues and allows users to easily track problems with their code, or make clear certain parts of the site that they want to change.

The issue tracker records all of the state of the rendering, and when an issue is generated such as in , it includes a link back to the live, rendered, version of the website. These issues along with any issues imported from GitHub are displayed in the CodePilot testing pane. Once you click an issue, a dropdown button list is shown, allowing users to view the issue on GitHub, close the issue both in CodePilot and in GitHub , and if the issue was generated by CodePilot view the live demonstration of the rendered web code.

This interface is shown in the above figure. CodePilot Issue Management Interface. This is because when an issue is created, the content of each aspect of the renderer HTML, CSS, Javascript, and console output is saved, and can be reloaded into the renderer template. This issue will be visible to everyone working on the repository or if it is a public repository, then the entire public.

An example issue that was generated by CodePilot is shown in as it appears on GitHub. Additionally, the link to the live version where the issue was found does not require users to be logged in with CodePilot, so if there are other collaborators using the standard git platform, they are still able to view and understand the issue.

It should be noted that this testing approach is much more general than web development. Nothing prevents this from being extended to any language or automated testing framework. The testing here could feature sending the code to a server to run test cases, or even compiling to Javascript in the browser in the future with Opal, Emscripten, or other Javascript source compilers Opal.

Users are able to select and import any repository that they are a collaborator on, or repositories that their organization owns and they have access to. This selection pane is shown in the figure below. In addition to this, they are able to easily fork any existing repository through the GitHub API , and begin working on that in Codepilot. Branches can also be browsed and selected, so that you are able to work on any branch from GitHub. Users are also able to create a new branch based off the your current CodePilot branch, and this change is immediately synced back to with GitHub.

CodePilot Repository Selection Interface. Once a repository is imported, you can use the programming interface to edit the contents of any text files that are located. Images in project repositories may be opened, but no interface is provided to edit them. Once any change is loaded into the renderer or the refresh button is pressed, a difference will be generated. CodePilot File Management Interface. There is a small reset button in the top right section of each diff, so that the user may reset changes that were made but does not want to commit.

This will pull down the latest commits from GitHub and load that version of the project into CodePilot. CodePilot Code Diffing Interface. The commit panel is only visible to pilots, excluding copilots. This goes with our theme of having the main pilot have the final say over what gets committed, but allowing others to help out on the code.

Once a commit has been made, the differences will be reset, and the commit that was just created and pushed will be added to the list of commits in both CodePilot and GitHub. This is demonstrated in the figure below. There is the possible use case of having a single main developer who frames the code and specifications, then guides other developers as they implement the basics.

Additionally, this system could be used in a scenario where the pilot seeks help on a specific problem, and allows a copilot to enter the session and try to solve it. The pilot still retains the sole access to push new versions of code to GitHub, but can now seek help from a broader pool of developers.

We developed CodePilot , a real time collaborative text editor with GitHub integration. We wanted to test whether this tool allows novice programmers to effectively use the git version control system in a collaborative environment, and whether the development tools inside CodePilot encourage members to parallelize their development efforts.

We recruited six pairs of students that were familiar with both web development and version control to participate in an 1 hour study evaluating how CodePilot performed as a collaborative development tool. We also took screen recordings of 10 out of the 12 study participants.

The reason for not recording screencasts of the last 2 participants was that they did not have any screen recording software installed, and we were not prepared with a screen recorder for their operating system. To avoid the study going over the allotted time, we continued without recording the screens of these two participants.

All were fairly experienced with version control and web development, as shown in and. The study had eight male and four female students. There were two graduate students, six seniors, three juniors, and one sophomore, represented in the figures below. Participant Version Control Skill.

Participant Web Programming Skill. Participants were assigned the following web programming tasks with a single teammate emulating pair programming , and encouraged to complete as many of them as possible in a 30 minute time frame that was allocated in the middle of the experimental session. The original repo with instructions can be found here:. Upon completion or the passing of 30 minutes from when the tasks were started, the first person who forked the repository would make a final commit of what they had to their version of the forked original repository.

Each participant would then complete a brief interview together about their experiences developing with CodePilot was like. They also were asked to complete a demographic survey afterwards, which asked about their student status year , gender, and web programming and version control experience. We also performed a short interview of both partners after programming together to learn more about their experience interacting with the system. When each pair of students first arrived at the session, we discussed what the study would go over, had them sign consent forms for participating as part of our IRB review process, and then gave them an overview of CodePilot.

They were instructed that they could leave at anytime and there would be no negative repercussions for them. After the initial overview and our CodePilot explanation and demonstration, they were given a set of web development tasks, divided up into the structure of the page HTML , the style of the page CSS , and the data and interactivity of the page Javascript.

The focus is less on what the task is though, and more on how they worked together to more efficiently complete these tasks. One could note that the division of these tasks could have lent itself to easier pair programming, since the tasks were already categorized into the type of work they required and also the file that work would be done in. In hindsight, it would have been ideal to perform this study on public Mac computers, since those would have screen recording software built in, and did not want to take time to install additional screen recording software.

Thus our data is somewhat fragmented, as we cannot entirely quantify the actions of those last two participants. Ample qualitative notes were taken during the study however, and there was at least one screencast generated per session. Through the study, we measured the amounts of commits total and per team member. For those that were able to provide a screencast, we measured their time on task, the amount of web searches, and the amount of context switches from their screen recordings of their study sessions.

After the collaborative programming session, each pair was interviewed about what their experience using CodePilot to collaborate on web development was like. They were also asked about how it compared to more traditional, asynchronous collaborative workflows namely collaboration using git or other distributed version control systems.

I think its like a different kind of workflow. We were only able to do that because we were right next to each other at the same time… like for that, I think it was really great. It was great for pair programming. GitHub is always going to be the collaboration tool for large scale projects, but if you want to real time collaborate, this is perfect.

GitHub is definitely not for real time, I am not expecting to collaborate on the same code at the same time, or there will be a ton of merge conflicts. Sometimes it can get in the way if you are trying to get something done and there is a merge conflict it just takes more time, its annoying. Another echoed that, while also noting some of the downsides that come with real time synchronization:. It was nice to see changes being made in real time.

When asked about if they had to work with another programmer who was not as experienced with version control if this would be a helpful tool, participants again agreed that it would be much easier to use than teaching that person all of how to use git, avoiding the headache of merge conflicts. Finally, another student told of how they had branched off on a project when working with others, and the large amount of merge conflicts when they tried to bring in their code:. Our participants maintained that version control is an essential skill which is worth learning, but can be challenging at first.

One suggested that a system as CodePilot could be nice to include novice programmers, slowly introducing them to version control concepts such as commits and branches which CodePilot supports :. Git is super useful to fully know… but that being said, this is definitely a good starting place so that they can at least have the idea that a commit is a save point in the code that they can go back to, and then later on introduce branches.

Overall, using a synchronous editor was found to be better at keeping developers in the same context than a standard distributed workflow, where programmers edit different code bases and then later merge them together. On the other hand, there is the chance that something will be edited by your collaborator, which would then impact what you were working on. One of the benefits of having a broad web editor is the diminished need to perform context switching, and the corresponding avoidance of mental flow disruptions.

Your partner can easily send you relevant links or even create a branch from the current system without having to distract you from whatever coding task you are working on. When asked if they had a good sense of what their teammate was doing, students responded positively, noting that the integrated activity feed helped them stay synced up:. Participants tended to immediately divide up the work and then work on the separate parts right from the initial starting up. This would not be a conflict in traditional development workflows, but you would still face the problem of later merging code back into the central hosted repository and resolving whatever conflicts could be generated from that.

Interestingly, the distribution of commits between team members was distributed in a manner almost as if we had enforced the pilot and copilot programming schemes. On almost every team, there was one person who took over the version control duties, making all the commits as seen in the figure below. There was one team where both partners authored and pushed commits back to GitHub, but they verbally communicated this, so there was some additional communication.

This suggests that people work well when they split up the work, and make clear roles for themselves even if they are not assigned. When asked if using CodePilot was enjoyable to use, all participants generally responded positively. One noted the unique workflow that it encouraged:. Overall, using it was a pretty pleasant experience, had a lot of fun. I would be a little bit worried using that as an alternative to version control, since I think it is important to learn how to use version control.

We added the ability to check out any single commit, or the head of the current branch that they were on. This provided users more flexibility in the state of the code that they were editing in the browser, if they wanted to check out what the state of code was at a given commit.

CodePilot File Resetting Addition. This included improving the file contents difference recognition mechanism, so users could preview what the differences were between the cached version of their project and the last committed version from GitHub.

It also provides users with the options to reset a file back to how it was from the last commit if they accidentally change a file that they did not mean to change. This is shown in the figure above. We also improved the commit interface, notably disabling the ability to commit anything if there were no differences between the current state of the project in CodePilot and the latest version that was pulled in from GitHub, shown in the figure above. Finally, we augmented navigation between code modes editing, testing, and saving so that the switching was less of a mental barrier, and allowed them to do so more easily.

One of the most requested features in the feedback was to be able to see their collaborators cursors, but this has not been implemented at the time of writing. No longer does the single genius hack away in isolation to bring about the latest innovation. However, parallelization of software development is an incredibly complex task, noted famously by Fred Brooks in the mythical man month Brooks As the future generations of software developers gets trained, it is important to reconsider how we work together on large pieces of complex software, and to ponder on whether there are better ways that collaboration could be done.

Other modes of task collaboration could be explored, such as implementing a specification test from design documents, while others begin writing the implementation. Frequent checks and syncing mechanisms help avoid the large overhead of syncing massive code changes together. While making commits frequently and atomically is broadly considered best practice, more software can be developed that helps share and encourage these best practices.

Developers could begin to embrace a broader set of collaborative models besides the traditional centralized repository, expanding the abilities teams to work dynamically, and for the relevant help to jump in more easily. This could possibly be in return for a financial reward, creating bounty hunter style developers. In order for this to work there would be a need to objectively verify that the software bug as described in however it was advertised had since been removed after the novice was helped.

One very viable route that online code evaluations systems could proceed in is extending CodePilot or other collaborative systems to allow the execution of arbitrary code in a browser sandbox, or improve the interfaces to back-end server compilers. Languages such as Ruby already have an implementation in Javascript, the core language that modern web browsers execute. This implementation is called Opal. Currently, the committing pane of CodePilot where users make new commits is limited to committing entire files or sets of files.

Furthermore, this augmented committing process could allow committing all changes from a specific user or a set of user. Each edit operation already has an author identification tag, which could then used to filter out which parts of the code to include in that commit. There are also many improvements that could be made in terms of shortening the feedback loop between editing code and inspecting the differences in output.

There are potential security issues with allowing other people direct access to your local machine though, so perhaps with more limiting modifications this could be a solid means of collaboration. Alternatively, the development environment could be bundled up and then cloned in a web IDE, where it could run actively. This work explores new ways for collaborative development to be less encumbering for budding programmers, and allow for more parallelized development for experienced programmings.

As software development becomes more popular and collaborative, it is important to examine the tools that people use to collaborate, along with how these tools are actually used in practice. CodePilot is just one example of a system that can extend how developers traditionally work together, and lower boundaries to novice programmers when getting involved with version control.

CodePilot combines synchronous and asynchronous collaboration, encouraging a greater sense of awareness for what your collaborators are working on, but this does not come without costs. Namely, the additional context gained from synchronously editing files is offset by the inability to edit code without effecting your collaborators.

This can be mitigated by compartmentalizing which codebase each person works on, or splitting up collaborators so that one or two developers are mainly writing code while others write tests or documentation. Version control has made the world of software development a better place, but is still often challenging to use when collaborating with a large group. GitHub has done a great job in making it more accessible, but there is still issues that people encounter when working together, such as merging divergent copies of the repository.

Tools can be built such as CodePilot that bring together the asynchronous real-time editor with that of the complex back-end version control system, as well as some method of software verification, which was implemented using the web renderer. CodePilot helps explore this increasingly viable and important space of collaborative programming systems. Acknowledgments First and foremost, I am grateful to my father and mother, Hollis and Paula Warner, whose unwavering support enabled and encouraged me to pursue my dreams wholeheartedly.

Abstract This thesis analyzes perceptions towards collaborating with version control and introduces a new system, CodePilot, for project-wide synchronous collaborative programming backed by version control. Dedicated to all who have suffered through merge conflicts. Software Collaboration There are two main modes of synchronization in collaboration: real-time and non-real-time.

Online Compilation Web browsers are an essential part of modern computer use, and developers frequently use them to access the internet, looking up documentation or asking questions on StackOverflow Brandt et al. Thesis Overview The key findings are that a mix of real-time and non-real-time version control systems can improve novice programmers sense of self-efficacy when using version control systems, and also that they can be used to help parallelize software development and reduce the amount of unnecessary merge conflicts.

Related Work A good amount of relevant work has been done on other real-time collaborative editors, as well as editors that integrate more blended forms of asynchronous and synchronous collaboration features. Collaborative Editors Increasingly, code is stored and distributed on GitHub, the popular git repository hosting website.

Pair Coding Dynamics In a large quantitative study, code produced from pair programming contained fewer bugs, leading to overall higher quality code Williams et al. Collaboration in Education Computing education is growing in popularity, as a new CS for all initiative was launched recently.

CodePilot: Git Realtime Collaboration Motivation We hypothesize that combining both real-time and non-real-time collaborative tools will lead to a richer and more cohesive collaborative programming experience, as opposed to either of those methods alone. CodePilot File Flow Pattern.

See the 'Note about fast-forwards' section of 'git push --help' for details. CodePilot Configuration Panel.

First and foremost, I am grateful to my father and mother, Hollis and Paula Warner, whose unwavering support enabled and encouraged me to pursue my dreams wholeheartedly.

Phd thesis on pair programing Buy best school essay on founding fathers
Phd thesis on pair programing 961
Phd thesis on pair programing To write a formal business letter
Teen complexion disorder essays Overall, using a synchronous editor was found to write a chorus better at keeping developers in the same context than a standard distributed workflow, where programmers edit different code bases and then later merge them together. To avoid the study going over the allotted time, we continued without recording the screens of these two participants. Computing education is growing in popularity, as a new CS for all initiative was launched recently. One of the most requested features in the feedback was to be able to see their collaborators cursors, but this has not been implemented at the time of writing. The focus is less on what the task is though, and more on how they worked together to more efficiently complete these tasks.
Phd thesis on pair programing Popular dissertation hypothesis writer website online
Professional descriptive essay ghostwriter website au 245
Phd thesis on pair programing Help with my professional argumentative essay on lincoln
Examples of argumentative essays There are two main modes of synchronization in collaboration: real-time and non-real-time. Namely, the additional context gained from synchronously editing files is offset by the inability to edit code without effecting your collaborators. Tasks are able to created, completed and optionally deleted by collaborators. Synchronous editing, such as that supported by Google Docs, is excellent at keeping collaborators in tune with what each other is working and focusing on. All work conducted for the thesis was completed by the student independently.

Casually come me a narrative essay something

Not coursewokrs something

This improves the working conditions and eases the work pressure. The best advantage in pair programming is the effort saved in post-debugging the work done by pair programming. As has been pointed out earlier also, the observer is continuously takes care of the programming methods, algorithms, strategy and the standard practices used by the driver. Thus, saves the time and effort in re-doing the work again.

The reviews may lift the standards of the work. The quality of the work improves as result of the lesser number of bugs in the codes. The client gets a better solution; design issues are also resolved in a better way.

The coding technologies today not only emphasize on the problem-solving techniques but also on the comprehensibility, atomicity and the extensibility of the code. A solo programmer cannot provide these benefits as it would require a lot of effort and time. Thus, gives us the advantage of the pair programming. Another benefit of a pair programming is that if new programmer is hired and inducted with an old employee as a team. The new person would learn much faster than sitting on his desk reading the documents about a project and the standards of the company while coding.

Thus, improves the productivity of the new person, by utilising pair programming. The pre-delivery bugs and the defects are lesser but the fact is that the chances of post-delivery bugs increase. This is because of the increased dependency on the peer review increases the chances of bugs coming into picture. The pair programming is attribute which is like a social nature and it takes time for a new person in such a system to learn the skills of pair, so it is already evident from the fact that Pair programming is less productive in short run.

Some even feel that doing the practice of pair programming, causes the underutilization of the resources. It has been also felt that complex programming did not favor the practicing pair programming. According to Williams and Kessler, pair programming is an intensive programming collaboration where two programmers design, code and test software collaboratively at one computer. In contrast to the Solo programming the pair programming gives a code with fewer defects and also promises a better design.

The programmers who have worked alone for long would be sceptical to the idea of pair programming and resist it. However, the pair programming increases the chances of sharing of knowledge and makes the task of programming enjoyable. The increased flow of knowledge among the team members decreases the chances of the teammates to be highly critical of each others work.

The pair programming allows people to understand the project work easily and with little effort as compared to the solo programming. In Oder to find out the various research options and objectives available to us to get out the possible results which give a coherent andclear understanding of the topic in the question we followed the method of Systematic Review Method. The systematic review method is a process of accessing the materials available in the various libraries with extensive and comprehensible strategies which might be based on several stages to produce a clear result.

The systematic review method follows the following method, which we followed iteratively:. This process is followed iteratively to reach to the results of the question formulated. This process has been. In order to find out the relevant literature for the study we created the appropriate search keywords to select the comprehensible literature from the online libraries.

We studied the population of the students who were interested in the pair programming. In producing the results were equally focussed about the quality of results involved in the research works. Based on the studies of the research works available in the online libraries we built up our review document and produced the data extracted from them. The Extreme Programming XP has got a phenomenal success from using the concept of pair programming.

The programmers at Ford motors were trying to build vehicle cost and profit system and had spent four unsuccessful years of trying the Waterfall model. But the team from XP completed this project in less than a year. XP believes that the best way to write a code is pair the two programmers and let them seat side by side a computer, pushing the keyboard and monitor back and forth, both being able to concentrate on a piece of code.

This is an art which has to be developed with time. There can be many obstacles in the path of contributing to the success of pair programming. Like if the experience of one partner is more than the other, there could be an awkward feeling at first, because one might be contributing more than the other.

Still the practice should be continued, as it takes long to learn the skills of working as pair programmers. The real question goes as how are we going to make two different programmers a pair of successful and efficient pair programmer. The answer lies in the soul of the practises of Pair Programming. The success of pair programming lies on the attitude of the partners involved in teaming up for the project. The basic features of which are outlined as below:.

This is a practice which has resulted in many success stories, but requires a patience development of such a skill. The practice of doing pair programming requires lot of time and hence is successful in scenarios in which long term development is required. Our future works should involves finding out the basic evidences which can provide unambiguous report of how the pair programming methods help in producing the better results and the scenarios where the pair programming can be helpful as the pair programming had been found to be unsuccessful in the short run.

Distributed Computing. October New York, Villard Books. The Case for Collaborative Programming. Communications of the ACM. March New York, Dorset House Publishing. But you can order it from our service and receive complete high-quality custom paper.

If you like one, you have an opportunity to buy a similar paper. As evidence for this, we will propose a technique for incremental refactoring, which relies for its correctness on a bidirectional language and its properties, and devise a framework for implementing program transformations, with bidirectional properties that allow program analyses to be carried out in the transformed program, and have the results reported in the source program.

Our applications of bidirectional programming to new areas bring up fresh challenges. This thesis also reflects on the challenges, and studies their impact to the design of bidirectional systems. We will review various design goals, including expressiveness, robustness, updatability, efficiency and easy of use, and show how certain choices, especially regarding updatability, can have significant influence on the effectiveness of bidirectional systems.

Simple search Advanced search. Bidirectional Programming and its Applications. This file may not be suitable for users of assistive technology. Download kB Preview.