Merge pull request #154 from QuillPusher/simplified_projects_and_rese…

…arch

New Projects and Research pages

README.md

@@ -133,6 +133,32 @@ docker run --rm -v "$PWD:/srv/jekyll" \
            jekyll serve --livereload
 ```
 
+## Guide to Making Changes to the Website
+
+### Adding a Project to /projects/ directory on the Website
+
+It is possible to 
+
+- add a new page with a lot of project details (e.g.,
+`\_pages\testproject.md`) and then add the project excerpt to the projects
+directory `_data\projects.yml`, or 
+
+- you can simply add the project excerpt to the projects directory
+`_data\projects.yml` if there aren't enough details available for the project.
+
+Next, use the `link` attribute in the `projects.yml` file to define the link
+to the detailed project page (if you created this in the previous step).
+
+The project excerpt should now automatically show up on the '/Projects/' page
+along with the link to the detailed project page.
+
+To change the layout of the Projects page itself, you can browse to
+`_pages\projects.md` and edit the Liquid code as needed.
+
+> Please note that the Projects page exists in parallel to the Open Projects
+> page (`_pages\open_projects.md`), and you should add your project details
+> where it makes more sense.
+
 
 [installation]: https://jekyllrb.com/docs/installation/windows/
 [RubyInstaller Downloads]: https://rubyinstaller.org/downloads/

_data/projects.yml

@@ -0,0 +1,84 @@
+- name: "Xeus-CPP - a Jupyter Kernel for C++"
+  description: |
+    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).
+
+    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://github.com/compiler-research/xeus-cpp
+
+- name: "Clang-REPL - an Interactive C++ Interpreter"
+  description: |
+    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.
+
+    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
+
+- 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://github.com/compiler-research/CppInterOp
+
+- 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
+    optimized compilation processes. 
+
+    By adopting a read-eval-print-loop (REPL) approach, Cling is helping C++
+    development evolve by enabling rapid application development without the need
+    for the traditional edit-compile-run-debug cycle, thus facilitating quick
+    prototyping and exploration in C++.
+
+    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.
+  link: |
+    https://github.com/root-project/cling
+
+- name: "Clad - an Automatic Differentiation Tool"
+  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.
+
+    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://github.com/vgvassilev/clad
+
+
+
+
+
+

_includes/header.html

@@ -12,20 +12,26 @@
       </a>
     </div>
     <ul id="navbar-collapse-1" class="nav navbar-nav ml-auto navbar-collapse collapse">
-      <li class="nav-item dropdown">
+<!--      <li class="nav-item dropdown">
         <a href="#" class="nav-link dropdown-toggle" id="dropdown02" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Research</a>
         <ul class="dropdown-menu" aria-labelledby="dropdown02">
           <li class="dropdown-item"> <a class="nav-link" href="/caas">Compiler-As-A-Service</a></li>
           <li class="dropdown-item"> <a class="nav-link" href="/interactive_cpp">Incremental C++</a></li>
           <li class="dropdown-item"> <a class="nav-link" href="/libinterop">Language Interoperability</a></li>
         </ul>
-      </li>
+      </li> 
       <li class="nav-item dropdown">
         <a href="#" class="nav-link dropdown-toggle" id="dropdown02" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Projects</a>
         <ul class="dropdown-menu" aria-labelledby="dropdown02">
           <li class="dropdown-item"> <a class="nav-link" href="https://rawgit.com/root-project/cling/master/www/index.html">Cling</a></li>
           <li class="dropdown-item"> <a class="nav-link" href="/clad">Clad</a></li>
         </ul>
+      </li>-->
+      <li class="nav-item">
+        <a class="nav-link" href="/research">Research</a>
+      </li>
+      <li class="nav-item">
+        <a class="nav-link" href="/projects">Projects</a>
       </li>
       <li class="nav-item dropdown">
         <a href="#" class="nav-link dropdown-toggle" id="dropdown01" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Results</a>

_pages/projects.md

@@ -0,0 +1,25 @@
+---
+title: "Compiler Research Projects"
+layout: gridlay
+excerpt: "Notable Projects by Compiler Research Group"
+sitemap: false
+permalink: /projects/
+---
+
+Following are some notable projects.
+
+
+{% for project in site.data.projects %}
+
+  <div class="well" style="padding-left: 20px; padding-right: 20px">
+
+  **{{ project.name }}**
+
+  {{ project.description | markdownify }}
+
+  For more details, please browse to this <a href="{{ project.link }}">link to the project</a>
+
+  </div>
+
+{% endfor %}
+

_pages/research.md

@@ -0,0 +1,111 @@
+---
+title: "Compiler Research Research Areas"
+layout: gridlay
+excerpt: "Research"
+sitemap: false
+permalink: /research/
+---
+
+Following are the areas of research that Compiler Research Group is focused on:
+
+#### [Automatic Differentiation ↗]
+
+Automatic Differentiation (AD) is a useful technique in scientific research
+fields like machine learning and computational physics. AD enables the
+automatic computation of derivatives of functions with high precision and
+efficiency. A notable implementation of AD is the [Clad plugin for the Clang]
+compiler. This integration not only simplifies the process of differentiation
+but also enhances the performance and accuracy of numerical computations in
+scientific applications.
+
+In scientific research, where intricate mathematical models are prevalent, the
+utilization of AD through tools like the Clad brings a new level of
+sophistication and speed to derivative calculations. By leveraging AD within
+C++ compilers, researchers can focus more on the scientific aspects of their
+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 (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
+gives developers unprecedented control and insights into the compilation
+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
+Python).
+
+
+#### [Incremental C++ ↗]
+
+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.
+
+Ongoing research in projects such as [Cling], [Clang-REPL], etc. aims to
+provide practically usable interactive capabilities to the C++ programming
+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:
+
+- In Data Science: Interactive probing of data and interfaces, making complex
+  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. 
+
+- In Exploratory Programming: rapid reproduction of results, which is crucial
+  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.
+
+#### [Language Interoperability ↗]
+
+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 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".
+
+The practical implications of language interoperability include the growing
+need for systems in data science to be able to interoperate with C++
+codebases. By providing automatic creation of bindings on demand, tools
+like CppInterOp enable Python to interoperate with C++ code dynamically,
+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.
+
+
+[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/
+
+[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://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 ↗]: https://compiler-research.org/caas/
+
+[Incremental C++ ↗]: https://compiler-research.org/interactive_cpp