-
Notifications
You must be signed in to change notification settings - Fork 0
How to Contribute@ Codebase Tour
Our VSCode Extension is a Typescript project and we use npm for our package manager.
We have various dev-dependencies for unit tests, end-to-end tests, code linters, and type definitions for typescript compilation. Our e2e-tests and unit-tests are stored in their respective folders , and our JSDoc documentation is stored in the docs folder.
All of our config files for the different package management pipelines are in the config folder, and this includes stuff like the Typescript compiler config, ESLint config, and code coverage config files.
Our backend API using google cloud functions with firebase is in the cloud_functions folder, and these functions consist of endpoints that communicate with our application and populate the database with the corresponding data in the correct format.
As for actual dependencies, we only have three node packages: Firebase
, simple-git
, and xmlhttprequest-ts
. Firebase is used to interface with Firebase's authentication feature which will be used to handle user accounts and user ids. Simple-git is used to run git commands on the user's local repositories to collect necessary data for our extension to work. Xmlhttprequest-ts is used to send HTTP requests to communicate with the backend endpoints that will write data into Firebase's realtime database.
The extensions core functionalities are all in the seven files in the src/ folder: auth.ts
, commandsx.ts
, config.ts
, events.ts
, git.ts
, main.ts
, and webview.ts
. auth.ts
contains authentication related functions, commands.ts
contains functions which represent the core functions of our extension that can be run through the VSCode command palette, config.ts contains the Firebase configuration of our backend, events.ts
contains an event listener that fires every time the user navigates to a new file within VSCode, and sends that file information over to the backend APIs. git.ts
contains Git-related functions which are mostly encapsulated git commands that run on the user's local environment and sends that data back to the endpoints. main.ts
contains the extensions main function where all the parts are put together, and webview.ts
contains the webview part of our extension which allows a map to be displayed within a webview in VSCode.
Our unit-tests are set up in unit-tests/suite/
, where any file ending in test.ts
will be compiled into a unit-test and run with Mocha, our unit-testing library.
Our end-to-end tests are set up in e2e-tests/
, where each file will be compiled into an e2e-test and run with vscode-extension-tester, which is our end-to-end testing library.
The extension's main function is called in main.ts
, which activates our extension and initializes the Firebase authentication service and runs the simple-git functions we have from git.ts
in order to collect basic data about the Git repository that the user's current open folder is in. main.ts also initializes the status bar button which can be clicked to reveal a command palette within VSCode. main.ts
prevents the extension from running without user authentication, so the user must sign in or sign up in order for the extension to start working. After the user is authenticated,
main.ts
loads the commands from commands.ts
and auth.ts
, where the user can choose to select a sign in/up option to authenticate, and select from the extension's core functionalities from commands.ts
, namely displaying the current working file, creating a map, and loading a map. Authentication is handled by the functions in auth.ts
using the Firebase package.
git.ts
contains the functions that encapsulate git commands that will be run via the simple-git package before collecting data about the repository and sending it to the server.
events.ts
contains a listener that will be run after the user is authenticated to keep track of the current file that the user is editing and update the database each time the user navigates away to a new file
webview.ts
contains the function that will initialize the webview with the source code map inside of VSCode. The webview contains a barebones version of our webapp which will display the source code map inside VSCode and update in realtime.
Welcome to CartoGraphX!
CartoGraphX is a combination of a VS Code extension and a web application that provides software development teams with a way to visualize their coding projects! Our software utilizes the files in a project in order to create a map that helps developers understand the relationships between the files they are working in much like the one displayed below:
Insert image of map view
CartoGraphX keeps track of where team members are working and updates automatically to reflect changes made to files in VS Code
Who is CartoGraphX for?
We created CartoGraphX for software development teams. Our application is intended to help foster and grow a team environment through the use of code visualization.
Why do you need CartoGraphX?
How long do you spend trying to understand the files in a project before you actually begin working?
A visualized map of the source code rather than a high level description design document might make your life easier…
How long do you spend trying to understand code you didn’t write?
Knowing exactly who worked on which file and when would be nice wouldn’t it? We did that for you.
How often are you actually collaborating with your team in a remote setting?
Our platform allows you to take full advantage of your teammates, increasing general productivity.
What Inspired CartoGraphX?
Like any solution, CartoGraphX is a response to a problem, or rather a series of problems. The developers here at CartoGraphX got inspiration both from issues that have been affecting software development teams for a long time as well as other problems that have recently come to light with our current global situation. The problems that CartoGraphX hopes to mitigate are:
-
Developers often don’t understand the full scope of the projects they work on. Instead, they focus just on the area of the project where they write code and don’t pay much attention to the rest of the project. This is problematic because developers today are essentially trying to solve a problem with partial information. Our map provides software teams with an easier way of understanding the full scope of a project.
-
Remote work has led to a lack of accountability where developers are left to manage their own time without much supervision. Additionally, with people now having to work from home, there are many more distractions that lead to a fall in productivity. In order to address these issues, our platform keeps track of where coders are working in real time. It places software developers on an “idle island” if code is left untouched for enough time when they should be working. This helps software developers to remain on task as seeing what their peers are doing will help them to maintain accountability. At the same time, this also helps team managers to monitor their developer’s behavior as well as help them to assess team progress throughout the development cycle.
-
Software developers often have a hard time resolving bugs because they deal with code they didn’t write and therefore don’t completely understand. Our map keeps track of who worked in each file. This means that if a coder runs into an issue in a file or area of the program they don’t fully understand, they can easily see who worked on these files last and can contact them to get help!
-
Remote working has decreased team interaction further because people are no longer forced to see each other everyday. This is problematic because it affects team morale and reduces team communication in general. CartoGraphX aims to help keep teams connected by providing a platform where teams can work simultaneously.