update

Author: QuillPusher

_data/projects.yml

@@ -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
+
+
+
+
+
+

_pages/research.md

@@ -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
@@ -41,7 +41,7 @@ and conversion from one programming language to another (e.g., C++ and
 Python).
 
 
-### Incremental C++
+#### [Incremental C++ ↗]
 
 Despite its high performance capabilities, C++ is not the first programming
 language that comes to mind for rapidly developing robust applications, mainly
@@ -53,7 +53,7 @@ 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. 
@@ -68,9 +68,9 @@ Following are some practical applications of a "[C++ Interpreter]," so to speak:
   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
@@ -90,6 +90,7 @@ only improves performance but also simplifies code development and debugging
 processes, offering a more efficient alternative to static binding methods.
 
 
+[Automatic Differentiation ↗]: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2072r0.pdf
 
 [Interactive C++]: https://blog.llvm.org/posts/2020-12-21-interactive-cpp-for-data-science/
 
@@ -99,12 +100,12 @@ processes, offering a more efficient alternative to static binding methods.
 
 [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