Kiri Strack-Grose and Jeffrey Matthews

"Reposaurus!"

Intensive Introduction to Computer Science

Andrew Cencini

17.4.2014

Project Proposal

Project: The intention of the project is to create a code hosting website, based on the Git model. The purpose of the project is manifold, and the primary facets are to a) learn and implement interesting and useful knowledge regarding git architecture, websites, etc, and to b) smash the patriarchy by creating an equitable alternative to GitHub.

Partners:

Alexander Holt (aholt@bennington.edu)

Arthur Jongebloed ajongebloed@bennington.edu)

Ayesha Raees (araees@bennington.edu)	

Carlos Mendez (cmendez@bennington.edu)

Chernoh Jalloh (cjalloh09@gmail.com)

Christopher Bussolini (cbussolini@bennington.edu)

Jeffrey Matthews j(matthews@bennington.edu)

Jenna Kadota (jkadota@bennington.edu)

Kiri Strack-Grose (kstrack-grose@bennington.edu)

Megan Farnham (mfarnham@bennington.edu)

Robin Hrynyszyn (rhrynyszyn@bennington.edu)

Roi Karlinsky (rkarlinsky@bennington.edu)

Scott Milliman (smilliman@bennington.edu)

Process: Through a flexible, active schedule, we will progress through a continual learn-and-implement process. By dividing the whole task into smaller, manageable parts and assigning those parts to individuals or small groups, we will work steadily on the many parts this project will require, such as:

a) a place to store the code, as well as a way to access that storage

b) an easy way to upload and share code

c) a user-friendly website to satisfy the social aspects of programming.

Project, Parsed: At its core, our project is to create a working file storage system that holds text files. To create this, many component functions need to be implemented. The text files need to be accessed and modified by a variety of users on a variety of machines. The changes made to files within the repository need to be merged back onto the repository. All of the changes also need to be tracked. The repository should also be able to be cloned and merged similarly to the text files. This all needs to be able to be done over the network and should have a web interface. Ultimately, we hope our homebred Git will be available to a wider audience, including but not limited to the rest of the Bennington student body.

Obviously, as introductory students, we are not equipped to build this system from scratch. Luckily, Git already exists and its source code is open-source. Thus, our goal is to copy, hack, and mutilate source code to suit our needs. Part of this project obviously entails gaining a thorough understanding of Git and its architecture, an undertaking that extends beyond simply copying and pasting source code. No matter the method, the ultimate goal is to create a working program that accomplishes the aforementioned tasks. Specifically, we are going to parse Git apart into its component parts. We have identified immediate areas of concentration: server side (backend), where the formal repositories live; networking, where a user or can interact with a server and create repositories and text files, clone repositories and files for use on the users home machine, and then merge those changes back to the server for storage and further access; web interface (frontend), where the user can access the Git architecture without using the terminal. The project contributors are researching those processes as well as specifically researching how the Git architecture handles those processes. We are then going to use small, focused groups to build the components through hacked code. Slowly, as those are built out, the individual parts will be integrated into a runnable system. Problems:

We anticipate a multitude of nebulous, undefined problems. However, the clearest problem is going to be interpreting Git source code, as we lack the requisite background. Andrew and the Internet are the best remedies to this problem and with time, the code should resolve itself to us. We also anticipate issues interfacing HTML and the python coding so that the website interacts with the backend server without the need for a terminal window and specific Git commands. The website is a matter of learning HTML, however a messaging system (important for any multi-user website!) may be complicated and thus present problems. We hope that an open-source messaging system can be implemented. Obviously, the python--accessing the server, pulling and pushing uploads--will be challenging because we are unfamiliar with how these system work. However, we hope to utilize online tutorials and Andrew to gain a conceptual understanding of these system processes. And then, finally, the concatenation of the the backend and frontend is unknown territory and an additional expected problem.

Resources (list in progress):

1. A server, or at least server space.

2. A domain name.

3. A host for said website.

4. Extra educational materials such as texts and web tutorials

5. Time and brainpower.

6. Andrew’s time and brainpower.