Explore Projects

<p>Nvim works as both a server and a client. “Nvim client” can connect to any other “Nvim server” and Nvim GUIs can show the screen of a remote “Nvim server”. But the built in Nvim TUI cannot show the screen of a remote Nvim server. The goal of this project is to bring this functionality to Neovim.</p> <p>The aim of the project can be summarized as: Whenever the user starts Nvim as</p> <p><code>nvim --connect {addr}</code></p> <p>the Nvim will connect to the Nvim server running at <code>{addr}</code>, where <code>{addr}</code> is either a <code>pipe</code> or a <code>tcp</code> address. The Nvim client instance would send input to the remote Nvim server and reflects the UI of the remote Nvim server. So the Nvim client acts like any other external GUI.</p> <p>Thus, this project makes <code>TUI</code> an RPC client. This enables us to convert <code>nvim</code> from a multi-threaded process, where <code>TUI</code> and <code>nvim server</code> ran on separate threads, to a multi-process system with <code>TUI</code> and the <code>server</code> running as separate processes and interacting with each other using the RPC API (<code>MessagePack</code>) of <code>nvim</code>.</p>

<p>Machine Learning algorithms for data analysis makes new areas such as Big Data analysis. Emerging data analysis with the streaming data is one of the most paramount areas that will be pioneered the businesses in the future. WSO2 ML (Machine Learner) is one of the main platforms which building some intelligent and predictive data analysis based on the machine learning algorithms to support modern data transactions. Even though they have ML which is build upon the well known Apache Spark MLLib, WSO2 ML still could not support streaming data. Even though the Spark MLLib has streaming support for k mean clustering and generalized linear regression (GLR) , it developed with a Scala API. Purpose of this project is to develop a Java API to support streaming k mean clustering and GLR with the mini batch sampling techniques to support streaming data without using Spark streaming. Therefore design include a way to acquire streaming data and break those data streams into mini batches which can be used this batches to retrain the models periodically with some optimization techniques such as Stochastic gradient descent algorithms.</p>

<p>IPv6 re-configuration through DHCP is a server triggered mechanism for the clients to update their IPv6 addresses and prefixes. The server behavior of sending and handling Reconfigure message is specified in RFC3315bis Internet draft. Kea-dhcpv6 server currently does not support Reconfigure messages and its associated remote key authentication protocol. The task of this project would be to extend Kea server software with the support of sending and handling of Reconfigure message in kea-dhcpv6 server as specified in RFC 3315-bis Internet Draft</p>

dubbo-rust provides basic RPC communication and service governance capability in microservice scenarios. deliverables: + protoc-gen-rust-triple: protoc plugin + service governance capability: server discovery, server registry, config server, metadata server + dubbo-rust code

<p>The project asks for a com_users component that adheres to the current coding standards and that is extended with two views, one with the list of users and one with the public profile.</p>

Robotics Academy is a framework for learning robotics and computer vision. It consists of several exercises, where each exercise consists of exercise.py and exercise.html, the web template is currently built on HTML, Javascript, and CSS. The purpose of this project is to migrate and improve the web template by using advanced front-end technologies like React, Vue, or Angular. The technology I have chosen for the project is REACT, an open-source library providing fast and better performance. There are 26 exercises and a Home screen that are required to be migrated to REACT. Along with REACT, worldview for 2d and 3d rendering, noVNC library to create VNC client, reactstrap for styling, react-router-dom for routing, and reactAce to create an ACE editor. The deliverable for the project will be a folder containing templates for the exercise in react, repository architecture updated accordingly, and documentation.

Pgexporter provides Prometheus metrics for PostgreSQL servers which include some core metrics, as well as custom metrics provided by users. The custom metrics are SQL queries that are run by the various servers, which subsequently may have a variety of PostgreSQL versions. If a query has parts of it not supported by a particular such server, then the whole query gets rejected. This proposal aims to solve this issue by enabling users to provide alternatives of the query of a metric along with the minimum PostgreSQL version on which each alternative query’s supported. Thus, whenever a particular server will need to be queried with a custom query, then based on the PostgreSQL version of the server, the corresponding query will be sent to the server, and the response will be formatted in the form of Prometheus metrics. This will greatly benefit both the users, as well as developers, to provide an out-of-the-box solution and would neither require the updation of codebases to cater to new PostgreSQL major version releases, nor would require the users to adapt to that change.

# Advance Device Profiles --- To enhance RIoTPot with pre-set and custom device profiles. The profiles will be displayed using an interface that users can toggle to customise their experience. Profiles are provided with services, banners and other device information. This configuration should be available to the user while using the application. ## Timeline 1. June-July: Basic API to communicate between the web interface and RIoTPot configuration and state. 2. July to August: Create behaviour trees and a switch-based view. Hand-in phase 1 3. August to September: Implementing a number of profiles and cleaning the documentation. 4. September until the end: Hand in phase 2 and polish the application.

In this proposal, I outline three projects. The following is a brief outline of each project problem, solution, and set of deliverables: Project 1) Improving Test Coverage Problem: Vorta has a current test code coverage of 72%, and we would like to get this in the 80% - 85% range. Additionally, current testing files need more a consistent file structure and organization. Solution: Work with organization mentors to prioritize test code coverage. Create unit and integration tests to reach our target code coverage. Reorganize and restructure testing file. Deliverables: At least 80% code coverage, with a stretch goal of 85%. Test files separated into unit tests vs integration tests. Consistency in file naming and structure across all test files. Project 2) Implement Profile Sidebar Problem: The current profile selector and setting tab implementation mixes global setting with profile specific settings. Solution: Move the profile selector and settings button to a collapsible sidebar. The settings button opens a new interface with options relating to global settings and profile management, while the individual profile buttons open to profile specific settings. Deliverables: A new sidebar with profile selector and setting button, as well as a new setting interface. Unit and integration testing accompanying all new features. Project 3: Test on Live Borg Binary Problem: Currently we test on static mock files of Borg JSON output. This task would improve testing to run on actual Borg versions/binaries. Solution: Test multiple versions of Borg using Tox to simplify testing. Implement these changes in setup.cfg Deliverables: CICD running tests on live Borg binaries with > 99% success rate. Include the option to run existing integration tests locally. Include thorough documentation of this process.

This proposal outlines a comprehensive plan to implement a system that enables end-users to verify the integrity of their game files against reference checksums. The system will be composed of a server component for storing and comparing checksums and an extension within ScummVM for computing and submitting these checksums.

<p>Build an inventory of the features present in the legacy UI that need to be moved to OWAs Replace existing JSP UI with OWA based on React Components then delete the JSP pages and build missing web service end-points which may not exist.</p>

Observability is very important for each application, we want to monitor more things of Chaos Mesh components, enrich the metrics for both logic patterns and performance data. We want to let users could watch the status of Chaos Mesh on grafana dashboard, and developers could using time-series metrics for debugging and profiling.

<p>Webiu is a “generalized website builder” which magnificently eases the essential process of getting a website up and running easily. The project provides almost all of the different sections required by a normal website as different reusable components. This project proposal aims at adding and implementing new features and functionalities into the current project to make it more reusable and accessible and further ease the process of building a website. Creating a logo, improving current components functionally, developing new components, creating an NPM package for Webiu, documenting the components using Storybook are some of the works (but not limited to) proposed. The proposal when implemented will functionally improve the current project, increase the range of the project and make the components accessible to other developers to incorporate them for developing websites.</p>

<p>Inputstream.adaptive is written in C++ and handles 3 bitstreams: HTTP Live Streaming (HLS) Dynamic Adaptive Streaming over HTTP (DASH) Smooth Streaming (ISM) This add-on provides packet to Kodi, and then Kodi renders the packets on the internal video player. While streaming, currently there is no inbuilt feature to switch bitstream automatically when external factors like network available bandwidth, screen window/ resolution changes for a minimum time, frames are not able to be rendered properly due to computation limitation. So, my focus of work will be mostly in this area to automatically switch the streaming to higher/lower resolutions depending on external factors/parameters available. Also I will implementing playback speed/ frame dropping.</p>

The architecture of the GHC compiler in its current state is anti-modular. Designed with GHC-the-program as the sole consumer in mind, it is very difficult for newer tooling to reuse its components. These problems extend to the inclusion of new backends such that implementations for various target platforms forked GHC frequently. The first step to improving the current design is the isolation of the different components and separation the codebase in layers for different purposes, described in the classic book "Domain Driven Design". This is already partly done, and in this project I join the existing effort by working on the next remaining subsystem: GHC's Core pipeline. In order to achieve my goal, I will proceed by using an incremental bottom-up approach: Starting at the bottom of the module hierarchy, I will push references to upper layers module-by-module up in the callstack until they are completely removed from each component. For the entry points of each in-scope component, I will then provide component-specific configuration types and corresponding initialization functions. The in-scope components are specific configurable tasks of the optimizer, and the optimizer as a whole. With this work completed, there will be significantly less references to the ubiquitous global states used throughout the whole compiler, namely the DynFlags and the HscEnv type, and significantly fewer imports of modules from upper layers, e.g. the driver.

The Objective of this project is to develop IDE plugins that can enhance the developer experience while working with Service Mesh Performance performance Profiles. Project Goals: Create a vs code extension for syntax highlighting and validation for smp models. Tech Stack: Language Server Protocol(LSP), Cloud native Componenets and relationships

New Frontend Framework for Simulator UI The project focuses on replacing JqueryUI with a modern frontend framework. I have divided the coding time period into 5 Parts - 1. Decoupling the Simulator 2. Dividing into Components 3. Sate Management 4. Refactoring CSS 5. Internationalization using vue-banana-i18n I will start by decoupling the Simulator UI from the backend followed by restructuring the folder structure. Dividing the Simulator UI into small Components, replace DOM mutations with strings by conditionally rendered components. Managing the states of different components and using various powerful features of the frontend framework like Lifecycle hooks. Refactoring the styles into their respective components. A lot of work for Localization of Simulator has already been done, so integrating it with the new frontend framework.

<p>Project: Migrating the 'Koko' image gallery application's UI components to Kirigami.</p> <p>Brief Explanation: The current version of Koko uses the QtQuickControls components that use QML for internal event handling. However, kirigami uses QtQuickControls2 components that provide better internal event handling(done through c++). The project will focus:</p> <ul> <li>Designing basic components required for Koko through kirigami, C++ and QtQuickControls2.</li> <li>Using the components in the application itself.</li> <li>Adding Tap-and-hold gestures.[Optional]</li> </ul> <p>Expected Results: Have a proper functioning mobile-friendly user interface for Koko on the top of kirigami.</p> <p>Knowledge Prerequisite: QML, Qt5 and C++.</p>

Integrate a new user experience into Meshery: a cloud native design configurator. This project involves presentation of Kuberenetes core resources and any custom resource (CRD) as a configurable component in a React-based user interface in which users design (in great detail) and deploy their cloud native infrastructure. Interns will familiarize with concepts of content lifecycle management.

ROOT is a framework for data processing, born at CERN, at the heart of the research on high-energy, molecular and laser physics, as well as in astronomy. ROOT has plenty of built-in components. Because of a variety of features, ROOT is a very large software which takes a very long time to compile. Currently ROOT compiles all of the components available within the source code distribution. The goal of the project is to speed up the compilation process by letting users specify which components of the ROOT will be needed. This can be done by converting ROOT’s CMake configuration into a set of “CMake External Projects” (superbuilds). Superbuilds can remove all of this cruft from the project’s source repository, and enable you to more directly use the upstream project’s build system as an independently built software component. It is basically a simple package manager that you make consistently work across your target build platforms, and if your target platforms have a common package manager you might consider using that instead. Also, during the configuration process it could be possible to identify if ROOT is already installed in the destination folder, the components which are already installed and offer an option to skip their compilation and use these already installed components for current compilation. We are not going to change the build system of ROOT, but to optimize it and offer users an option to select only the parts of the ROOT to be built. Partial builds for ROOT can allow the creation of “edition” builds if necessary.

Libafl is a library written in Rust that provides components to build fuzzers. A newcomer might feel confused when creating a fuzzer because that requires some knowledge of what each component does and how they can be used together. Without prior experience, going through the repository and trying to understand these features on your own is not a trivial task. To make Libafl more beginner-friendly, as well as didactic, this project proposes the implementation of a Fuzzer Template Generator. The generator will guide the user through the components, explain their functionalities and utilization, and output snippets of that component's Rust code, so the user may apply it to their fuzzer implementation. Therefore, this project aims to: 1. Implement a wizard, to show options and take the user's decisions, 2. Add a progressive flow chart generation, to help keep visual track, 3. Output Rust code for each component selected.

<p>Rucio produces large amounts of metadata for it’s files and datasets which is stored in a central Rucio server. However there is a fixed set of metadata attributes that can be stored currently. Rucio would like a generic metadata catalogue with no restriction on the kind of metadata stored for the files. The project is to to design and implement a generic and scalable metadata component that integrates with the core transactional model of Rucio.</p>

<p>SaltStackis an open-source software that facilitates configuration management for IT infrastructures. Salt Virt is a component of SaltStack which functions as a cloud controller that offers a high level view of the cloud resources to assist cloud management. It supports a handful of core cloud operations such as virtual machine deployment, inspection, migration, network profiling etc. I propose to make some existing Libvirt API domain properties configurable in Salt Virt in order to provide advanced performance tuning options.</p>