Google Summer of Code 2023 proposed ideas

Contributors interested to participate should check which of the following projects fits their interests and skills.

Τo communicate with the mentors and ask questions about the projects, students should subscribe to this list and post relevant questions. Please follow the Proposal Template

For practical information, developers should visit this page.

DIY IoT Physics

Brief Explanation

Remote physics experiments for students in all the educational levels are the second best to hands on experiments. Especially for students who temporarily cannot attend school or in cases like the Covid-19 and the lockdowns. In many practical cases they are the only alternative, as they are available 24/7, they can involve dangerous materials or conditions, they can be accessed from anywhere and any device, they require less maintenance, have lower cost, can be easily modified, or arranged to perform another experiment, and are less probable to be damaged. They are in line with the modern way to perform experiments, as it is desirable to have as less as possible direct contact with the experiments and use them on-line. Like on-line telescopes and electronic microscopes. This is possible due to the automation, data acquisition and manipulation of the experimental data is done using a computer or a microcomputer. In this way students need not to take pain stacking notes, especially for experiments that take a lot of time to collect data, like days or months. The students can concentrate on data processing and on the physics of the results. Our laboratory has setup a lot of remote experiments and has experience of more than 10 years in designing, setting and servicing remote experiments. Our remote experiments are based on Arduino and readily available sensors and actuators. The aim of the present project is to design and implement a way to make the sensors and the actuators to form an IoT local network so that it will be easier to utilize them in different experiments easily and also to build new experiments. The IoT sensors and actuators will be DIY based on open software. The applicant will program the ESP8266 to receive data from the sensor and transmit through MQTT the data to ThingsBoard and similarly for the actuator the ESP8266 will receive MQTT data from ThingsBoard. The applicant will prepare five DIY IoT sensors and five actuators. ThingsBoard will provide users with the visual representation of the data and the control of the experimental setup through dashboards. The applicant will prepared five dashboards for corresponding experiments.

Duration of the Project

175 hours (Medium Size)

Expected Results

At the end of that GSoC project the open source code for five IoT DIY sensors and five actuators will be designed and implemented. Also five Dashboards on the open source IoT platform ThingsBoard for five corresponding experiment will be designed and implemented. A list of the electronic components, instructions for the assembly and documentation for the software will be prepared.

Related repositories

https://github.com/totheworld2004/DIY-Physics-IoT

Knowledge Prerequisites

How to program ESP8266, MQTT to transfer and receive data and design and implement Dashboards on a IoT platform

Mentors:

Hariton Polatoglou and Panagiotis Koustoumpardis

Creating new lattices for Apothesis

Brief Explanation

Apothesis is a generalized software for deposition processes on solid surfaces which is based on kinetic Monte Carlo (KMC) method. In order to apply the KMC method [1] a lattice is needed where the elementary processes (adsorption, desorption, migration and surface reaction(s) ) are performed. These lattices consist of sites which are activated centers where the different processes take place. Based on the physical representation of the surfaces different lattices can be constructed. Currently, Apothesis supports Simple Cubic and (partial) Face Cubic Center (FCC) lattices. In the current proposed project, we focus on expanding the capabilities of Apothesis by adding hexagonal [2] and diamond lattices [3] - two very popular lattices used in surface sciences.

Duration of the Project

350 hours (Large Size)

Expected Results

Apothesis has the basic infrastructure (parent class) containing the minimum information for creating a lattice. The goal of the proposed project is the creation of two classes for generating hexagonal and diamond lattices based on these parent class. We expect that this will be a great enhancement in the capabilities of Apothesis allowing the investigation of various physical/chemical systems.

Related repositories

https://github.com/nixeimar/Apothesis

Knowledge Prerequisites

C++, elementary physics

Mentors:

Nikolaos Cheimarios: nixeimar@chemeng.ntua.gr, Vissarion Fisikopoulos: vissarion.fisikopoulos@gmail.com

Control and Management Patterns as Node-RED flows

Brief Explanation

Node-RED (https://nodered.org/) is a popular low code programming environment for event driven applications, particularly in the IoT world. It is based on a visual, browser based editor in which developers can write functions, wire them together to form a workflow, group a subset of functions into reusable and parametric subflows etc. Node-RED can interact with any API or service, thus its usage can be extended to be used in collaboration with other services and frameworks.

The project revolves around the idea of using Node-RED as a controller and orchestrator in event driven programming. For a first look and feel of the scope you can visit this technical report: https://arxiv.org/pdf/2202.09683.pdf

Initial flows that have been created on this scope and can be used as examples can be found here: https://flows.nodered.org/collection/HXSkA2JJLcGA

Points for contribution around the proposal include: - Adaptation of a control logic on the node-red environment by creating a relevant flow that implements it. This flow may regulate how the flow behaves or how it determines how to configure an external system. Examples for such controlling logic may include PID controllers (https://en.wikipedia.org/wiki/PID_controller) inclusion and automated tuning/adaptation, creation of on/off delay switches eyc. - Replication of Cloud design patterns rationale (https://docs.microsoft.com/en-us/azure/architecture/patterns/), for which a relevant flow can be implemented to support them - Creation of adaptable pattern flows that respond to real time events and related monitoring information. To this end, controlling logic may be included as the PID case mentioned above or otherwise (e.g. inclusion of a Neural Network controller) -Packaging of that flow as a subflow and adding parameters of operation and configuration (from the UI or through the incoming message fields)

Duration of the Project

350 hours

Expected Results

The purpose of the work is to exploit Node-RED's subflow and workflow features in order to implement reusable flows that can be shared through Node-RED's repository. The initial scope of the flows is around workflow and control structures for created patterns although other scopes can be proposed. .

Related repositories

https://flows.nodered.org/, https://github.com/node-red, https://flows.nodered.org/collection/HXSkA2JJLcGA

Knowledge Prerequisites

Necessary: javascript, Preferable: Node-RED

Mentors:

George Kousiouris

Alexandria3k Extensions

Brief Explanation

The alexandria3k package supplies a library and a command-line tool providing efficient relational query access to diverse publication open data sets. The most important one is the entire Crossref data set (157 GB compressed, 1 TB uncompressed). This contains publication metadata from about 134 million publications from all major international publishers with full citation data for 60 million of them. In addition, the Crossref data set can be linked with the ORCID summary data set (25 GB compressed, 435 GB uuncompressed), containing about 78 million author records, as well as data sets of funder bodies, journal names, open access journals, and research organizations.

The alexandria3k package installation contains all elements required to run it. It does not require the installation, configuration, and maintenance of a third party relational or graph database. It can therefore be used out-of-the-box for performing reproducible publication research on the desktop, as described in this preprint.

The objective of the proposed project is to extend alexandria3k to support the inclusion of the US Patent Office Datasets, linking the provided metadata. Time permitting, the project can be extended to also cover PubMed/MEDLINE data, author name and affiliation disambiguation, missing contributor relations (e.g. editor), and topic matching.

Duration of the Project

350 hours

Expected Results

It is expected that the student will send a series of pull requests on the project's repository suitable for merging. Each PR should implement the code associated with a given addition, and also provide documentation and examples of its use.

Related repositories

https://github.com/dspinellis/alexandria3k

Knowledge Prerequisites

Python, SQL, JSON, XML

Mentors:

Diomidis Spinellis (dds@aueb.gr)

Epoptes improvements

Brief Explanation

Epoptes is an open source computer lab management and monitoring tool. It is used in more than 1000 Greek schools, and in thousands more schools and businesses worldwide. The following improvements and new features have been requested by the community for years and can be implemented as part of a GSoC project:

- Make Epoptes available on more Linux distributions.

- Support screen sharing on Wayland.

- Drop the session service and keep only the system epoptes-client service.

- Use systemd socket activation and autorestart.

And if there's enough time left, also improve its firewall compatibility.

Duration of the Project

350 hours

Expected Results

It is expected that the student will send a pull request on https://github.com/epoptes/epoptes, suitable for merging upstream. That PR should implement all the aforementioned tasks, which are described in more detail at https://epoptes.org/documentation/gsoc/

Related repositories

https://epoptes.org/documentation/gsoc/

Knowledge Prerequisites

Python, GTK, Shell, networking, systemd services, Wayland, XDG desktop portals

Mentors:

Foteini Tsiami (fottsia@gmail.com), Siahos Yiannis (siahos@cti.gr)

OpenAPI integration in dFlow DSL

Brief Explanation

Dflow is a textual DSL for rapid Virtual Assistant (VA) development. It can automate and facilitate the otherwise time-intensive process by defining all assistant attributes in one file. In its current version, it supports dialogues that use REST requests in a dynamic manner. An extension of this, however, is to automate the definition of simple RESTful dialogues by only providing the underlying endpoint and its description. For that, a new metamodel is required that can use the OpenAPI Specification, which has standardized all REST web services, and the corresponding OpenAPI-to-dFlow Model-to-Model (M2M) transformation component. This way developers will be able to build complete dFlow models for VAs by defining REST endpoints using the OpenAPI specifications enriched with optional VA-specific parameters.

Duration of the Project

Medium Size

Expected Results

Development of the OpenAPI-to-dFlow M2M transformation, Automation of intent examples creation from OpenAPI description

Related repositories

https://github.com/robotics-4-all/dFlow

Knowledge Prerequisites

Software development, Python

Mentors:

Nikolaos Malamas nmalamas@ece.auth.gr, Konstantinos Panagiotou klpanagi@ece.auth.gr, Andreas Symeonidis symeonid@ece.auth.gr

Development of a Robotic Education Platform for the DIY robot kit for educators

Brief Explanation

The project started back on the GSoC 2019 when Christos Chronis designed and implemented a 3D printable robot for educational purposes from scratch. The idea was create a new educational robot, that will be modular, come at a low cost and be available to everyone. All of the parts of the modular robot were designed in a way so that they are easily 3D-printable. The 3D-printed parts are combined with basic low-cost electronics and sensors, which can be easily assembled to the final robot following extensive and simple guidelines of how to print and assemble the robot. In this way non-expert staff in robotics, electronics or IoT programming can assemble and use the robot. Alongside the guidelines, a number of demo scenarios for the class, e.g. simple navigation or sensing scenarios, that require basic programming skills are also provided.

The project has been continued two years later, in GSoC 2021, by Georgios Giannakoulias, who developed a version of the “DIY robot kit for educators” that integrates Node-Red blocks and introduced a new way to program the robot based on blocks. Last year at the GSOC 2022 two more contributors Danai Brilli and Eleftheria Papagergiou worked on a new version of the robot and redesigned the whole programming stack. The robot can now be programmed using native Python code or using a custom version of Google Blockly (a Scratch-like user interface). They also improved the initial core library and developed a completed unified user interface with multiple project management, robot configuration page, a new programming mode for kindergarten learning activities and a Docker based deployment system with CI/CD capabilities.

What must be done in GSOC 2023:

The current robot programming stack runs in the robot itself, allowing for the use and programming of the robot without the need for additional software installation on a local computer. However, this feature has proven to be more of an obstacle than a benefit due to connectivity and update issues. Also the rising cost of Single Board Computers (SBCs), such as the Raspberry Pi, made DIY solutions uncompetitive with commercial alternatives.

To address these issues, the entire programming stack must be transferred to the cloud. This approach would remove the need for additional computational power within the robot and provide the opportunity for a wider range of SBCs or microcontrollers such as the Raspberry Pi Pico, Microbit, ESP32, or Micropython-enabled Arduino boards to be used. This would result in a reduction in the overall cost of construction for the robot and give users more freedom to choose their own computing components. Additionally, this approach would reduce the need to perform version updates on each robot separately. Based on the feedback we got from educators, the current approach for interaction with the robot is different from that of similar market robotic kits. Thus, it is necessary to adopt an approach that utilizes existing user interaction knowledge. The proposed solution of transferring the programming stack to the cloud addresses these issues and provides a cost-effective and user-friendly solution.

Expected Results

Within the months of the project the expected results are:

• Understanding previous work
• Transfer the core library to Micropython
• Convert the whole stack to be deployable on the cloud as a platform.
• New programming modes
• Resolve bugs and provide improvements (front end - back end)
• Github automation for deployment
• Extensive documentation

Duration of the Project

350 hours

Related Repositories

https://github.com/eellak/fossbot

https://github.com/chronis10/fossbot_source

https://github.com/chronis10/fossbot_simulator

https://github.com/cyberbotics/webots

https://github.com/bbcmicrobit

https://gist.github.com/yiorgosynkl/914e75d0f9ae98bb31f4d8da66ec9908

https://gist.github.com/chronis10/9d069c56b3df9c92693ac8d24270a62a

https://github.com/isl-org/OpenBot

Mentors:

Iraklis Varlamis

Christos Chronis

Development of a Web Based robotic simulator for the DIY robot kit for educators

Google Summer of Code 2023 - Proposal

Brief Explanation

The project started back on the GSoC 2019 when Christos Chronis designed and implemented a 3D printable robot for educational purposes from scratch. The idea was create a new educational robot, that will be modular, come at a low cost and be available to everyone. All of the parts of the modular robot were designed in a way so that they are easily 3D-printable. The 3D-printed parts are combined with basic low-cost electronics and sensors, which can be easily assembled to the final robot following extensive and simple guidelines of how to print and assemble the robot. In this way non-expert staff in robotics, electronics or IoT programming can assemble and use the robot. Alongside the guidelines, a number of demo scenarios for the class, e.g. simple navigation or sensing scenarios, that require basic programming skills are also provided.

The project has been continued two years later, in GSoC 2021, by Georgios Giannakoulias, who developed a version of the “DIY robot kit for educators” that integrates Node-Red blocks and introduced a new way to program the robot based on blocks. Last year at the GSOC 2022 two more contributors Danai Brilli and Eleftheria Papagergiou worked on a new version of the robot and redesigned the whole programming stack. The robot can now be programmed using native Python code or using a custom version of Google Blockly (a Scratch-like user interface). They also improved the initial core library and developed a completed unified user interface with multiple project management, robot configuration page, a new programming mode for kindergarten learning activities and a Docker based deployment system with CI/CD capabilities.

What must be done in GSOC 2023:

A contributor Manousos Linardakis developed a simulator for the robot that gives the opportunity to everyone to use the previous programming stack without the need of a real robot. The current version is based on Coppelia Simulator and it was a great import to the whole robot interaction experience. Already the simulator has been tested by many educators and  received great comments. Based on that it is important to develop a new simulator. The new simulator must be web based and must provide a way to run different educational scenarios, like line following or obstacle avoidance. In addition the need for an integrated,  lightweight, web based simulator is very important because the existing simulator requires a high end PC and also adds extra steps to the procedure of testing and using the robot. Finally the new simulator must be capable of being integrated in the existing programming stack or in a future cloud based implementation. The proposed solution provides a cost-effective and user-friendly solution and eliminates the need of a real robot removing the cost boundaries and giving the opportunity to any educator to test and use our open source solution.

Expected Results

Within the months of the project the expected results are:

• Understanding previous work
• Add compatibility to core library for simulator support
• Develop a web based simulator
• Integration of the simulator with the platform
• Create stages for education scenarios
• Resolve bugs and provide improvements
• Github automation for deployment
• Extensive documentation

Related Repositories

https://github.com/eellak/fossbot

https://github.com/chronis10/fossbot_source

https://github.com/chronis10/fossbot_simulator

https://github.com/cyberbotics/webots

https://github.com/bbcmicrobit

https://gist.github.com/yiorgosynkl/914e75d0f9ae98bb31f4d8da66ec9908

https://gist.github.com/chronis10/9d069c56b3df9c92693ac8d24270a62a

https://github.com/isl-org/OpenBot

Mentors:

Iraklis Varlamis

Christos Chronis

Build Recorder performance improvements

Brief Explanation

Build recorder is a command-line utility to fully record the interactions between assets (files and tools) when a software component is being built (compiled).

The current implementation needs improvements to handle large-scale and parallel builds. The scope of this project is to implement such improvements.

Duration of the Project

350 hours

Related repositories

https://github.com/eellak/build-recorder

Knowledge Prerequisites

C, data structures, multi-threading

Mentors:

Alexios Zavras

Build Recorder extension for other languages

Brief Explanation

Build recorder is a command-line utility to fully record the interactions between assets (files and tools) when a software component is being built (compiled).

The current implementation only handles software being compiled using local resources, as s the case for C or C++. Other programming languages also use resources from the Internet when building a binary. The scope of this project is to extend build-recorder to record relevant information in these use cases.

Duration of the Project

350 hours

Related repositories

https://github.com/eellak/build-recorder

Knowledge Prerequisites

C and one of more other compiled languages: Go, Rust, Java, ...

Mentors:

Alexios Zavras

Development of an interactive flow visualization tool for visual / blockly programming, for educational use.

Brief Explanation

Programming with visual / blockly languages (scratch, makecode, etc) is quite common in the young ages. A more intuitive approach to this kind of programming is the creation of many threads/scenarios that communicate through messages. Yet, in many cases the resulting flow is tricky to follow, but very useful from an educational perspective. We will make a tool to reveal this flow, mainly the inter-thread communication. The input programming language will be processed as json structures, that could fold and unfold in the visualization. Communication among different threads and components will be shown explicitly. Different visualization methods will be available, that will fit to many programming languages.

Expected Results

Creation of an application to visualize code

Duration of the Project

350 hours

Related repositories

The project will make a new github repo. Related links are: https://eproceedings.epublishing.ekt.gr/index.php/cetpe/article/view/3690 https://github.com/dgmid/CodeOverview https://blog.ouseful.info/2016/02/18/blockpy-python-blockly-environment/ https://scratch.mit.edu/ https://developers.google.com/blockly/

Knowledge Prerequisites

Required: Python and other programming languages

Mentors:

Sarantos Kapidakis (sarantos.kapidakis@gmail.com)

HELP

Brief Explanation

Brief explanation=HELP is a location based mobile application (LBMA) with integrated emergency communications service, which includes an inbound and an outbound component similar to 112 or 911. You may use it with or without dialing 112 or 911 for free in any emergency anywhere (within available mobile network reception). The inbound component allows you to receive warnings or assistance of any kind and possibly allowing remote usage for the phone to light the flashlight for example or send a voice message. The outbound component will sent automatically location and other data if they are available (from any connected device like smartwatches or other health / sport devices) via multiple technologies and communication channels in case of imminent or occurring incident or dangerous situation constituting an immediate threat to your health and safety, so that you can report the incident and be reached and receive any kind of assistance. This application uses location to provide products or services based on information obtained from one or more smart devices. However, implementation and execution of these services may raise users privacy concerns related to sensitive information being handled so it has to be a FLOSS core application with possible plugins / add-ons for medical or other kind of assistance. On a later phase this application can be installed by default in any smartphone or similar device and will be available on any emergency even without SIM like 112/911.

Expected Results

A location based mobile application (LBMA) with integrated emergency communications service

Duration of the Project

175 hours

Related repositories

New project, no existing repo available.

Knowledge Prerequisites

Native iOS app and / or native Android app development skills.

Mentors:

Christos Iossifidis