Review changes for Projects and Research

- removed footnotes

- linked research page headings (added a link icon to show it is clickable)

- heading change: Clad - an Automatic Differentiation Tool

- Projects Page: remove Interactive C++ (Cling Use Case) and Incremental Compilation Support in Clang (CaaS)

- Added Clang-REPL to Projects YML

- Added xeus-cpp to Projects YML

- Changed links from "LibInterOP" page to "CppInterOp" Readme link

Author: QuillPusher

Gemfile.lock

@@ -1,33 +1,49 @@
-- name: "C++ Language Interoperability Layer"
+- name: "Xeus-CPP - a Jupyter Kernel for C++"
   description: |
-    In the CppInterOp (previously LibInterOp) project, we explore the key aspects
-    of language interoperability with C++ using an automated binding approach,
-    focusing on automatic binding to and from Python, but also applicable to other
-    languages like D and Julia. 
+    Xeus-CPP is a product of OAC-1931408 in collaboration with the QuantStack
+    company. It is a Jupyter kernel for C++ based on the native implementation
+    of the Jupyter protocol xeus. It is supports the Wasm version of Jupyter
+    (JupyterLite). It is a generalization of the Xeus-Clang-Repl (a Jupyter
+    plugin supporting C++ development based on ClangRepl).
 
-  category: "Language Interoperability"
+    With Xeus-CPP, you can write and execute C++ code interactively, seeing
+    the results immediately. This REPL nature allows you to iterate quickly
+    without the overhead of compiling and running separate C++ programs.
   link: |
-      https://compiler-research.org/libinterop/
+    https://github.com/compiler-research/xeus-cpp
 
-- name: "Clad - Clang Plugin"
+- name: "Clang-REPL - an Interactive C++ Interpreter"
   description: |
-    Clad is a plugin for the Clang compiler that enables automatic differentiation
-    capabilities for C/C++ codebases. It is a valuable tool for developers seeking
-    to streamline complex mathematical computations and optimize their codebase
-    efficiently.
+    Clang-Repl is an interactive C++ interpreter that allows for incremental
+    compilation. It supports interactive programming for C++ in a
+    read-evaluate-print-loop (REPL) style.
 
-    Clad facilitates the generation of derivatives, gradients, Hessians, and
-    Jacobians (in forward and/or reverse mode), enhancing the efficiency and
-    versatility of numerical computations.
+    Clang-Repl is suitable for exploratory programming and in places where
+    time to insight is important. Clang-Repl is a project inspired by the work
+    in Cling, a LLVM-based C/C++ interpreter developed by the field of high
+    energy physics and used by the scientific data analysis framework ROOT.
+    Clang-Repl allows to move parts of Cling upstream, making them useful and
+    available to a broader audience.
+  link: |
+    https://clang.llvm.org/docs/ClangRepl.html
 
-    Clad not only supports partial and higher-order derivatives but also
-    integrates seamlessly with frameworks like ROOT, providing a comprehensive
-    solution for automatic differentiation needs in C++ applications.
-  category: "Automatic Differentiation"
+- name: "CppInterOp - a C++ Language Interoperability Layer"
+  description: |
+    CppInterOp (previously LibInterOp) is a product of OAC-1931408 and exposes
+    APIs from Clang and LLVM in a mostly backward compatibe way. The APIs
+    support downstream tools that utilize interactive C++ by using the
+    compiler as a service. That is, embed Clang and LLVM as a libraries in
+    their codebases. 
+    
+    The APIs are designed to be minimalistic and aid non-trivial tasks such as
+    language interoperability on the fly. In such scenarios CppInterOp can be
+    used to provide the necessary introspection information to the other side
+    helping the language cross talk. The package makes it easy to deploy as it
+    ships Clang as a service without any dependencies. 
   link: |
-    https://compiler-research.org/clad/
+    https://github.com/compiler-research/CppInterOp
 
-- name: "Cling - C++ Interpreter"
+- name: "Cling - an Interactive C++ Interpreter"
   description: |
     Cling is an interactive C++ interpreter that operates on top of the Clang and
     LLVM libraries, utilizing LLVM's Just-In-Time (JIT) compiler for fast and
@@ -41,26 +57,28 @@
     By providing support for advanced C++ features like templates, lambdas, and
     virtual inheritance, Cling empowers developers in exploratory programming with
     interactive, dynamic language interoperability and rapid prototyping.
-  category: "Interactive C++"
   link: |
-    https://rawgit.com/root-project/cling/master/www/index.html
+    https://github.com/root-project/cling
 
-- name: "Interactive C++ (Cling Use Case)"
+- name: "Clad - an Automatic Differentiation Tool"
   description: |
-    Researchers heavily rely on tools that minimize the "time to insight" to
-    enhance productivity. However, the escalating data volumes and computational
-    demands necessitate a constant emphasis on optimizing code performance. This
-    is where interactive capabilities of tools like Cling are useful, enabling
-    navigation through a diverse set of programming languages, development tools,
-    and hardware.
-  category: "Interactive C++"
-  link: |
-    https://compiler-research.org/interactive_cpp
+    Clad is a plugin for the Clang compiler that enables automatic differentiation
+    capabilities for C/C++ codebases. It is a valuable tool for developers seeking
+    to streamline complex mathematical computations and optimize their codebase
+    efficiently.
 
-- name: "Incremental Compilation Support in Clang (CaaS) Project"
-  description: |
-    Incremental compilation aims to support clients that need to keep a single 
-    compiler instance active across multiple compile requests. 
-  category: "Compiler-As-A-Service"
+    Clad facilitates the generation of derivatives, gradients, Hessians, and
+    Jacobians (in forward and/or reverse mode), enhancing the efficiency and
+    versatility of numerical computations.
+
+    Clad not only supports partial and higher-order derivatives but also
+    integrates seamlessly with frameworks like ROOT, providing a comprehensive
+    solution for automatic differentiation needs in C++ applications.
   link: |
-    https://compiler-research.org/caas/
+    https://github.com/vgvassilev/clad
+
+
+
+
+
+

_data/projects.yml

@@ -8,7 +8,7 @@ permalink: /research/
 
 Following are the areas of research that Compiler Research Group is focused on:
 
-### Automatic Differentiation
+#### [Automatic Differentiation ↗]
 
 Automatic Differentiation (AD) is a useful technique in scientific research
 fields like machine learning and computational physics. AD enables the
@@ -26,9 +26,9 @@ work rather than getting bogged down in manual differentiation tasks. This
 automation not only accelerates the development process but also ensures that
 computations are error-free and consistent.
 
-### Compiler-As-A-Service
+#### [Compiler-As-A-Service ↗]
 
-[Compiler as a Service (CaaS)] is an evolving technology that redefines the
+Compiler as a Service (CaaS) is an evolving technology that redefines the
 traditional approach to compilers by providing a service-oriented
 architecture. Instead of treating the compiler as a black box, the CaaS
 approach helps open up the functionality to make it available as APIs. This
@@ -37,13 +37,13 @@ process, while being able to use lightweight APIs for simpler workflows and
 diagnostics, helping create sophisticated applications more efficiently.
 
 Practical applications of CaaS include deeper and interactive program analysis
-and conversion from one programming language to another (e.g., C++ <->
+and conversion from one programming language to another (e.g., C++ and
 Python).
 
 
-### Incremental C++
+#### [Incremental C++ ↗]
 
-Despite its high performance capabilities, C++ not the first programming
+Despite its high performance capabilities, C++ is not the first programming
 language that comes to mind for rapidly developing robust applications, mainly
 due to the long edit-compile-run cycles.
 
@@ -53,30 +53,31 @@ language. The goal is to enable dynamic interoperability, rapid prototyping,
 and exploratory programming, which are essential for data science and other
 scientific applications.
 
-Following are some practical applications of a "[C++ Interpreter]," so to speak:
+Following are some practical applications of a "C++ Interpreter," so to speak:
 
 - In Data Science: Interactive probing of data and interfaces, making complex
-  libraries and data more accessible to users. [^1]
+  libraries and data more accessible to users. 
 
-- In CUDA: The Cling CUDA extension brings the workflows of interactive C++ to
-  GPUs without losing performance and compatibility to existing software. [^1]
+- In CUDA: The Cling CUDA extension brings the workflows of [Interactive C++] to
+  GPUs without losing performance and compatibility to existing software. 
 
 - In Exploratory Programming: rapid reproduction of results, which is crucial
-  during the exploratory phase of a project. [^2]
+  during the exploratory phase of a project.
 
-- In Jupyter Notebooks: Interactive C++ can be integrated with Jupyter
-  Notebooks, providing a swift prototyping and learning experience for C++ users. [^2]
+- In Jupyter Notebooks: Interactive C++ can be [integrated with Jupyter
+  Notebooks], providing a swift prototyping and learning experience for C++
+  users.
 
-### Language Interoperability
+#### [Language Interoperability ↗]
 
-[Language interoperability] helps programmers get the best of both worlds, with
+Language interoperability helps programmers get the best of both worlds, with
 the ability to work with a high-performance language (e.g., C++), and at the
 same time, take advantage of a more interactive one (e.g., Python), while
 helping them identify each other's entities (like variables and classes) for
 seamless integration.
 
 This interoperability can be achieved by libraries like [CppInterOp], which
-expose APIs from compilers like Clang/LLVM in a backward-compatible manner. By
+expose APIs from compilers like Clang in a backward-compatible manner. By
 enabling interactive C++ usage through the Compiler-As-A-Service, CppInterOp
 simplifies complex tasks such as "language interoperability on the fly".
 
@@ -88,24 +89,23 @@ instantiate templates, and execute them efficiently. This dynamic approach not
 only improves performance but also simplifies code development and debugging
 processes, offering a more efficient alternative to static binding methods.
 
----
-Footnotes:
 
-[^1]: [Interactive C++ for Data Science](https://blog.llvm.org/posts/2020-12-21-interactive-cpp-for-data-science/)
+[Automatic Differentiation ↗]: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2072r0.pdf
 
-[^2]: [Interactive Workflows for C++ with Jupyter](https://blog.jupyter.org/interactive-workflows-for-c-with-jupyter-fe9b54227d92)
+[Interactive C++]: https://blog.llvm.org/posts/2020-12-21-interactive-cpp-for-data-science/
 
+[integrated with Jupyter Notebooks]: https://blog.jupyter.org/interactive-workflows-for-c-with-jupyter-fe9b54227d92
 
 [CppInterOp]: https://github.com/compiler-research/CppInterOp/blob/main/README.md
 
 [Clad plugin for the Clang]: https://compiler-research.org/clad/
 
-[Language interoperability]: https://compiler-research.org/libinterop/
+[Language Interoperability ↗]: https://cppinterop.readthedocs.io/en/latest/index.html
 
 [Cling]: https://rawgit.com/root-project/cling/master/www/index.html
 
 [Clang-REPL]: https://clang.llvm.org/docs/ClangRepl.html
 
-[Compiler as a Service (CaaS)]: https://compiler-research.org/caas/
+[Compiler-As-A-Service ↗]: https://compiler-research.org/caas/
 
-[C++ Interpreter]: https://compiler-research.org/interactive_cpp
+[Incremental C++ ↗]: https://compiler-research.org/interactive_cpp