GSoC 2023 Project Ideas
Introduction
CodePod.io is an open-source canvas-based coding IDE that helps programmers develop large, production-ready projects faster by presenting interactive coding (e.g., Jupyter) on a hierarchical, scoped, 2D canvas. Without code modularization (traditionally done via organizing text files under tree-structured folder hierarchies), a Jupyter notebook can easily become messy, difficult to manage and scale. Alleviating such limitations, CodePod was born to bump interactive coding beyond prototyping and demos. Our website is https://codepod.io. More details are in our paper: https://arxiv.org/abs/2301.02410
We are a VC-backed startup dedicated to open-source development tools. Both of the co-founders will be available as a mentor.
- Hebi (CEO, potential GSoC mentor) is an ex-Google Brainer and ex-ByteDancer with 10 years of AI and PL research experience. He is also A Ph.D. candidate at Iowa State University. Homepage: https://lihebi.com
- Forrest (CPO) is a CS Prof. at Iowa State Univ. Reported by MIT Tech Review, Lancet Neurology, and NYTimes. Homepage: https://forrestbao.github.io/
Idea list
Scope-branching Version Control System (VCS)
Detailed Description: Traditional version control systems work only on files and manage an entire repo as a whole. VCS has always been a challenge in computational notebooks as there are no longer files. CodePod’s unique nested scope canvas offers an opportunity to develop a finer-grained VCS by branching at the scope level, instead of the repo level. In particular, users can create a branch for any scope, and others can pull and merge the branch or switch revisions. In addition (optional for this project), we’d like to support collaborative editing and VCS at the same time to further improve the effectiveness of teamwork.
Expected Outcomes: a version control system that can create branches on the Scoped code cells. Should support branching, merging, and conflict-resolving operations. Users can track changes and view the diff for each pod.
Skills required/preferred: Javascript/Typescript, React, GraphQL, WebSocket, Python
Possible Mentors: Hebi Li
The expected size of the project: 350 hrs
Rating: hard
Scope-based function-level CI/CD
Detailed Description: Traditional CI/CD pipeline assumes heavily on file-based automation. But in interactive coding, there are no files but only snippets of code (code cells). CodePod’s unique nested scope canvas offers yet another opportunity to develop a function-level CI/CD pipeline. The pipelines should be tightly integrated with the Canvas system.
Expected Outcomes: a CI/CD pipeline that can be triggered by releasing or exporting. The pipeline should be function-level, for example, triggering a unit test of a function defined in a code pod.
Skills required/preferred: Javascript/Typescript, React, GraphQL, WebSocket, Python
Possible Mentors: Hebi Li
The expected size of the project: 350 hrs
Rating: hard
Scope-aware language kernels for Javascript, Julia, and Racket.
Detailed Description: CodePod features a novel language-agnostic module system that supports scope-based Encapsulation. The module system manages the symbol table above the language runtime. Thus, in order to support other programming languages, a parser is expected to be built.
Expected Outcomes: an option to choose which language’s kernel to launch. Develop scope-aware kernels for Javascript, Julia, and Racket.
Skills required/preferred: Javascript/Typescript, React, GraphQL, WebSocket, Python, tree-sitter, compiler, parser
Possible Mentors: Hebi Li
The expected size of the project: 175 hrs
Rating: medium
React Jupyter/CodePod kernels
Detailed Description: Front-end development often relies on frameworks such as React. Although the Javascript kernel for Jupyter exists, it is impossible to develop React apps in Jupyter due to the lack of package bundler support, e.g., webpack. Interactive development can be very useful for front-end development thanks to the visualization capability. Thus, it is desired to develop React kernels for Jupyter and CodePod, respectively.
Expected Outcomes: a React kernel for Jupyter that derives from Javascript kernel, but with webpack support.
Skills required/preferred: Javascript/Typescript, React, GraphQL, WebSocket, Python
Possible Mentors: Hebi Li
The expected size of the project: 350 hrs
Rating: hard
A scope-based extension system and APIs
Detailed Description: Extension is a great way to introduce additional functionality for a platform, e.g. the extensions and marketplace of VSCode. CodePod has a unique scope-based canvas interface, we would like to define and implement an extension system and APIs.
Expected Outcomes: An extension system and APIs for extending CodePod. Demo extensions: auto-completion, chatGPT integration, theming.
Skills required/preferred: Javascript/Typescript, React, GraphQL, WebSocket, Python
Possible Mentors: Hebi Li
The expected size of the project: 350 hrs
Rating: medium
Auto-layout of code cells and scope boxes
Detailed Description: Currently, the cell/scope layout is done manually. It is pretty tedious and time-consuming. An automated layout algorithm will let programmers focus on coding. It analyzes the code snippets to figure out the dependencies between the cells and scopes, and implement various auto-layout algorithms present the program structure clearly. Dependencies include the call graph, data dependency, execution order, arrow-based importing, and manually defined order.
Expected Outcomes: a call-graph and data-dependency analyzer and a set of auto-layout algorithms.
Skills required/preferred: Javascript/Typescript, React, GraphQL, WebSocket, Python, compiler, parser
Possible Mentors: Hebi Li, Forrest Bao
The expected size of the project: 350 hrs
Rating: hard
Potentially separate into two projects:
- DAG dependency semantic implementation
- Auto-layout
Cross-language runtime
Detailed Description: Different programming languages have different features and different library ecosystems. Thus, it is very attractive if the functions of different programming languages can call each other. This need is especially useful in CodePod where the smallest coding unit is a function instead of a file. Here, the goal is to implement cross-language runtime calls by serializing and standardizing input/output into ProtoBuffer.
Expected Outcomes: a cross-language runtime that supports calling functions implemented in other languages.
Skills required/preferred: Javascript/Typescript, React, GraphQL, WebSocket, Python
Possible Mentors: Hebi Li
The expected size of the project: 350 hrs
Rating: hard
Integration test and automatic unit-test generation
Detailed Description: Testing is essential for software development. This project adds both integration tests and unit tests. In addition, we envision three important features:
- abstract unit test modules over different programming languages.
- UI and pipeline support in Canvas and scope-based interface.
- Automatic unit tests generation. Unit tests are expensive to write and maintain. Thus, we would like to automatically generate unit tests from integration test runs by recording` the input/output of the functions.
Expected Outcomes: a testing framework that allows users to write and run integration tests and unit tests; an engine to automatically generate unit tests from integration tests.
Skills required/preferred: Javascript/Typescript, React, GraphQL, WebSocket, Python
Possible Mentors: Hebi Li
The expected size of the project: 350 hrs
Rating: medium
Breakpoint support in code pods
Detailed Description: Jupyter-style interactive coding is intuitive for debugging. However, traditional breakpoint-based debugging is still useful for debugging the internal logic inside a function, e.g., inspecting the variables inside the loops. This project aims to support adding breakpoints in CodePod’s code editor and implements actions such as step-into, step-out, and step-over. Jupyter already has it, so we’d probably just adapt it for CodePod. https://jupyterlab.readthedocs.io/en/latest/user/debugger.html
Expected Outcomes: allowing users to set breakpoints in the code editor at any line, and enabling step-into, step-out, and step-over actions.
Skills required/preferred: Javascript/Typescript, React, GraphQL, WebSocket, Python
Possible Mentors: Hebi Li, Forrest Bao
The expected size of the project: 175 hrs
Rating: easy
Importing and exporting between Codepod and local formats, especially Jupyter notebooks and Python scripts
Detailed Description: The goal here is to allow the conversion between CodePod and other formats to help users migrate between them and backup projects locally. When exporting to Jupyter notebooks or Python scripts, users will be asked to choose an ordering criterion, e.g., the return of an external function based on the call graph or the data dependency, the execution order, or the user-assigned order, to map code cells hierarchically located on a 2D canvas to a linear order. Pickling and loading a Codepod project to and from a local copy shall also be supported.
Expected Outcomes: an importer and an exporter between Codepod and its own local
open format, Jupyter notebooks (*.ipynb), Python scripts (*.py), HTML
(exporter only), Markdown (exporter only) and PDF (exporter only). When
exporting, three ordering schemes shall be supported: calling an external
function, sorting cells based on execution order, and using user-assigned order.
Skills required/preferred: Javascript/Typescript, Python, React, GraphQL
Possible Mentors: Forrest Bao, Hebi Li
The expected size of the project: 175 hrs
Rating: Easy
Properly detailed contextual zoom with minimap/toc navigation
Detailed Description: CodePod makes the structure of code clear thanks to its built-in visualization. This project improves CodePod’s visualization capability to the next level. In particular, we need to show users just the right amount of information, verbose details shall be collapsed properly upon zooming out. Besides, since code cells are laid out 2D, a new way is needed to visualize their orders, e.g., via arrows. The order can be manually assigned by a user (e.g., drag and draw) or by an external function (e.g., analyzing the call graph or data dependency). Lastly, a minimap is desired to show users an overview of where we are and can navigate to the right code & scope through ToC jumping.
Expected Outcomes: Storing and retrieving the ordering information to and from the database and visualizing the ordering in arrows using React-flow; allowing users to assign orders to cells via drawing arrows in CodePod’s frontend and saving the user-assigned orders to the database; selectively visualizing upstream and downstream nodes of a selected cell
Skills required/preferred: Javascript/Typescript, SQL, React, React-flow, GraphQL
Possible mentors: Forrest Bao, Hebi Li
The expected size of project: 350 hrs
Rating: Hard
CodePod-based collaborative documentation and publishing
Detailed description: When code cells are all in Markdown or LaTeX or even plain text, CodePod becomes a new documentation or publishing tool: the hierarchy of texts is visualized in 2D rather than using fonts or indentations in a conventional way. The goal here is to add collaborative features to CodePod and to publish CodePod-made documents into interactive web pages.
Expected outcomes: Change tracker and comment (bubbles, not programming language’s comments) in Codepod, collapsing and expanding scopes into and from thumbnail icons, semantic search in the text (as easy as using sentence-bert) with results highlighted and jumpable.
Skills required/preferred: Javascript/Typescript, HTML, React, React-flow
Possible mentors: Forrest Bao, Hebi Li
The expected size of project: 175 hrs
Rating: Easy
Comment and suggest edits
Detailed description: Online collaboration has been widely used in team working. When we collaborate on document writing on Google docs, two features have been shown to be useful: the comment and reply system, and the suggest editing where others can review and accept or reject the suggestions. We believe such collaboration features will boost the productivity of software development as well. This project adds comments and suggests edits features to CodePod.
Expected outcomes: Users can select some text or node and add a comment; team members can reply and resolve the comment. Users can also toggle on the “suggests edits” switch, and the edits will become a suggestion marked with a different color. Other users can leave comments and decide to accept or reject the suggestions.
Skills required/preferred: Javascript/Typescript, HTML, React, React-flow
Possible mentors: Forrest Bao, Hebi Li
The expected size of project: 175 hrs
Rating: Easy