Skip to main content

Notice: This Wiki is now read only and edits are no longer possible. Please see: https://gitlab.eclipse.org/eclipsefdn/helpdesk/-/wikis/Wiki-shutdown-plan for the plan.

Jump to: navigation, search

Difference between revisions of "Google Summer of Code 2023 Ideas"

(Created page with "Please see our main Google Summer of Code page for participation information. This year, projects should take ~175 hours or ~350 hours for GSoC contributors to complete....")
 
m (Adding a 2nd complementary project proposal under Eclipse Adoptium)
 
(15 intermediate revisions by the same user not shown)
Line 30: Line 30:
 
'''Rating''' Easy, medium or hard rating of each project.
 
'''Rating''' Easy, medium or hard rating of each project.
  
=== Eclipse Ditto™ – Cloud Events mappings ===
+
=== Eclipse Hara (DDI Client for Eclipse hawbkBit™) ===  
 +
==== Topic 1: Improve Automatic Testing ====
 +
'''Description:''' Hara-ddiclient (https://github.com/eclipse/hara-ddiclient/) is a Kotlin library that facilitates and speeds up the development of DDI API clients for devices connecting to hawkBit servers. This project aims to modernize and extend the existing test suite to improve the release process. Currently, the test cases implemented are limited and the test env uses a hawkbit-server launched via docker, which must be replaced with a mock.
  
'''Description''' [https://www.eclipse.org/ditto/ Eclipse Ditto] is a digital twin project and can consume events for device updates from several messaging solutions (MQTT, Kafka). As Ditto needs to understand the payload, it provides a data model, which defines how data is represented inside Ditto. However, it needs to interface with existing systems, which do not follow the Ditto data model or encoding of that. Kafka (or MQTT) on the other hand can transport any kind of payload.
+
'''Expected outcomes:''' a mock implementation of the hawkbit-server easily configurable at run time, and new test cases which cover the prominent use cases of the hara-ddiclient.
  
[https://cloudevents.io/ Cloud Events] are a definition of some common properties of events, like payload and header, which maps to multiple event drive technologies (like Kafka, MQTT, HTTP/WS, AMQP, …). So a "cloud event" can be represented in all of those technologies, still allowing to transport any kind of payload.
+
'''Skills required/preferred:''' Programming skills required, preferably one or more of the following technologies: Kotlin/Java, TestNG/JUnit
  
This proposal is to bring Cloud Events to Ditto. There currently already exists a Cloud Events HTTP endpoint, which can passively accept Cloud Events. However, Ditto supports "[https://www.eclipse.org/ditto/basic-connections.html connections]", which are more active and implemented in a different way. These connections (might be Kafka, MQTT, …) either require the payload to be in the Ditto format, or allowing hooking in [https://www.eclipse.org/ditto/connectivity-mapping.html default/custom payload/event mapping logic] to translate events into the Ditto format. Same for outbound messages, these can be mapped from Ditto into something that is understood be an external system.
+
'''Project size:''' 175 or 350 hours (scope can be adjusted, e.g., by including test cases)
  
So what is required to complete this project:
+
'''Possible mentors:''' [mailto:daniele.sergio@kynetics.com Daniele Sergio]
  
* Create an out-of-the-box inbound and outbound mapper, which translates Ditto events into Cloud Events (and back)
+
'''Rating:''' Medium
* Provide a way to use e.g. the "Normalize" step as part of that mapping
+
  
This includes:
+
==== Topic 2: Native implementation in Rust ====
 +
'''Description:''' Hara-ddiclient is a Kotlin library that facilitates and speeds up the development of DDI API clients for devices connecting to hawkBit servers. This project will implement a native ddi-client in Rust following the Hara-ddiclient architecture. This project's benefit is providing a DDI client implementation applicable in those crucial contexts where a native approach is required. The native implementation of the DDI client can then be used by different frameworks (i.e Qt) and tools to include their integration with the hawkBit update server. 
  
* Defining a mapping specification
+
'''Expected outcomes:''' a first version of the hara-ddiclient written in rust which covers one of the primary use cases of ddi-client which is to download and apply an update.
* Creating an implementation
+
* Creating unit-tests
+
* Updating the documentation
+
  
'''Expected outcomes''' an event mapper for Ditto Events to/from Cloud Events including a mapping specification, an implementation, unit tests, and documentation.
+
'''Skills required''': Students should understand Kotlin, Rust, and possibly Actor model (https://en.wikipedia.org/wiki/Actor_model).
  
'''Skills required/preferred''' Java, Cloud Events, Maven
+
'''Project size:''' 350 hours
  
'''Project size''' 175 hours
+
'''Possible mentors:''' [mailto:daniele.sergio@kynetics.com Daniele Sergio]
 +
[mailto:diego.rondini@kynetics.com Diego Rondini]
  
'''Possible mentors:''' [mailto:jreimann@redhat.com Jens Reimann]
+
''Rating:'' Hard
  
'''Rating''' Easy
 
  
=== Eclipse JKube™: Improve JKube user experience ===
+
=== Eclipse 4diac™ (Domain-specific modelling environment) ===
'''Description'''
+
==== Topic 1: Testing software developed in a graphical DSL ====
Eclipse JKube™ is a collection of plugins and libraries that are used for building container images using Docker, JIB or S2I build strategies.
+
'''Description''' The Eclipse 4diac project provides an open source infrastructure for distributed Industrial Process Measurement and Control Systems (IPMCS) based on the IEC 61499 standard. This project will add infrastructure for domain experts to test software components (so-called Function Blocks) based on behavior models. Currently, the tool environment has limited tool support for (semi-)automated testing of Function Blocks. A framework for the test execution and a basic user interface are available, partly developed by earlier GSoC projects.
Eclipse JKube generates and deploys Kubernetes/OpenShift manifests at compile time too.
+
  
This project focuses on providing compile-time plugins and libraries for the Java ecosystem for:
+
'''Expected outcomes:''' A user interface for generating tests for FB Networks and executing them must be available (including documentation). It should be furthermore possible to record such scenarios, which can be later used as test cases.
* Building container images
+
* Creating Kubernetes and OpenShift resource descriptors
+
* Deploying resources descriptors
+
  
The goal of this proposal is to improve the user experience of JKube for a better adoption. Basically to work on the issues with the label ‘UX’ https://github.com/eclipse/jkube/labels/UX . Students could also propose issues that would help JKube to be well/better adopted.
+
'''Skills required/preferred:''' Programming skills required, preferably one or more of the following technologies: Java, SWT, Eclipse, RCP
  
'''Expected outcomes''' are of course contributions in terms of code. But it could also involve the website or the documentation or videos.
+
'''Project size:''' 175 or 350 hours (scope can be adjusted, e.g., by including a graphical user interface)
  
'''Skills required/preferred.'''
+
'''Possible mentors:''' [mailto:bianca.wiesmayr@jku.at Bianca Wiesmayr]
* Basic knowledge of Kubernetes
+
* Good knowledge of Java
+
  
'''Project size''' 350
+
'''Rating:''' Medium
  
'''Possible mentors:''' [mailto:sutan@redhat.com Sun Tan (CET/CEST)], [mailto:marc.nuri@redhat.com Marc Nuri (CET/CEST)]
+
==== Topic 2: Refactoring graphical software automatically ====
 +
'''Description''' The Eclipse 4diac project provides an open source infrastructure for distributed Industrial Process Measurement and Control Systems (IPMCS) based on the IEC 61499 standard. This project will add automatic refactoring operations to improve the software developed in the graphical modeling language.
  
'''Rating''' medium
+
'''Expected outcomes:''' A concept for fixing problems in the software has to be developed and implemented. The results should be presented to the user.
  
 +
'''Skills required/preferred:''' Programming skills required, preferably one or more of the following technologies: Java, Eclipse, RCP
  
=== Eclipse JKube™: Migrate To Mockito for mocking tests ===
+
'''Project size:''' 175 or 350 hours (scope can be adjusted, e.g., by including a graphical user interface)
'''Description'''
+
Eclipse JKube™ is a collection of plugins and libraries that are used for building container images using Docker, JIB or S2I build strategies.
+
Eclipse JKube generates and deploys Kubernetes/OpenShift manifests at compile time too.
+
  
This project focuses on providing compile-time plugins and libraries for the Java ecosystem for:
+
'''Possible mentors:''' [mailto:bianca.wiesmayr@jku.at Bianca Wiesmayr]
* Building container images
+
* Creating Kubernetes and OpenShift resource descriptors
+
* Deploying resources descriptors
+
  
The goal of this proposal is to migrate our current test mocking framework to Mockito instead of JMockit https://github.com/eclipse/jkube/issues/857
+
'''Rating:''' Medium
  
Currently all unit tests in Eclipse JKube repository are using [https://jmockit.github.io/ JMockit] for mocking objects. JMockit is good but [https://site.mockito.org/ Mockito] provided a cleaner and simpler API to allow developers to mock objects. It also seems to be more popular and up to date framework.
+
=== Eclipse Vert.x client for Apache Pinot ===
 +
'''Description''' [https://vertx.io Vert.x] is a toolkit to build reactive applications on the Java virtual machine. It provides asynchronous and non-blocking clients for different types of databases. [https://pinot.apache.org/ Apache Pinot] is a realtime distributed datastore for analytics workloads. The project consists in creating a Vert.x client for Pinot, based on the [https://docs.pinot.apache.org/users/clients/java Apache Pinot Java Client].
  
While building gradle plugins, the Eclipse JKube team started writing tests using Mockito. Other modules, namely all submodules of [https://github.com/eclipse/jkube/tree/master/jkube-kit jkube-kit], [https://github.com/eclipse/jkube/tree/master/kubernetes-maven-plugin kubernetes-maven-plugin] and [https://github.com/eclipse/jkube/tree/master/openshift-maven-plugin openshift-maven-plugin] tests, need to be migrated to use Mockito instead of JMockit.
+
'''Expected outcomes'''
 +
At the end of the project, we should be able to execute Pinot queries using Vert.x supported APIs ('''Future''', RxJava, or SmallRye Mutiny).
 +
The client transport shall be implemented with the [https://vertx.io/docs/vertx-web-client/java/ Vert.x Web Client].
 +
It is expected that the student creates a sample application and a blog post to present it.
  
'''Expected outcomes''' are of course contributions in terms of code.
+
'''Skills required/preferred''' Students should have a good understanding of the Java programming language and be able to learn and experiment with the [https://docs.pinot.apache.org/users/clients/java Apache Pinot Java Client].
  
'''Skills required/preferred.''' Basic knowledge of Java is required.
+
'''Project size''' 175/350 hours (scope can be adjusted to reflect the desired length)
  
'''Project size''' 350
+
'''Possible mentors:''' [mailto:tsegismont@gmail.com Thomas Segismont]
 
+
'''Possible mentors:''' [mailto:marc.nuri@redhat.com Marc Nuri (CET/CEST)], [mailto:rokumar@redhat.com Rohan Kumar (IST)]
+
  
'''Rating''' easy
+
'''Rating''' Medium/Hard
  
=== Eclipse JKube™: Migrate To JUnit5 Testing Framework from JUnit4 ===
+
=== Eclipse JKube™ ===
 +
==== Topic 1: Improve JKube user experience ====
 
'''Description'''
 
'''Description'''
 
Eclipse JKube™ is a collection of plugins and libraries that are used for building container images using Docker, JIB or S2I build strategies.
 
Eclipse JKube™ is a collection of plugins and libraries that are used for building container images using Docker, JIB or S2I build strategies.
Line 121: Line 113:
 
* Deploying resources descriptors
 
* Deploying resources descriptors
  
The goal of this proposal is to migrate our current testing framework to [https://junit.org/junit5/ JUnit 5] . It is currently using [https://junit.org/junit4/ JUnit 4] . It would be nice to upgrade to JUnit5 in order to use new features like precise exception handling, display names, annotations etc.
+
The goal of this proposal is to improve the user experience of JKube for a better adoption. Basically to work on the issues with the label ‘UX’ https://github.com/eclipse/jkube/labels/UX . Students could also propose issues that would help JKube to be well/better adopted.
  
For better understanding, more detailed information can be found in the JUnit5 [https://junit.org/junit5/docs/current/user-guide/#migrating-from-junit4 Migrating from JUnit4 Guide]. This needs to be done for every unit test of the Eclipse JKube repository.
+
'''Expected outcomes''' are of course contributions in terms of code. But it could also involve the website or the documentation or videos.
  
'''Expected outcomes''' are of course contributions in terms of code.
+
'''Skills required/preferred.'''
 
+
* Basic knowledge of Kubernetes
'''Skills required/preferred.''' Basic knowledge of Java is required.
+
* Good knowledge of Java
  
 
'''Project size''' 350
 
'''Project size''' 350
  
'''Possible mentors:''' [mailto:marc.nuri@redhat.com Marc Nuri (CET/CEST)], [mailto:rokumar@redhat.com Rohan Kumar (IST)]
+
'''Possible mentors:''' [mailto:sutan@redhat.com Sun Tan (CET/CEST)]
  
'''Rating''' easy
+
'''Rating''' medium
  
=== Eclipse Kuksa™: Device Twin for Vehicle Signal Specification (VSS) automotive data ===
+
=== Eclipse Epsilon Kernel for Jupyter Notebooks ===
'''Description:''' Eclipse Kuksa provides building blocks for connected-car ecosystems responding to increasing demand for software and data-driven services in and around cars. As part of the Eclipse Kuksa project, Kuksa.val delivers an implementation of the W3C VSS [1] specification, which defines the structure and the access to signals and data in a vehicle.
+
  
Many applications hosted in a cloud backend face similar challenges of how to retrieve and transport vehicle data to the cloud. IoT scenarios often solve these challenges through an instance of a device twin acting as a digital representation of the actual thing. One implementation for such device twins is Eclipse Ditto.  
+
'''Description'''
Having unified device twins for vehicles allows faster development of portable applications and improves the overall developer experience for working with VSS.
+
[https://www.eclipse.org/epsilon/ Eclipse Epsilon] is a family of Java-based scripting languages for automating common model-based software engineering tasks, such as code generation, model-to-model transformation and model validation. This project would consist in the implementation of a kernel to allow executing these languages in a [https://jupyter.org/ Jupyter] Notebook. Eclipse Epsilon already provides several features that might help during this project: (1) Epsilon programs can be executed from Java code or vía Ant, Maven or Gradle; (2) textual syntaxes for models and metamodels (Flexmi and Eclipse Emfatic respectively) that fit well in the cell-based workflow of Jupyter Notebooks; (3) a [https://www.eclipse.org/epsilon/playground/ browser-based playground] for fiddling with Epsilon’s languages; and (4) examples of how to work with Epsilon in different [https://www.eclipse.org/epsilon/doc/articles/#development-environments development environments].
  
[1] https://covesa.github.io/vehicle_signal_specification/
+
'''Expected outcomes'''
 +
A baseline could be implementing a Jupyter kernel that allows executing [https://www.eclipse.org/epsilon/doc/eol/ EOL (Epsilon Object Language)] snippets contained in notebook cells. The kernel should be able to maintain the state of the environment, which will be updated with each notebook cell execution. From there, other model-based tasks could be added incrementally, such as editing models and metamodels, supporting other Eclipse Epsilon languages, and visualising models, among others.
  
'''Expected outcomes:''' Expected outcomes: At the end of the project, we envision to add deployment scripts, a service implementation, and a running example available, for the realization of a digital twin based on the VSS implementation of Eclipse Kuksa. Preferably
+
'''Skills required/preferred'''
- Kuksa.cloud has new services in its deployment scripts, which provides a device twin which could for example be on an instance of Eclipse Ditto
+
Object-Oriented Programming skills required, preferably Java. Knowledge in how to use Jupyter Notebooks is preferred but not required.
- Kuksa.val has a new adapter that allows to send data from Kuksa.val to a device twin instance in the cloud
+
  
'''Skills required/preferred:''' Students should be able to program in the Java programming language, have a good understanding of cloud architectures and service deployments based on Kubernetes and Helm. Understanding Python code helps to understand the VSS implementation.
+
'''Project size'''
 +
175/350 hours (scope can be adjusted e.g. by determining which of the Epsilon languages/tools is supported)
  
'''Project size:''' 350 hours
+
'''Possible mentors:'''
 +
[mailto:alfonso.delavega@unican.es Alfonso de la Vega], [mailto:dimitris.kolovos@york.ac.uk Dimitris Kolovos]
  
'''Possible mentors:''' [mailto:johannes.kristan@bosch.io Johannes Kristan], Sebastian Schildt, Sven Erik Jeroschewski
+
'''Rating'''
 +
Medium/Hard
  
'''Rating:''' Medium
+
=== Eclipse Adoptium ===
 +
==== Topic 1: Optimize Eclipse Adoptium Pipelines (Techniques for Reducing Test Node Usage) ====
 +
'''Description''' [https://adoptium.net/ adoptium.net]
 +
Eclipse Adoptium has a large inventory of infrastructure to support builds and tests.  We gather metrics on machine utilization and store that in an application written as part of the Eclipse AQAvit project (TRSS/Test Results Summary Service, a live instance found here: https://trss.adoptium.net/, source code within: https://github.com/adoptium/aqa-test-tools).  We want to extend the information that we gather and put in the TRSS database (to include queue times and machine idleness), and assess various approaches to optimize our use of the limited nodes we have, including the use of dynamic agents, trialing different parallelism strategies, and different scheduling tactics to minimize idle times).  This project will have aspects of data gathering, analysis and hands-on pipeline changes to trial and measure new variations of node usage. 
  
=== Eclipse SWTChart™ (Radar/Spider Chart Support) ===
+
'''Expected outcomes'''
'''Description''' Eclipse SWTChart provides the means to create rich, flexible and interactive data visualizations natively in SWT. This project will add support to easily create radar and spider charts in SWTChart. Other chart types like Pie-, Doughnut-, Line-, Scatter- or Barplots are supported out-of-the-box already.
+
We expect that this project will provide us with metrics to be able to refine our build and test pipelines to more optimally use our limited machine resources.  An assessment of current CI/CD best practices and comparative analysis with several variations should be one of the concrete outcomes of this work. Outcomes from this project will also be valuable for sharing with other projects. Another outcome will be a dynamic map of our infrastructure network, or other visualizations of the data (represented in the TRSS application).  Ideally the findings will allow us to reduce our infrastructure costs and maintenance requirements.
  
'''Expected outcomes:''' A specific type for radar and spider charts as well as an example section how to use them must be available after finishing the project successfully.
+
'''Skills required/preferred''' Successful candidates should have a good understanding of the Java, JavaScript and shell script programming and be prepared to gather and analyze large amounts of data and present regularly on findings.  Skills in data visualization are also helpful.
  
'''Skills required/preferred:''' Java, SWT, Eclipse, RCP, OSGi
+
'''Project size''' 175/350 hours (scope can be adjusted to reflect the desired length)
 +
350 hours
  
'''Project size:''' 350 hours
+
'''Possible mentors:''' [mailto:slambert@gmail.com Shelley Lambert] [mailto:scfryer@redhat.com Scott Fryer]
  
'''Possible mentors:''' [mailto:philip.wenig@openchrom.net Philip Wenig]
+
'''Rating''' Medium
  
'''Rating:''' Medium
+
==== Topic 2: Eclipse AQAvit Assessment and Prioritization ====
 
+
'''Description'''
=== Eclipse SWTChart™ (Export Options) ===
+
The Eclipse AQAvit project curates and runs an extremely large set of tests. The AQAvit manifesto includes a clause to introduce and use metrics to ensure the test material is assessed regularly for its effectiveness. This project is geared to developing a repeatable approach to measure the effectiveness of our large set of tests to be used regularly to assess and adjust our testing to be most useful and relevant. Details at this [https://github.com/adoptium/aqa-tests/wiki/GSoC-2023-Term:-AQAvit-Assessment-and-Prioritization aqa-tests wiki page].
'''Description''' Eclipse SWTChart provides the means to create rich, flexible and interactive data visualizations natively in SWT. This project will improve the existing export options in SWTChart, especially the SVG template export.
+
 
+
'''Expected outcomes:''' More export types shall be supported like Pie- and Doughnutplots. Additional options shall be added to export labels.
+
 
+
'''Skills required/preferred:''' Java, SWT, Eclipse, RCP, OSGi
+
 
+
'''Project size:''' 350 hours
+
 
+
'''Possible mentors:''' [mailto:philip.wenig@openchrom.net Philip Wenig]
+
 
+
'''Rating:''' Easy
+
 
+
=== Eclipse 4diac™ (Domain-specific modelling environment) ===
+
'''Description''' The Eclipse 4diac project provides an open source infrastructure for distributed Industrial Process Measurement and Control Systems (IPMCS) based on the IEC 61499 standard. This project will add user interface for testing software components (so-called Function Blocks) based on behavior models. Currently, the tool environment has limited tool support for (semi-)automated testing of Function Blocks. A framework for the test execution is however available.
+
 
+
'''Expected outcomes:''' A user interface for generating tests based on behavior models and executing them must be available (including documentation). It should be furthermore possible to record new scenarios, which can be later used as test cases.
+
 
+
'''Skills required/preferred:''' Programming skills required, preferably one or more of the following technologies: Java, SWT, Eclipse, RCP
+
 
+
'''Project size:''' 175 or 350 hours (scope can be adjusted)
+
 
+
'''Possible mentors:''' [mailto:alois.zoitl@jku.at Alois Zoitl] [mailto:bianca.wiesmayr@jku.at Bianca Wiesmayr]
+
 
+
'''Rating:''' Medium
+
 
+
=== Eclipse Vert.x™: JSONRPC as wire protocol for the eventbus TCP bridge ===
+
'''Description:''' Eclipse Vert.x offers a message-driven programming model based on an event bus that allows applications to scale to multiple processes or nodes without requiring code changes or knowledge during development. The event bus can be extended to non-native vert.x applications, including other platforms such as nodejs, python, etc... At the moment, the wire format of the messages in this event bus bridge is vert.x specific. To make the bridge more accessible to everyone, a more popular format should be added. We would like to see JSON-RPC as a wire format, as the current format is JSON based. This would keep the project scope small and not require many changes for clients to adapt.
+
 
+
'''Expected outcomes:''' At the end of the project we should have simple communication with the existing bridge using a client of choice of the student using JSON-RPC showcasing the communication modes:
+
 
+
* send and forget
+
* request-response
+
* push
+
 
+
 
+
'''Skills required/preferred:''' Students should be fluent in Java programming language and have some basic knowledge on another language of choice to test the client.
+
 
+
Having some experience with asynchronous programming is highly recommended, to understand the vert.x code base.
+
 
+
'''Project size:''' 350 hours
+
 
+
'''Possible mentor:''' [mailto:pmlopes@gmail.com Paulo Lopes]
+
 
+
'''Rating:''' Medium/Hard.
+
 
+
=== Eclipse Vert.x™: Implement Security audit logging for Vert.x Web ===
+
'''Description:''' Eclipse Vert.x Web is a small library to build modern web applications with vert.x. Although vert.x web already supports many security handlers, there is no easy way to create an audit authentication logging trail. This project is to create a simple logging audit trail handler, that captures all the authentication related events and logs then to a specific logger.
+
  
'''Expected outcomes:''' At the end of the project, a handler, tests and documentation should be delivered. One of the goals is to keep the handler agnostic to the backend logger, so the documentation should include examples on how to use common logging frameworks, either local or remote. Remote examples are required to showcase non repudiation.
+
'''Expected outcomes'''  
 +
We hope that this project will have the following outcomes:
 +
- A survey of the best in class open source tools/approaches that measure test effectiveness
 +
- A set of KPIs used to assess the test material on a regular cadence
 +
- Tools that assist in the running of this assessment
 +
- If time permits, automated report generation.  
  
'''Skills required/preferred''': Students should have a good understanding of Java programming language and be able to learn or experiment with logging frameworks like logback or log4j.
+
'''Skills required/preferred''' Successful candidates should have a good understanding of the Java, JavaScript and shell script programming.
  
'''Project size:''' 175/350 hours The scope can be adjusted to reflect the desired length.
+
'''Project size''' 175/350 hours (scope can be adjusted to reflect the desired length)
 +
350 hours
  
'''Possible mentor:''' [mailto:pmlopes@gmail.com Paulo Lopes]
+
'''Possible mentors:''' [mailto:lan_xia@ca.ibm.com Lan Xia] [mailto:renfeiw@ca.ibm.com Renfei Wang] [mailto:slambert@gmail.com Shelley Lambert]  
  
'''Rating:''' Easy/Medium.
+
'''Rating''' Medium
  
=== Eclipse Sirius Web: Contribute Card Board representation ===
+
=== Eclipse Cargo Tracker: Improvements and Updates ===
'''Description:''' Eclipse Sirius Web is a framework to build modern modeling studios to the web. Sirius Web provides today two different kind of representations: diagrams and forms. This project is to contribute a new "Card Board representation" like Trello/Focalboard/Github Projects.
+
'''Description''' The Eclipse Cargo Tracker project demonstrates how you can develop applications with Jakarta EE using widely adopted architectural best practices like Domain-Driven Design (DDD). It is a realistic, non-trivial Jakarta EE sample application. The project is a key part of the EE4J/Jakarta EE umbrella at the Eclipse Foundation.
 +
The project is mature but needs a number of important enhancements ranging from improving look/feel, upgrading to Jakarta EE 10/Payara 6/Java SE 11, adding more JUnit tests, adding JMeter tests, adding support for more IDEs such as VS Code/IntelliJ and supporting more runtimes such as GlassFish/Open Liberty/WildFly.
 +
Here is a complete list of issues where contribution is needed: https://github.com/eclipse-ee4j/cargotracker/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22. The Eclipse Cargo Tracker website is here: https://eclipse-ee4j.github.io/cargotracker/.
  
'''Expected outcomes:''' At the end of the project, it will be possible for the studio maker to define directly from the web a new Card Board description and for the studio user to get a card+column representation with support of add/delete column and cards, reorder column, reorder cards, D&D cards between columns, edit card details in a properties view.
+
'''Expected outcomes''' The contributor(s) will successfully merge the enhancement(s) they elect to work on into the main branch of the project and close the corresponding issues. Their work will be included in a subsequent Eclipse Cargo Tracker release. They will be recognized as a project contributor and possibly a qualified committer.  
  
'''Skills required/preferred''': Java, Spring Boot, React, JS.
+
'''Skills required/preferred''' Java, Jakarta EE, JUnit, JMeter, HTML, CSS, JavaScript
  
'''Project size:''' 175/350 hours The scope can be adjusted to reflect the desired length.
+
'''Project size''' 175/350 hours
  
'''Possible mentor:''' [mailto:melanie.bats@obeo.fr Mélanie Bats] [mailto:pierre-charles.david@obeo.fr Pierre Charles David]
+
'''Possible mentors:''' Reza Rahman (Reza.Rahman@microsoft.com)
  
'''Rating:''' Medium.
+
'''Rating''' There are easy, medium and hard tasks in the project.

Latest revision as of 20:11, 1 March 2023

Please see our main Google Summer of Code page for participation information.

This year, projects should take ~175 hours or ~350 hours for GSoC contributors to complete.

Each project on the Ideas list should include:

  • a project title/description
  • more detailed description of the project (2-5 sentences)
  • expected outcomes
  • skills required/preferred
  • possible mentors
  • expected size of project (175 or 350 hour).
  • And if possible, an easy, medium or hard rating of each project.


Project ideas

Warning2.png
Project team member and potential mentors, add your content here. The format suggested below is just an idea. Play with the layout, but please don't mess with content provided by other projects. Please be sure to follow branding guidelines (e.g. "Eclipse Dash", not "Dash"). Putting things in alphabetical order seems like a fair thing to do. Links to content hosted elsewhere are fine, but bear in mind that this page will likely be the main point of contact for people who are not already inside your community.

Example Project idea

Description of the Example Project idea with links to more information, bugs, and other useful content. This could include a list of specific objectives

Expected outcomes list of the results expected to be achieved after completing of the project.

Skills required/preferred list of skill set required to be able to complete the project in the proposed time.

Project size 175/350 hours

Possible mentors: Somebody Mentor

Rating Easy, medium or hard rating of each project.

Eclipse Hara (DDI Client for Eclipse hawbkBit™)

Topic 1: Improve Automatic Testing

Description: Hara-ddiclient (https://github.com/eclipse/hara-ddiclient/) is a Kotlin library that facilitates and speeds up the development of DDI API clients for devices connecting to hawkBit servers. This project aims to modernize and extend the existing test suite to improve the release process. Currently, the test cases implemented are limited and the test env uses a hawkbit-server launched via docker, which must be replaced with a mock.

Expected outcomes: a mock implementation of the hawkbit-server easily configurable at run time, and new test cases which cover the prominent use cases of the hara-ddiclient.

Skills required/preferred: Programming skills required, preferably one or more of the following technologies: Kotlin/Java, TestNG/JUnit

Project size: 175 or 350 hours (scope can be adjusted, e.g., by including test cases)

Possible mentors: Daniele Sergio

Rating: Medium

Topic 2: Native implementation in Rust

Description: Hara-ddiclient is a Kotlin library that facilitates and speeds up the development of DDI API clients for devices connecting to hawkBit servers. This project will implement a native ddi-client in Rust following the Hara-ddiclient architecture. This project's benefit is providing a DDI client implementation applicable in those crucial contexts where a native approach is required. The native implementation of the DDI client can then be used by different frameworks (i.e Qt) and tools to include their integration with the hawkBit update server.

Expected outcomes: a first version of the hara-ddiclient written in rust which covers one of the primary use cases of ddi-client which is to download and apply an update.

Skills required: Students should understand Kotlin, Rust, and possibly Actor model (https://en.wikipedia.org/wiki/Actor_model).

Project size: 350 hours

Possible mentors: Daniele Sergio Diego Rondini

Rating: Hard


Eclipse 4diac™ (Domain-specific modelling environment)

Topic 1: Testing software developed in a graphical DSL

Description The Eclipse 4diac project provides an open source infrastructure for distributed Industrial Process Measurement and Control Systems (IPMCS) based on the IEC 61499 standard. This project will add infrastructure for domain experts to test software components (so-called Function Blocks) based on behavior models. Currently, the tool environment has limited tool support for (semi-)automated testing of Function Blocks. A framework for the test execution and a basic user interface are available, partly developed by earlier GSoC projects.

Expected outcomes: A user interface for generating tests for FB Networks and executing them must be available (including documentation). It should be furthermore possible to record such scenarios, which can be later used as test cases.

Skills required/preferred: Programming skills required, preferably one or more of the following technologies: Java, SWT, Eclipse, RCP

Project size: 175 or 350 hours (scope can be adjusted, e.g., by including a graphical user interface)

Possible mentors: Bianca Wiesmayr

Rating: Medium

Topic 2: Refactoring graphical software automatically

Description The Eclipse 4diac project provides an open source infrastructure for distributed Industrial Process Measurement and Control Systems (IPMCS) based on the IEC 61499 standard. This project will add automatic refactoring operations to improve the software developed in the graphical modeling language.

Expected outcomes: A concept for fixing problems in the software has to be developed and implemented. The results should be presented to the user.

Skills required/preferred: Programming skills required, preferably one or more of the following technologies: Java, Eclipse, RCP

Project size: 175 or 350 hours (scope can be adjusted, e.g., by including a graphical user interface)

Possible mentors: Bianca Wiesmayr

Rating: Medium

Eclipse Vert.x client for Apache Pinot

Description Vert.x is a toolkit to build reactive applications on the Java virtual machine. It provides asynchronous and non-blocking clients for different types of databases. Apache Pinot is a realtime distributed datastore for analytics workloads. The project consists in creating a Vert.x client for Pinot, based on the Apache Pinot Java Client.

Expected outcomes At the end of the project, we should be able to execute Pinot queries using Vert.x supported APIs (Future, RxJava, or SmallRye Mutiny). The client transport shall be implemented with the Vert.x Web Client. It is expected that the student creates a sample application and a blog post to present it.

Skills required/preferred Students should have a good understanding of the Java programming language and be able to learn and experiment with the Apache Pinot Java Client.

Project size 175/350 hours (scope can be adjusted to reflect the desired length)

Possible mentors: Thomas Segismont

Rating Medium/Hard

Eclipse JKube™

Topic 1: Improve JKube user experience

Description Eclipse JKube™ is a collection of plugins and libraries that are used for building container images using Docker, JIB or S2I build strategies. Eclipse JKube generates and deploys Kubernetes/OpenShift manifests at compile time too.

This project focuses on providing compile-time plugins and libraries for the Java ecosystem for:

  • Building container images
  • Creating Kubernetes and OpenShift resource descriptors
  • Deploying resources descriptors

The goal of this proposal is to improve the user experience of JKube for a better adoption. Basically to work on the issues with the label ‘UX’ https://github.com/eclipse/jkube/labels/UX . Students could also propose issues that would help JKube to be well/better adopted.

Expected outcomes are of course contributions in terms of code. But it could also involve the website or the documentation or videos.

Skills required/preferred.

  • Basic knowledge of Kubernetes
  • Good knowledge of Java

Project size 350

Possible mentors: Sun Tan (CET/CEST)

Rating medium

Eclipse Epsilon Kernel for Jupyter Notebooks

Description Eclipse Epsilon is a family of Java-based scripting languages for automating common model-based software engineering tasks, such as code generation, model-to-model transformation and model validation. This project would consist in the implementation of a kernel to allow executing these languages in a Jupyter Notebook. Eclipse Epsilon already provides several features that might help during this project: (1) Epsilon programs can be executed from Java code or vía Ant, Maven or Gradle; (2) textual syntaxes for models and metamodels (Flexmi and Eclipse Emfatic respectively) that fit well in the cell-based workflow of Jupyter Notebooks; (3) a browser-based playground for fiddling with Epsilon’s languages; and (4) examples of how to work with Epsilon in different development environments.

Expected outcomes A baseline could be implementing a Jupyter kernel that allows executing EOL (Epsilon Object Language) snippets contained in notebook cells. The kernel should be able to maintain the state of the environment, which will be updated with each notebook cell execution. From there, other model-based tasks could be added incrementally, such as editing models and metamodels, supporting other Eclipse Epsilon languages, and visualising models, among others.

Skills required/preferred Object-Oriented Programming skills required, preferably Java. Knowledge in how to use Jupyter Notebooks is preferred but not required.

Project size 175/350 hours (scope can be adjusted e.g. by determining which of the Epsilon languages/tools is supported)

Possible mentors: Alfonso de la Vega, Dimitris Kolovos

Rating Medium/Hard

Eclipse Adoptium

Topic 1: Optimize Eclipse Adoptium Pipelines (Techniques for Reducing Test Node Usage)

Description adoptium.net Eclipse Adoptium has a large inventory of infrastructure to support builds and tests. We gather metrics on machine utilization and store that in an application written as part of the Eclipse AQAvit project (TRSS/Test Results Summary Service, a live instance found here: https://trss.adoptium.net/, source code within: https://github.com/adoptium/aqa-test-tools). We want to extend the information that we gather and put in the TRSS database (to include queue times and machine idleness), and assess various approaches to optimize our use of the limited nodes we have, including the use of dynamic agents, trialing different parallelism strategies, and different scheduling tactics to minimize idle times). This project will have aspects of data gathering, analysis and hands-on pipeline changes to trial and measure new variations of node usage.

Expected outcomes We expect that this project will provide us with metrics to be able to refine our build and test pipelines to more optimally use our limited machine resources. An assessment of current CI/CD best practices and comparative analysis with several variations should be one of the concrete outcomes of this work. Outcomes from this project will also be valuable for sharing with other projects. Another outcome will be a dynamic map of our infrastructure network, or other visualizations of the data (represented in the TRSS application). Ideally the findings will allow us to reduce our infrastructure costs and maintenance requirements.

Skills required/preferred Successful candidates should have a good understanding of the Java, JavaScript and shell script programming and be prepared to gather and analyze large amounts of data and present regularly on findings. Skills in data visualization are also helpful.

Project size 175/350 hours (scope can be adjusted to reflect the desired length) 350 hours

Possible mentors: Shelley Lambert Scott Fryer

Rating Medium

Topic 2: Eclipse AQAvit Assessment and Prioritization

Description The Eclipse AQAvit project curates and runs an extremely large set of tests. The AQAvit manifesto includes a clause to introduce and use metrics to ensure the test material is assessed regularly for its effectiveness. This project is geared to developing a repeatable approach to measure the effectiveness of our large set of tests to be used regularly to assess and adjust our testing to be most useful and relevant. Details at this aqa-tests wiki page.

Expected outcomes We hope that this project will have the following outcomes: - A survey of the best in class open source tools/approaches that measure test effectiveness - A set of KPIs used to assess the test material on a regular cadence - Tools that assist in the running of this assessment - If time permits, automated report generation.

Skills required/preferred Successful candidates should have a good understanding of the Java, JavaScript and shell script programming.

Project size 175/350 hours (scope can be adjusted to reflect the desired length) 350 hours

Possible mentors: Lan Xia Renfei Wang Shelley Lambert

Rating Medium

Eclipse Cargo Tracker: Improvements and Updates

Description The Eclipse Cargo Tracker project demonstrates how you can develop applications with Jakarta EE using widely adopted architectural best practices like Domain-Driven Design (DDD). It is a realistic, non-trivial Jakarta EE sample application. The project is a key part of the EE4J/Jakarta EE umbrella at the Eclipse Foundation. The project is mature but needs a number of important enhancements ranging from improving look/feel, upgrading to Jakarta EE 10/Payara 6/Java SE 11, adding more JUnit tests, adding JMeter tests, adding support for more IDEs such as VS Code/IntelliJ and supporting more runtimes such as GlassFish/Open Liberty/WildFly. Here is a complete list of issues where contribution is needed: https://github.com/eclipse-ee4j/cargotracker/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22. The Eclipse Cargo Tracker website is here: https://eclipse-ee4j.github.io/cargotracker/.

Expected outcomes The contributor(s) will successfully merge the enhancement(s) they elect to work on into the main branch of the project and close the corresponding issues. Their work will be included in a subsequent Eclipse Cargo Tracker release. They will be recognized as a project contributor and possibly a qualified committer.

Skills required/preferred Java, Jakarta EE, JUnit, JMeter, HTML, CSS, JavaScript

Project size 175/350 hours

Possible mentors: Reza Rahman (Reza.Rahman@microsoft.com)

Rating There are easy, medium and hard tasks in the project.

Back to the top