[gsoc24] Xeus-Cpp project and proposals for compiler-research.org (#1509

)

* Create proposal_XeusCpp-LLM.md

* Create project_Xeus-Cpp.md

* Add Xeus-Cpp logo

* Create proposal_XeusCpp-Features.md

* Create proposal_CppInterOp-AdoptionInROOT.md

* Update proposal_CppInterOp-AdoptionInROOT.md

* Fix typo in _gsocproposals/2024/proposal_XeusCpp-LLM.md

---------

Co-authored-by: Valentin Volkl <[email protected]>

_gsocprojects/2024/project_Xeus-Cpp.md

@@ -0,0 +1,15 @@
+---
+project: Xeus-Cpp
+layout: default
+logo: Xeus-Cpp-logo.png
+description: |
+  [Xeus-Cpp](https://xeus-cpp.readthedocs.io/en/latest/index.html) xeus-cpp is a Jupyter kernel
+  for cpp based on the native implementation of the Jupyter protocol xeus. This enables users to
+  write and execute C++ code interactively, seeing the results immediately. This REPL (read-eval-print-loop)
+  nature allows rapid prototyping and iterations without the overhead of compiling and running separate C++ programs.
+  This also achieves C++ and Python integration within a single Jupyter environment.
+summary: |
+  Xeus-Cpp is a Jupyter kernel for C++ based on the native implementation of the Jupyter protocol [xeus](https://github.com/jupyter-xeus/xeus).
+---
+
+{% include gsoc_project.ext %}

_gsocproposals/2024/proposal_CppInterOp-AdoptionInROOT.md

@@ -0,0 +1,42 @@
+---
+title: Adoption of CppInterOp in ROOT
+layout: gsoc_proposal
+project: Cppyy
+year: 2024
+difficulty: medium
+duration: 350
+mentor_avail: June-October
+organization:
+  - CompRes
+---
+
+## Description
+
+Incremental compilation pipelines process code chunk-by-chunk by building an ever-growing translation unit. Code is then lowered into the LLVM IR and subsequently run by the LLVM JIT. Such a pipeline allows creation of efficient interpreters. The interpreter enables interactive exploration and makes the C++ language more user friendly. The incremental compilation mode is used by the interactive C++ interpreter, Cling, initially developed to enable interactive high-energy physics analysis in a C++ environment. The CppInterOp library provides a minimalist approach for other languages to identify C++ entities (variables, classes, etc.). This enables interoperability with C++ code, bringing the speed and efficiency of C++ to simpler, more interactive languages like Python. CppInterOp provides primitives that are good for providing reflection information.
+
+The ROOT is an open-source data analysis framework used by high energy physics and others to analyze petabytes of data, scientifically. The framework provides support for data storage and processing by relying on Cling, Clang, LLVM for building automatically efficient I/O representation of the necessary C++ objects. The I/O properties of each object is described in a compilable C++ file called a /dictionary/. ROOT’s I/O dictionary system relies on reflection information provided by Cling and Clang. However, the reflection information system has grown organically and now ROOT’s core/metacling system has been hard to maintain and integrate. 
+
+The goal of this project is to integrate CppInterOp in ROOT where possible.
+
+## Project Milestones
+
+* To achieve this goal we expect several infrastructure items to be completed such as Windows support, WASM support
+* Make reusable github actions across multiple repositories
+* Sync the state of the dynamic library manager with the one in ROOT
+* Sync the state of callfunc/jitcall with the one in ROOT
+* Prepare the infrastructure for upstreaming to llvm
+* Propose an RFC and make a presentation to the ROOT development team
+
+
+## Requirements
+
+* C++ programming
+* Python programming
+* Knowledge of Clang and LLVM
+
+## Mentors
+* **[Vassil Vassilev](mailto:[email protected])**
+* [David Lange](mailto:[email protected])
+
+## Links
+* [Repo](https://github.com/compiler-research/CppInterOp)

_gsocproposals/2024/proposal_XeusCpp-Features.md

@@ -0,0 +1,38 @@
+---
+title: Implementing missing features in xeus-cpp
+layout: gsoc_proposal
+project: Xeus-Cpp
+year: 2024
+difficulty: medium
+duration: 350
+mentor_avail: June-October
+organization:
+  - CompRes
+---
+
+## Description
+
+xeus-cpp is a Jupyter kernel for cpp based on the native implementation of the Jupyter protocol xeus. This enables users to write and execute C++ code interactively, seeing the results immediately. This REPL (read-eval-print-loop) nature allows rapid prototyping and iterations without the overhead of compiling and running separate C++ programs. This also achieves C++ and Python integration within a single Jupyter environment.
+
+The xeus-cpp is a successor of xeus-clang-repl and xeus-cling. The project goal is to advance the project feature support to the extent of what’s supported in xeus-clang-repl and xeus-cling.
+
+## Project Milestones
+
+* Fix occasional bugs in clang-repl directly in llvm upstream
+* Implement the value printing logic
+* Advance the wasm infrastructure
+* Write tutorials and demonstrators
+* Complete the transition of xeus-clang-repl to xeus-cpp
+
+## Requirements
+
+* Python and C++ programming
+* Knowledge of Clang and LLVM
+
+## Mentors
+* **[Alexander Penev](mailto:[email protected])**
+* [Vassil Vassilev](mailto:[email protected])
+
+## Links
+* [Repo](https://github.com/compiler-research/xeus-cpp)
+* [Docs](https://xeus-cpp.readthedocs.io/en/latest/index.html)

_gsocproposals/2024/proposal_XeusCpp-LLM.md

@@ -0,0 +1,39 @@
+---
+title: Integrate a Large Language Model with the xeus-cpp Jupyter kernel
+layout: gsoc_proposal
+project: Xeus-Cpp
+year: 2024
+difficulty: medium
+duration: 350
+mentor_avail: June-October
+organization:
+  - CompRes
+---
+
+## Description
+
+xeus-cpp is a Jupyter kernel for cpp based on the native implementation of the Jupyter protocol xeus. This enables users to write and execute C++ code interactively, seeing the results immediately. This REPL (read-eval-print-loop) nature allows rapid prototyping and iterations without the overhead of compiling and running separate C++ programs. This also achieves C++ and Python integration within a single Jupyter environment.
+
+This project aims to integrate a large language model, such as Bard/Gemini, with the xeus-cpp Jupyter kernel. This integration will enable users to interactively generate and execute code in C++ leveraging the assistance of the language model. Upon successful integration, users will have access to features such as code autocompletion, syntax checking, semantic understanding, and even code generation based on natural language prompts.
+
+## Project Milestones
+
+* Design and implement mechanisms to interface the large language model with the xeus-cpp kernel. [Jupyter-AI](https://github.com/jupyterlab/jupyter-ai) might be used as a motivating example
+* Develop functionalities within the kernel to utilize the language model for code generation based on natural language descriptions and suggestions for autocompletion.
+* Comprehensive documentation and thorough testing/CI additions to ensure reliability.
+* [Stretch Goal] After achieving the previous milestones, the student can work on specializing the model for enhanced syntax and semantic understanding capabilities by using xeus notebooks as datasets.
+
+## Requirements
+
+* Python and C++ programming
+* Basic knowledge of Large Language Models 
+* Familiarity with the API's of Bard/OpenAI is a plus
+
+## Mentors
+* **[Vassil Vassilev](mailto:[email protected])**
+* [Aaron Jomy](mailto:[email protected])
+* [David Lange](mailto:[email protected])
+
+## Links
+* [Repo](https://github.com/compiler-research/xeus-cpp)
+* [Docs](https://xeus-cpp.readthedocs.io/en/latest/index.html)