Explore Projects

<p>I propose to work on a tool that, given JVM bytecode, decides for each method, whether it performs an effectful computation (including IO, global variable mutation etc.), or it is referentially transparent, that is it yields the same result everytime it is called with same arguments. Such functions are called 'pure functions'. The tool is also supposed to provide information about whether the return type can be the special <code>null</code> value, requiring a <code>Maybe a</code> during Eta-interop. Automated analysis for such data can simplify the development process, by enabling an ffi-generator to generate bindings for Java , ideally without requiring any manual input from the developer. Since the project is mostly exploratory, the analysis is intended to be conservative, but never wrong, in the sense that it should not recommend a return type of <code>a</code> for a function that may return <code>null</code>, but may recommend <code>Maybe a</code> for a function that never returns <code>null</code>. But the aim is to, of course, minimize the number of such cases.</p>

<p>Merge conflicts are part of every version control system structure. There can be situations in which some changes are necessary for a piece of software to function properly but, an unexpected merge conflict may lag the development workflow. The user may want to store a partially resolved merge-state if they have to fix an urgent bug. In the current scenario, they are only allowed to either fully resolve conflicts or abort the operation that led to conflicts by discarding the partially resolved state with conflicts. This project is about adding functionality to store an unresolved merge-state to help the user on such occasions. This lets the user do the required tasks at the moment in the same repository and get back later to the same merge-state and resume resolving conflicts. This project also adds functionality to let someone else do the conflict resolution for the user if they want by committing the conflicts and sharing it with other users.</p>

Description:Kruize Autotune is a Performance Tuning Tool for Kubernetes. . It uses Hyper Parameter Optimization to tune the language runtime layers of a given application. System component metrics can give a better look into what is happening inside them. Metrics are particularly useful for building dashboards and alerts. Kubernetes components emit metrics in Prometheus format. This format is structured plain text, designed so that people and machines can both read it.Following are four common methods of hyperparameter optimization for machine learning in order of increasing efficiency: 1.Manual 2.Grid search 3.Random search 4.Bayesian model-based optimization The aim of Bayesian reasoning is to become “less wrong” with more data which these approaches do by continually updating the surrogate probability model after each evaluation of the objective function. At a high-level, Bayesian optimization methods are efficient because they choose the next hyperparameters in an informed manner. The basic idea is: spend a little more time selecting the next hyperparameters in order to make fewer calls to the objective function. In practice, the time spent selecting the next hyperparameters is inconsequential compared to the time spent in the objective function. By evaluating hyperparameters that appear more promising from past results, Bayesian methods can find better model settings than random search in fewer iterations.So,this project aims at tuning kubernetes applications using bayesian optimization.

<p>Starfish would be a cross platform client side application that would let you open a file in IDE of your choice (vscode, eclipse, intellij, emacs, vi, etc.) or start a debugger locally directly from the browser or file system.This will enable an option to “Open in IDE” through browser extension on various websites like github, gitlab, etc similar to one you see in this demo: <a href="https://fahad-israr.github.io/starfish-demo/" target="_blank">https://fahad-israr.github.io/starfish-demo/</a> [Notice the “Open in IDE” Option] . The application will register and handle custom URL schemes (i.e ide://clone-url?url=<a href="https://github" target="_blank">https://github</a> …​ , ide://open-file?ide:// open-debugger? port =..&amp; project=url, etc.) on users' machine and integrate various browser actions (whenever user triggers the registered custom URL “ide://..”) with user’s IDE(vscode, eclipse, intellij, emacs, vi, etc).</p>

<p>The Proposal contains details for implementation of <strong>Socket Module</strong> to be completed within the timeline of GSOC in the summers. Key elements of the proposal are:</p> <ul> <li>Socket Module to integrate C Socket Calls into Chapel Module.</li> <li>Writing good unit tests and documentation.</li> <li>Performance testing for finding out the best possible implementation.</li> <li>Ensuring Concurrency, Parallelism and Non-Blocking Nature of Procedures.</li> </ul>

<p>This requires completion and packaging of the udiff library. Potential goals include:</p> <ul> <li>Publishing an initial version to PyPI. </li> <li>Adding matrix/tensor calculus support.</li> <li>Adding tests.</li> <li>Adding documentation on use, which will be fairly minimal. </li> <li>Publishing a final version to PyPI.</li> </ul> <p>More Detail: <a href="https://uarray.org/en/latest/gsoc/2020/ideas.html#udiff-completion-and-packaging" target="_blank">udiff: Completion and Packaging</a></p>

<p>Dipy is a python library for analysis of diffusion-weighted MRI (dMRI). Diffusion patterns can reveal microscopic details about tissue architecture and is used in clinical as well as neuroscience research. The IVIM model describes diffusion and perfusion in the signal acquired with diffusion MRI. Recently the interest has expanded and applications have emerged throughout the body including kidneys, liver, and even the heart. Many more applications are now under investigation such as imaging for cancer (prostate, liver, kidney, pancreas, etc.) and human placenta. One of its largest uses is in brain mapping and neuroscience research such as Parkinson’s disease where it is used to study aging and structural degeneration of fibre pathways in the brain. An open source implementation of this model will help researchers and students investigate such applications and will add to Dipy’s ability as a complete diffusion imaging library.</p>

<p>In the ten years since its creation, the Pharo programming environment has evolved greatly: it now has Github support and many cool tools; it’s faster, better and more convenient to use both for people who have been familiar with Smalltalk for decades and for complete newbies. However, there’s one thing that is behind in improvements -- code completion. And so having already had some experience with it, this is something I want to work on and improve.</p>

This project adds native PEM keystore support to WildFly Elytron, enabling WildFly to load Kubernetes TLS secrets directly without any manual conversion. Kubernetes exposes TLS certificates and private keys as PEM files, typically as tls.crt and tls.key. Elytron currently requires JKS or PKCS12 keystores, which creates unnecessary friction when deploying applications in containerized environments. This project introduces a new KeyStoreSpi implementation that reads PEM-encoded certificates and private keys from separate files and exposes them as a standard keystore type (PEM). The implementation integrates seamlessly with Elytron’s existing KeyManager and TrustManager infrastructure, allowing it to be used transparently in current configurations. The main deliverables include a robust PEM parser, the PemKeyStoreSpi implementation, support for separate certificate and key files, Elytron configuration integration, comprehensive test coverage, validation using Kubernetes-style TLS secrets, and clear user documentation.

<p>A Collision Detection system that is an alternate to Bounding Box and Precision Collision Systems. Used In Enigma to detect collisions in a game between objects and sprites.</p>

Pwndbg’s codebase is incosistent and (only partially) structured. The goal of the project, is to "clean" the codebase, by enforcing stricter linting, refactoring code, splitting large files/modules into smaller parts, and adding standardized logging and wrappers. Deliverables: cleaner structure, improved readability, reusable utilities, and documented conventions

<p>The way PySAL users interact with geographic data is directly tied to manipulating unlabeled Numpy arrays. With Pandas readily available for most users, this is tedious fait accompli for users, since the core data model for PySAL's API was designed before Pandas existed. While newer projects have attempted to extend Pandas for geographic data, those packages have difficult-to-install dependencies that make them inaccessible for many end users, and make design decisions which the author thinks are somewhat suboptimal for PySAL's use case. Therefore, I propose to specify and implement a tabular spatial data model in Python leveraging Pandas dataframes directly, rather than through subclassing. This follows in the spatialite idea that spatial data is first data, then spatial. Thus, tooling must focus on enabling spatial operations directly on Pandas dataframes by exploiting column dtype information and dispatching appropriately, instead of a subclassing approach. In the end, this project would result in a simpler data model for PySAL.</p>

A collaboration server is owned by Mission Support System. Local users can be created by using this server. Existing identity providers using SAML 2.0 are desired to be used. A service provider (SP) needs to be implemented on the server side in the existing WSGI application and an authentication into the QT client application. When a user logs in on the QT client, a browser will be triggered for the login process. The QT client user can authenticate afterward by exchanging a one-time token. To test the system, a local identity provider (IdP) will be configured and a few tests will be added.

This project focuses on porting the PyCUDA-based FDTD method solver of gprMax to HIP API. The final target is to run gprMax on AMD ROCm GPUs. HIP Python and HIPIFY+Pybind are considered to be used to do the porting work. The final deliverables consist of the ported kernels and the adaption to the original gprMax code, the setup script, benchmarks, and documents.

<p>The aim is to extend Data Sync ( Data Synchronization using Voyager Framework ) to android by porting of the current aerogear-js-SDK (in which it is currently implemented) to Android to cover up a larger user base and provide the services like Offline Support, Conflict Resolution, and the Data Sync services to the users which is the key feature provided by the AeroGear mobile services.</p>

<p>Built-in data structures are a necessity for any budding language, and in a language where distributed computing is at its core, data structures that can properly be maintained across clusters is desired.</p> <p>For my project, I have designed the core framework for a distributed data structures library, and have implemented two novel scalable distributed data structures, an ordered deque and an unordered multiset, that exceed a naive implementation by at least two orders of magnitude in a moderately sized cluster.</p>

The project aims to create a Command-line utility tool to manage and manipulate FreeCAD preferences from outside the FreeCAD application. This tool is intended to be used for installing and configuring the FreeCAD all through the scripts.

On-machine Inspection (OMI) is a valuable tool used in CNC commercial manufacturing to ensure proper tolerances of the manufactured piece. This is done by attaching a probe to the tool head of the machine and scanning the surface of the finalised product to see if there are discrepancies between the expected result and actual measurements. Including such a tool on FreeCAD, which already has a dedicated set of tools for CNC milling in the Path Workbench, will not only bring it closer to proprietary solutions but even surpass some of them that don't have this feature. This would save time for the machinist and also increase the inherent accuracy of the whole process. Building upon this, sensing solutions can introduce novel approaches to improve the CAM workflow and even generate new solutions not seen before. This proposal argues for an automatized post-processing of, for example, 3D prints by milling them to correct tolerances and inherent defects of the manufacturing process like layer patterns, over-extrusion or limited resolution. For On-machine inspection, there are already commercial solutions available so it's a matter of replicating their implementations on Python for FreeCAD. For the post-processing tool, a more involved overview of optimization algorithms for closely-matching volumes will be needed but it's surely available in the literature. If not, my background in mathematics and physics should prove valuable in the development of such an algorithm. Thus, the main goals for the proposal are to prodive the FreeCAD Path Workbench with two new tools, On-machine Inspection and automatized post-processing of already manufactured pieces, and also to properly test and document these new tools in the FreeCAD wiki.

The goal of the project is to improve the existing implementation of the text node and extend the text support by adding lorem ipsum placeholder, formatting spans and typographical parameters, text on path, text in option to enforce casing (lower, upper, title) area, hyphenation, font fallbacks, flows between text areas, upper case, lowercase, toggle for ligatures and vertical typing.

The major objectives of the project are: 1. Refactoring the Python code to increase efficiency and readability and increase the overall code quality of the entire codebase of the software. 2. To enhance user engagement and support by creating a comprehensive FAQ dataset which is used to train a custom Chatbot. 3. Investigate and discuss different possibilities for multi-GPU model execution, i.e. allow a model to execute (and share memory) across multiple GPUs.

<p>The current Python's development process is very complicated for core developers. When an external contributor uploads a patch for a certain issue, the core developer needs to download the patch and then apply the patch and run the tests manually to make sure it works properly. Also, the core developers review the code on the forked version of Rietveld code review tool which is not being maintained. Once the patch is correct, the changes are committed manually. This is a manual and burdensome process for core developers. On <a href="https://mail.python.org/pipermail/core-workflow/2016-January/000345.html" target="_blank">1st January 2016</a>, Brett Cannon decided to migrate from Mercurial on hg.python.org to Git on GitHub.</p> <p>So, my project is about migrating to Git/Github. I will be working on creating pull requests on Github whenever a patch is submitted on the issue tracker (<a href="https://bugs.python.org" target="_blank">https://bugs.python.org</a>) and integrating various bots to maintain linear history of commits, auto-close of issues, enforce CLA, etc. Towards the end of the GSoC period, I will work on patch-related improvements.</p>

Miri finds undefined behavior but can't explain why, its only debug aid is thousands of lines of interpreter logs. The original Priroda step debugger bitrotted from tight coupling and no CI. This project rebuilds Priroda with a three-tier architecture: a Miri integration layer, a stable core debugger API (step, breakpoints, locals, allocations, threads), and a DAP server giving any modern editor step-debugging support. It lives inside the Miri repo with CI and scripted tests to prevent future bitrot.

P4 (Programming Protocol-independent Packet Processors) is a domain-specific language for network devices. It allows programmers to specify how data plane elements (switches, NICs, routers) process packets without needing to deal with the specifics of the underlying hardware. The absence of a code formatter for the P4lang poses challenges for developers working on large codebases, hindering efforts to maintain consistent coding styles across projects.This project aims to address this gap by developing a code formatter specifically tailored for P4. This would enhance productivity by standardising coding styles, facilitating collaboration among developers, and improving code readability. By implementing this tool, developers will be able to efficiently format P4 codebases, ensuring adherence to coding standards and fostering a more streamlined development process.