The JBoss Community is planning to participate in Google Summer of Code in 2019.
All students & developers are welcome to participate in the Google Summer of Code 2019 program with the JBoss Community (once JBoss Community is accepted by Google)!
You can take look on org page of Summer of Code website for proceeding with the application process.
If you are a student looking forward to participate in the GSoC 2019 with the JBoss Community, feel free to browse the growing idea list below. Please don't hesitate to contact the mentor(s) indicated in the proposal for any related clarification and to discuss proposals. Students can submit the proposals in 2019.
If you want to suggest an additional idea, please use the page GSoC 18 Student Ideas (you'll need a free JBoss Community account to edit the page). Interested mentors can check the student ideas page and sign up to be a mentor by moving the idea onto the main page.
You can also look at GSoC-16 Ideas, 2017 Ideas and 2018 Ideas for suggestions from last years.
Administrators and Mentors
We will list the potential mentors in this place. For now, if you have any questions, please contact the primary GSoC administrator:
Heiko Rupp (@pilhuhn) or co-administrators Matthias Wessendorf (@mwessendorf) and Anuj Garg (@KeenWarrior).
Umbrella org
JBoss community will this year serve as an umbrella for Codeuino - find their projects in the proposals below.
Codeuino organization supervisor is Jaskirat Singh (juskirat2000@gmail.com).
---------------------------------
Application template for Codeuino GSOC 2019 Student Application Template · codeuino/GSOC Wiki · GitHub
---------------------------------
Communication channels
For JBoss Community
Gitter : JBossOutreach/GSoC - Gitter
IRC : #gsoc-jboss on freenode
Please take note - These channels are about generic doubts. For project specific doubts you will need to contact project mentors and channels specified in the project description.
For Codeuino Orgnaistion
Slack Discussion platform : http://slack.codeuino.org/
IRC : #codeuino on freenode
---------------------------------
Notes
Points to consider while choosing any project
1. You meet at least 50 percent of pre-rq. Remaining skills can be honed on the go, so don't worry if you lack some.
2. You can relate with the project idea and you have used something related to the project as user.
3. You are willing more toward learning the skills and less toward boasting about the skills you have already.
Suggested steps after choosing favourite project
1. Start to use product/tool/api as user or hello world client application.
2. Setup the development environment for project and start to use your own build.
3. Look for new comer bugs and try to get your head around them.
4. Let us know if you feel stuck at any stage.
Idea Proposals
Category : Testing
EAT - Testing Infinite Software Project Versions
Summary of idea:
The innovative part of EAT is creating the test once and testing with any version of the tested software. It may be firstly applied for the JBoss Servers, but, in general, a similar structure, can be used for creating tests about any software with multiple versions or for multiple software programs that have a part of the testsuite in common. EAT is a project under the ΙΔΕΑ statement.
Possible tasks for this project :
Go through the EAT workshop, extending the existing AT testsuites, creating a new testsuite using the AT Structures, improving the dependency AT analyzer (dynamic testing), etc
Github repo: https://github.com/jboss-set/eap-additional-testsuite
Contact / potential mentors: Panagiotis Sotiropoulos (psotirop@redhat.com)
Associated JBoss community project: EAT
Category: Observability
Improve the performance of Kiali - Service Mesh Observability Project through GraphQL
Summary of idea:
Kiali is the bundled Service Mesh Visualization console for Istio Service Mesh.
The idea here is to provide performance enhancements via GraphQL client/server:
- Both the frontend(Kiali-ui) and backend(Kiali) would need to be connected to GraphQL.
- GraphQL will provide a single request for multiple resources (and metrics) enhancing the performance of the server/ui and simplifying the asynchronous nature of coordinating multiple requests.
- This will also open up easier resource/metric discovery through the GraphQL Explorer and allows for some new interesting tools to take advantage of the Kiali Server.
Knowledge prerequisite: Go, Javascript/Typescript, ReactJS, GraphQL
Github repo: http://github.com/kiali/kiali
Skill level: Intermediate, Experienced
Contact(s) / potential mentors(s): Heiko Rupp (pilhuhn), Mike Thompson (mithomps@redhat.com)
Associated JBoss community project(s): Kiali
Make Kiali able to work with Linkerd
Summary of idea:
Kiali is currently tied to Istio. Another popular Service Mesh is Linkerd.
The idea here is to decouple Kiali from Istio, with an abstraction layer, and be able to have it work using Linkerd metrics.
Some current functionalities wouldn't be available as Linkerd metrics don't provide as much information as Istio metrics, but we should be able to have a minimal UI with workloads graph, Kubernetes objects lists and details as well as metrics page.
Knowledge prerequisite: Go (help will be provided with the language, if beginner), Javascript/Typescript, ReactJS
Github repo: https://github.com/kiali/kiali
Skill level: Intermediate
Contact(s) / potential mentors(s): Heiko Rupp (pilhuhn ), Joël Takvorian (jtakvori@redhat.com)
Associated JBoss community project(s): Kiali
Category: Data Streaming
Stand-alone change data capture server based on Debezium
Summary of idea:
Debezium is an open-source platform for change data capture (CDC) and lets you stream data change events out of a variety of databases such as MySQL, Postgres, SQL Server, MongoDB and others. The idea of this proposal is to provide a stand-alone runtime based on Debezium that can be configured with different outbound connectors e.g. to stream changes to Amazon Kinesis, Cloud Events etc.
Your mission, should you decide to accept it, will be:
- Build a small runtime environment for running Debezium connectors, e.g. based on the MicroProfile APIs
- Define an SPI (service provider interface) that allows to emit change events into different message brokers such as Amazon Kinesis
- Ensure the runtime can be safely paused and restarted, resuming its work where its left off before
- Explore what’s needed to operate that Debezium runtime on Kubernetes/OpenShift (container image, liveness/readiness probes, Kubernetes Operator etc.)
- Build an end-to-end demo based on OpenShift, that uses the runtime to capture changes in a database, produce CloudEvents and consume these events
Knowledge prerequisite: Java, Maven, Git, at least one of the databases supported by Debezium; ideally Kubernetes/OpenShift, too
GitHub repo: https://github.com/debezium/debezium
Skill level: Intermediate, Experienced
Contact(s) / potential mentors(s): Gunnar Morling (gunnar@hibernate.org)
Associated JBoss community project(s): Debezium
Reliable asynchronous CDI events through change data capture
Summary of idea:
The CDI spec defines the notion of asynchronous events, i.e. events that will be processed out of the context of the transaction from which the events originated. This is a powerful tool in the box, but puts the burden of ensuring reliability and consistency in case of failures during asynchronous processing to the developer. The idea of this proposal is to persist events in a database and use Debezium, an open-source platform for change data capture (CDC), to stream these events to asynchronous event handlers in a reliable way.
Your mission, should you decide to accept it, will be:
- Implement a CDI portable extension that receives CDI events and persist them in an “events” table in the database as part of the ongoing transaction
- Integrate Debezium (using its embedded engine) to ingest new “event” records from that table and pass them to any asynchronous handlers of that event type
- Ensure asynchronous handlers are invoked in a reliable manner, i.e. a failure in one of them shouldn’t impact others, and failed events should be retried with the affected handler (and only that one), a configurable number of times.
- Develop a “housekeeping” process that ensures entries are removed from the events table once they have been completely processed
Knowledge prerequisite: Java, Maven, Git, at least one of the databases supported by Debezium; understanding of dependency injection
GitHub repo: https://github.com/debezium/debezium
Skill level: Intermediate
Contact(s) / potential mentors(s): Gunnar Morling (gunnar@hibernate.org)
Associated JBoss community project(s): Debezium
Category: Mobile
AeroGear Digger - CI/CD workflows on AeroGear Digger with advanced testing cases
Summary of idea:
AeroGear Digger gives users the possibility of coming up with their own CI/CD workflow. We would like to experiment with some advanced testing scenarios.
Prepare workflows for Android and IOS app builds that demonstrate how to do some advanced testing scenarios on an AeroGear Digger CI/CD workflow. Examples are on-device or on-simulator testing, compatibility testing, low-level resource testing, offline testing and performance testing but not limited to these.
Here is an overview of the tasks to be done:
- Install necessary tools in build containers.
- Install plugins in Jenkins installation, if necessary.
- Execute the workflow step in CI/CD workflow in Jenkinsfile
- Create sample workflows, record demos about them, write blog posts about them
Detailed info available at AeroGear's GSOC 2019 page: https://github.com/aerogear/GSoC-2019
Technologies: Jenkins, Docker, Kubernetes, OpenShift, Mobile
GitHub repos:
- https://github.com/aerogear/aerogear-digger-installer
- https://github.com/aerogear/aerogear-digger
- https://github.com/aerogear/digger-android-slave-image
Skill level: Intermediate
Contact(s) / potential mentors(s): Ali Ok (@aliok_tr)
Associated JBoss community project(s): AeroGear
Mailing list / IRC: https://groups.google.com/forum/#!forum/aerogear / #aerogear at freenode
A Node.js library to support GraphQL Subscriptions Powered by Red Hat AMQ
Summary of idea:
The goal of this project is to create a Node.js library that can be used to implement GraphQL subscriptions using Red Hat AMQ as the underlying Pub Sub technology. (Upstream project is Apache ActiveMQ Artemis 2.0.0)
There is a huge amount of scope here for the student to learn about GraphQL, Microservices, Asynchronous Messaging, Event Driven Architectures and Red Hat technologies. Because the deliverable (A Node.js library) would be quite small, The student is also encouraged to write tests, fully featured documentation, and to take ownership of the publishing/release lifecycle (on npm).
As a stretch goal, the student could also build an example application e.g. a real time messaging application that uses their new node.js library and the apollo-voyager-server framework as a proof of concept.
In GraphQL, subscriptions is a concept that allows clients to subscribe to events happening on the server. The basic idea is that an event happens on the server and the server has some way to notify any clients that are interested in that event. For example, in a group chat application, all of the clients could subscribe to a new message event. The most common implementation of subscriptions uses websockets between the server and client. This allows the server to send back events to the clients in real time.
In a production environment, there will be several instances of the backend application running at the same time. The backend servers need a Publish/Subscribe (Pub Sub) mechanism to share events back and forth between each other.
Publish/Subscribe is a is a form of asynchronous service-to-service communication used in serverless and microservices architectures. In a pub/sub model, any message published to a topic is immediately received by all of the subscribers to the topic.
For example, Using Pub Sub, Server 2 can know about an event that happened on server 1 and server 2 can notify its connected clients about the event.
There are many technologies that can be used for Pub Sub. (Examples: RabbitMQ, Apache Kafka, MQTT) and there are many Node.js libraries that allow us to use Pub Sub technologies in GraphQL applications. They would be a great starting point for trying to implement a new one. https://github.com/apollographql/graphql-subscriptions#pubsub-implementations
Red Hat has a messaging product called Red Hat AMQ which can be used to implement a production ready Publish/Subscribe architecture. The goal of this project is to create a node.js library that can be used to implement GraphQL subscriptions using Red Hat AMQ as the underlying Pub Sub technology.
Detailed info available at AeroGear's GSOC 2019 page: https://github.com/aerogear/GSoC-2019
Technologies: GraphQL, Node, AMQ, ActiveMQ
GitHub repos: https://github.com/aerogear/voyager-server
Skill level: Beginner, Intermediate
Contact(s) / potential mentors(s): Dara Hayes (@darahayess)
Associated JBoss community project(s): AeroGear
Mailing list / IRC: https://groups.google.com/forum/#!forum/aerogear / #aerogear at freenode
Ionic Capacitor integration with AeroGear Voyager
Summary of idea:
Capacitor technology enables smooth transition between Android/IOS and PWA.
Proposed work will require getting familiar with Ionic Capacitor and extending current Ionic Voyager template to work with Capacitor Framework. At later phase native implementations for IOS and Android can be done.
What is required to work on:
- Basic knowledge of Node.js and TypeScript (participants can learn that)
- Mobile development: IOS/Android is a plus
What students will get:
- Familiarity with modern cross platform dev tools (Ionic ecosystem)
- IOS/Android plugin development
Challenges:
- All work requires extensive research of Ionic Capacitor.
- Developers can contribute work directly in Capacitor repository and become Ionic collaborator
Detailed info available at AeroGear's GSOC 2019 page: https://github.com/aerogear/GSoC-2019
Technologies: GraphQL, Node, Ionic, Typescript, Javascript, iOS, Android
GitHub repos: https://github.com/aerogear/apollo-voyager-ionic-example
Skill level: Intermediate
Contact(s) / potential mentors(s): Wojciech Trocki (@wojtroken)
Associated JBoss community project(s): AeroGear
Mailing list / IRC: https://groups.google.com/forum/#!forum/aerogear / #aerogear at freenode
Kubernetes Operators for Unified Push Server and AeroGear Digger
Summary of idea:
The goal of this project is to create Kubernetes Operators that can install, update, configure and manage Unified Push Servers and AeroGear Digger, using the Operator-SDK.
Detailed info available at AeroGear's GSOC 2019 page: https://github.com/aerogear/GSoC-2019
Technologies: Golang, Operator Framework, Kubernetes
GitHub repos:
Skill level: Beginner, Intermediate
Contact(s) / potential mentors(s): Wei Li (weil@redhat.com)
Associated JBoss community project(s): AeroGear
Mailing list / IRC: https://groups.google.com/forum/#!forum/aerogear / #aerogear at freenode
AeroGear Remote Configuration Service
Summary of idea:
For many client apps, developers sometimes want to change the behaviour or appearance of the apps using configurations. However, they do not want to release new apps every time when they need to update the configuration. The AeroGear Remote Configuration service will allow developers to update the configurations for their client apps remotely, without the need to release a new app.
The main components of this service including:
- A backend server that can manage configurations, probably built based on the AeroGear Voyager GraphQL server
- A UI that will developers to define configurations for their apps, and setup rules about what client/device can get what configurations
- A client side SDK that can manage fetching the configuration, caching and notify developers about configuration changes. Initial target is to have a JavaScript SDK, built based on the AeroGear Voyager client modules.
Detailed info available at AeroGear's GSOC 2019 page: https://github.com/aerogear/GSoC-2019
Technologies: Nodejs, GraphQL, AeroGear Voyager, React
GitHub repos: https://github.com/aerogear/voyager-server
Skill level: Beginner, Intermediate
Contact(s) / potential mentors(s): Wei Li (weil@redhat.com)
Associated JBoss community project(s): AeroGear
Mailing list / IRC: https://groups.google.com/forum/#!forum/aerogear / #aerogear at freenode
Conflict Resolution for AeroGear Sync Android/iOS SDK
Summary of idea:
A port of the current JS SDK to Android or iOS. Although porting work seems straightforward, conflict resolution, offline support etc. makes this work more complex.
This is actually 2 projects for 2 students: one for Android and one for iOS.
Detailed info available at AeroGear's GSOC 2019 page: https://github.com/aerogear/GSoC-2019
Technologies: Android OR iOS, GraphQL, OpenShift, Docker
GitHub repos:
- https://github.com/aerogear/voyager-server
- https://github.com/aerogear/aerogear-js-sdk
- https://github.com/aerogear/aerogear-android-sdk
- https://github.com/aerogear/aerogear-ios-sdk
Skill level: Intermediate, Advanced
Contact(s) / potential mentors(s): Ali Ok (@aliok_tr)
Associated JBoss community project(s): AeroGear
Mailing list / IRC: https://groups.google.com/forum/#!forum/aerogear / #aerogear at freenode
AeroGear Voyager Server - GraphQL community ideas
Summary of idea:
These are ideas on Github: https://github.com/aerogear/apollo-voyager-server/issues?q=is%3Aissue+is%3Aopen+label%3Aideas
As these ideas are relatively small for a 3 month GSoC project, candidates need to pick a few ideas they would like to implement during GSoC, contact the potential mentor and apply GSoC.
What is required to work on:
- Basic knowledge of Node.js and TypeScript (participants can learn that in first weeks)
- Willing to learn about GraphQL, Node.js and supporting technologies
What students will get:
- Possibility to resolve real problems that GraphQL community is facing
- Possibility to contribute to leading frameworks and extend AeroGear Voyager server
- Learn about best patterns and collaboration in JavaScript community
- Work with wider team defined by GraphQL enthusiasts
Challenges:
- All work requires extensive research in GraphQL community - picking the right tools or evaluating new hottest technologies
- Implementation will require participants to provide clean API, documentation and great UX
Detailed info available at AeroGear's GSOC 2019 page: https://github.com/aerogear/GSoC-2019
Technologies: Nodejs, GraphQL, Typescript
GitHub repos: https://github.com/aerogear/voyager-server
Skill level: Beginner, Intermediate
Contact(s) / potential mentors(s): Wojciech Trocki (@wojtroken)
Associated JBoss community project(s): AeroGear
Mailing list / IRC: https://groups.google.com/forum/#!forum/aerogear / #aerogear at freenode
Kotlin Multi-platform SDK for Unified Push Server
Summary of idea:
The goal of this work is to create a multiplatform SDK for Unified Push Server using Kotlin Native. See Multiplatform Projects - Kotlin Programming Language
Detailed info available at AeroGear's GSOC 2019 page: https://github.com/aerogear/GSoC-2019
Technologies: Kotlin, Android, iOS
Skill level: Beginner, Intermediate
Contact(s) / potential mentors(s): Wei Li (weil@redhat.com)
Associated JBoss community project(s): AeroGear
Mailing list / IRC: https://groups.google.com/forum/#!forum/aerogear / #aerogear at freenode
Teiid Community
Summary of idea:
Project 1:
The goal of the project is to build non opinionated GraphQL library using Teiid technologies such that GraphQL API could be enabled on any data source that Teiid supports.
Project 2:
Write a vs-code plugin to validate DDL and provide command completion based on ANSI-SQL and Teiid specific SQL-MED grammer. The idea that if user using vs-code and starts to enter DDL statements help in comannd completion and validate for their syntax and validity as whole schemaand provide contextual help/tips along the way.
Technologies: java, node, vs-code
Skill level: Intermediate
Contact(s) / potential mentors(s): Ramesh Reddy(rareddy@redhat.com)
Associated JBoss community project(s): Teiid
Category: Security
Elytron is a set of Java APIs and SPIs for application server security. Although it was developed to unify security across the WildFly application server, Elytron is an open-source, standalone library that can theoretically be used in other Java server environments. Within WildFly, Elytron is used to secure applications deployed to the server and to secure management access to the server.
Project 1: Client side HTTP authentication mechanisms for Elytron
Summary of idea:
Elytron already provides both server side and client side SASL authentication mechanisms and server side HTTP authentication mechanisms. The idea here is extend this to include a client side framework for HTTP authentication mechanisms and implement a set of client side HTTP authentication mechanisms.
Project 2: Script Engine integration for Elytron
Summary of idea:
Elytron's APIs and SPIs can be used by custom implementations to extend Elytron functionality. The idea here is to add Script Engine integration to support custom implementations for Elytron components in languages other than Java.
Technologies: Java
GitHub repos: https://github.com/wildfly-security/wildfly-elytron
Skill level: Beginner, Intermediate
Contact(s) / potential mentors(s): Darran Lofthouse (darran.lofthouse@redhat.com) and Farah Juma (fjuma@redhat.com)
Associated JBoss community project(s): Elytron, WildFly
Category: Codeuino
Project 1: Development of modules with new UI/UX
Summary of idea:
Developing configuration mechanism is one of our newest additions to our installation frameworks of DONUT Platform The task of this major project is to develop a minimum of 12 different Modules for the social environment ( DONUT Platform ) along with a good looking User Interface architecture. To simplify the configuration, these predefined modules will have the most common use cases with different options for modules and settings while setting up this environment.
Few have been described below which would serve essential features but make sure you meet the minimum criteria (12) for these.
1.) Defining the Security Settings
- External users can register (show registration form on login)
- Allow access for non-registered users to public content (guest access)
2.) Setup independent Modules for following:
- Notification ( This widget will show upcoming notifications on the dashboard ) Issue to work
- Tasks Manager ( This will help to form tasks/assigns tasks/track tasks )
- building Forms that will help users to post their projects/events/articles/etc
- Formatting Tool ( It will Help in formatting the content which can be written to post something )
- Most Active Projects/People/posts/articles (Defining most active people and most viewed projects )
3.) Sample data Content
- This part will consists of developing Dashboards for organization and Users differently depending upon who signed up. Issue to work
- Developing "Pages" just like we have in Facebook( This is the main part of the project as it will help the users or community to develop pages for their "project"/"events"/internships or any other related things in order to showcase it in profound way)
These modules should be developed with appropriate User Interface(i.e. front-end part) as well as back-end code with better User Experience.
References: What exactly modules mean-Guide by Digital Ocean
Plugins from Elgg that can help to know more about modules
Some modules example by Terasology
Knowledge prerequisite: Good knowledge of Modules with packaging
languages such as Python, Node Js, JavaScript, HTML, and CSS, Vue.js
UI/UX experience is also required with unique approach.
GitHub repos: https://github.com/codeuino/Social-Platform-Donut
Skill level: Intermediate
Expected Outcome: This project would result in formation of packaged modules with new User Interface that would help the users and various communities to get predefined things configured on initial installing or setting up.
Contact(s) / potential mentors(s): Jaskirat Singh (juskirat2000@gmail.com), Devesh Verma (deveshverma619@gmail.com), Vaibhav Aren (vaibhavdaren@gmail.com), Prateek Chanda (prateekkol21@gmail.com) and Uphaar Dubey (uphaar23dubey@gmail.com)
Project 2: Categorization system using tags in DONUT PLatform along with module development to retrieve analytics and export it in CSV/PDF format
Summary of idea:
The DONUT Platform contains the notification feature which helps users to accommodate things in easy way. So the task of this project is to develop a mechanism for "tags" (Explanation of tags in posts by WordPress) These tags will provide a useful way to group related posts together and and to quickly tell readers what a post is about and where to redirect or highlight the particular post more. The mechanism should be developed in such a way that users can make their own tags or can also select from predefined tags(this needs to be built) which gets automatically saved at one place that can be called as tag cloud and while submitting any posts it should get redirected to the appropriate users/groups which contains the similar tags.The tag cloud needs to be built which can store all the tags.
When someone viewing your blog/project/article/any other post, clicks on one of defined Tag links, a Tag archive page with all the posts belonging to that Tag, should be displayed should also get displayed.
Lets Understand this with example
Assume that "X" user signs up on the DONUT platform. Once the "X" user has defined all the details about himself, then he would be asked to select some tags from the tags cloud which describes him the best and here, "X" user chooses "Designer", "Nodejs" and "Html". this tells us from the description of the tags in the tags cloud that this "X" user is a "Designer" and knows languages like "Nodejs" and "Html".On pursuing further these tags get stored for him.
Now assume other user "Y", suppose "Y" user is already logged into this platform. "Y" user writes a post as project/article/blog or any other thing related to feeds on it, before he publishes, he would be asked to choose some tags from the "Tags Cloud". Suppose the "Y" user choose "Nodejs" tag from it. **Here, we see that user "X" and "Y" has "Nodejs" common in them.** So on publishing the post by user "Y", the particular project would be redirected to the "X"(because they both contain common tags), According to the tags description user "X"would be able to review the thing.
"X" and "Y" can be users as well as communities.
Few things to be considered while developing the tags module as:
- Minimum of 50 predefined tags are required with different colors.
- Users can also make custom tags
- Some required items can be inspired from here
- Should be well formatted in the table in the "tags cloud" with tag name and descriptions required.
- giving access to the users to delete custom made tags as well as edit custom made tags.
Another objective is to develop a module using APIs with which communities admins will be able to gather meaningful insights from the various conversation happening in various phases of the DONUT platform. But, sometimes, it becomes difficult for the admin to personally go through all the Activities that are happening within the channels of this platform like people posting various things, tagging and introducing new projects, etc. This is where an analytics tool could save the day for admins. This project aims at developing a module to retrieve and show meaningful information to admins which could help them remain updated with all the happenings within the community. This should result in the formation of a Summary sheet which can also be notified through emails to them.
Following are the basic feature which should be supported by the analytics module:
- Admin should be able to track all the members within the community
- Users privacy should be kept secure and safe and no one other than community admin should be able to access any conversation
- The data should be collected and organized in the proper way to extract meaningful information. It should also help admin to understand community members behavior and trigger automation workflows
- The analysis should show key trends, how many members are active and are responding which should help him make a future decision.
- The report should be updated in real-time.
- Admin should be able to export the report generated in CSV/PDF format.
- The proper user interface should be used to make the report attacking and readable.
References: Reference 1 by tag modules by WordPress
Exporting work space data from Slack
Knowledge prerequisite: Good knowledge of Modules with packaging
languages such as Python, Node Js, JavaScript, HTML, and CSS, Vue.js
Good knowledge about data analytics and commonly used analytics tool
Prior experience with Data analytics or data collection
Technologies required: Python, HTML, CSS, Python Libraries like numpy, Matplotlib etc.
Converting analytics report in PDF or CSV format
Prior experience of NLP and semantic analysis will be an added advantage
.
GitHub repos: https://github.com/codeuino/Social-Platform-Donut
Skill level: Intermediate
Expected Outcome: This tag module will help users to review group related posts together and to quickly tell readers what a post is about by supporting them in their projects if needed. Tags also make it easier for people to find content as well as describe your own tag in better way.
Contact(s) / potential mentors(s): Jaskirat Singh (juskirat2000@gmail.com), Pranjal Kumar (pranjalkumar8228@gmail.com), Devesh Verma (deveshverma619@gmail.com), Pratul Kumar (pratulkumar1997@gmail.com )
Project 3: Improve the user experience of the Admin Dashboard with a module that automatically publishes scheduled social posts
Summary of idea:
The DONUT Platform already contains dashboard for users only but with new mission and aim DONUT platform can be used by an individual user as well as by the community. This project defines the purpose to give more profound look to the Admins dashboards for the "users" and "community" differently. More and better user interface and user experience required that could fulfill the requirements for the users and community admins.
Since for the community, only a single user can register/sign up for their community, so the community admin( person who register/signs up)should have all the access. Few things/features described below.:
- Admins can add members to the community.
- Blocking users ( Giving access to block people)
- Analytical representation (This will help community view stat for their posts which can be shown through popularity/most viewed,etc )
- Contribution on various projects by making the APIs and integrating with the Github.
- Project/Articles/blogs and other feeds posted by community
- Comments made by people on any community post
- Profile with all details (Giving access to delete any post)
- Allowing to give them access for the "settings" of the community
- Activity logs ( This feature will describe about followings, comments, Upvote/Downvote, stare, pinned things( posts/projects/events/etc)
You are welcome to add more features that can improve the UI/UX and result in good outcome. Look here at this example to see some UIs for dashboard
User Dashboard should includes the following things:
- User profile (with appropriate settings feature)
- Activities log ( This feature will describe about followings, comments, Upvote/Downvote, stare, pinned things( posts/projects/events/etc)
- Groups ( Create, invite and manage your own groups )
- blocking other users
The other part of this project is to develop a module that would help users to draft their posts in advance which can be posted accordingly and automatically after it has been scheduled with appropriate timing.
For instance, if "X" user wants to publish his project/post on "Y date/day", then he will write their posts in advance in this tool and schedule it with appropriate timings/day/date. On particular "Y date/day" this post would automatically get published. This will help to save time and increase efficiency.
The other part of this project is to integrate other social handles like Facebook, Twitter, LinkedIn, YouTube with the DONUT platform so that post can be shared on other social handles too.
Note: This project requires additional minimum 10 features for both users as well as organisations apart from the above described ones. Creativity would be really appreciable and be taken into consideration.
Initial dashboard code can be seen at https://github.com/codeuino/frontened/blob/master/User-dashboard.html
References: #Reference 1 - Some good looking UI/UX of dashboard
#Reference 2 - Guide explaining the structuring of the dashboard
#Reference 3 - Open Source guide describing the components of a dashboard
#Reference 5 - Google analytical
#Reference 6 - Hootsuit which is paid and non-open source guides about it
Knowledge prerequisite: Good knowledge of databases
languages such as NodeJs, Html CSS, Bootstraps, JavaScript, Vue.js
Knowledge of visual representation
GitHub repos: https://github.com/codeuino/Social-Platform-Donut
Skill level: beginner, Intermediate
Expected Outcome: This project would reward back with more user friendly and better User experience dashboard along with a tool that will help users to save their post as a draft and share them anytime or automatically through Reminders.
Contact(s) / potential mentors(s): Aishwarya Srivastava (aishsrivastava1998@gmail.com), Uphaar Dubey (uphaar23dubey@gmail.com), Jaskirat Singh (juskirat2000@gmail.com), Devesh Verma (deveshverma619@gmail.com)
Project 4: Integration of Task Management tool in DONUT platform
Summary of idea:
The purpose of this project is to integrate task management tool for DONUT platform which will provide admins of the communities to organize the workflow using the concept of generating cards to showcase task. By making use of **Task Management tool** admins will be able to organised different types of tasks that has been achieved/to be achieved/in progress.
Also, Task Management tool will have progress monitoring charts, to explain this in a better way the progress tracking will help in monitoring the development cycle of the projects. Using the progress tracking feature contributors will be well aware of the deadlines to finish a particular task. Also this will help better management of the communities.
Following are the things that an integrated Task Management tool should have:
- Automating the work flow ( This will set up triggering events to save time on project management that can move tasks into the right columns accordingly.)
- Representing the progress made with the help of visualization
- Project boards are made up of issues and notes that are categorized as cards in columns of your choosing. These can drag and drop or use keyboard shortcuts to reorder cards within a column, move cards from column to column, and change the order of columns.
- Creating notes within columns with appropriate formatting tool
- Able to add task reminders, references to issues and pull requests from any repository on GitHub, or to add information related to the project board.
- Allowing selecting things with the help of checklist added
- Notifying assignee through email if any comment made or tagged.
Note: This project can be achieved by integration of task management tools from Github, Trello and other tools that can result in same outcome
References: #Reference 1 - Project Board Engineering
#Reference 2 - GitHub Project Board
Knowledge prerequisite: Good knowledge of Integration
Knowledge of working in project boards of GitHub and Trello
languages such as NodeJs, Html CSS, Bootstraps, JavaScript, React;
Knowledge of visual representation
GitHub repos: https://github.com/codeuino/Social-Platform-Donut
Skill level: beginner, Intermediate
Expected Outcome: With integrated tool communities would be able to track progress and will able to generate task for members.
Contact(s) / potential mentors(s): Aishwarya Srivastava (aishsrivastava1998@gmail.com), Vaibhav Aren (vaibhavdaren@gmail.com), Prateek Chanda (prateekkol21@gmail.com)
Project 5: Integration of Chat functionality in DONUT Platform
Summary of idea:
Communication is an important part of the development cycle and for an efficient product, it's important that all the team members can communicate and coordinate accordingly. This is why we wish to provide a proper communication channel for developers where they can discuss about any new development in their project, can share their ideas with their team members or even plan a team meeting. This project aims at integrating various chat platforms like Slack, Gitter, and IRC with the DONUT platform. Since DONUT is an open source platform, community leaders and team leaders should be able to create a channel or add or remove members from the channel. This project would require integration through making APIs.
Following the basic feature which should be supported by the chat platform:
- Secure Integration with various chat platforms like Slack, Gitter, and IRC using their APIs
- User experience should be a top priority while developing the chat functionality so that even a new developer finds is very easy
- User privacy should be a top priority
- Team leaders or organization Leaders should be able to create a different channel where they could add to remove members
- Notification feature in case of an emergency message with the group of which a particular user is a part of, either via text message or email.
- To perform meaningful analytics across various chat platforms and an efficient way to manage them
- Video communication platforms should also be integrated as an additional feature for effective team meetings.
- The efficient way to handle the large traffic in case of video communication
Some of the widely used chat platforms (textual) which need to be integrated are as follows :
Note: The above-mentioned communication platforms are just the examples and any new platforms can also be added and integrated
References: Integrating Slack using API
Developing a video communication platform
Knowledge prerequisite: Good knowledge of databases
languages such as NodeJs, Html CSS, Bootstraps, JavaScript, React;
Knowledge of visual representation
GitHub repos: https://github.com/codeuino/Social-Platform-Donut
Skill level: Intermediate
Expected Outcome: With the integration of proper communication channel, the communities should be able to communicate and coordinate any project.
Contact(s) / potential mentors(s): Pranjal Kumar (pranjalkumar8228@gmail.com), Uphaar Dubey (uphaar23dubey@gmail.com), Jaskirat Singh (juskirat2000@gmail.com)
Category: Kubernetes & Openshift Tooling
This category deals with tools which help in work Kubernetes and Openshift .
This category has mainly three repositories :
- Kubernetes Client : Its a fluent DSL wrapper for Kubernetes & OpenShift 3 REST APIs. GitHub - fabric8io/kubernetes-client: Java client for Kubernetes & OpenShift 3
- Fabric8-Maven-Plugin (FMP) : Its a popular maven plugin to build docker images for their Java applicatios, generate and deploy resources on Kubernetes & Openshift.
GitHub - fabric8io/fabric8-maven-plugin: Maven plugin for getting your Java apps on to Kubernetes and OpenShift | Docs : https://maven.fabric8.io/ - Tomcat Quarkus extension: Quarkus is a Kubernates Native Java stack and Tomcat as an application server will fit Quarkus as an extension. Repo: GitHub - apache/tomcat: Apache Tomcat
The applicants for these projects are not expected to have full knowledge on Kubernetes and Openshift. Basic familiarity should suffice. There will be learning curve involved, especially when it comes to Container platforms,
as per the requirements of the respective projects.
However, strong programming skills in Java are required.
For discussing projects I and II in this category, join our public channel on Mattermost and #fabric8 on IRC .
For discussing project III, please join our freenode channel #jws-jbcs on freenode
For Suggestions on project proposal's format, This document suggests a format for proposing a project for Google Summer of Code. · GitHub
Project 1: Adding more options in Fabric8-Maven-Plugin for building images.
Fabric8-Maven-Plugin currently supports two ways of building Container Images for applications, Docker and Source To Image ( s2i ).
It would be good to more options for build operations. The following tools should be integrated :
There must proper test coverage for every feature added.
Github: More options for building images. · Issue #1534 · fabric8io/fabric8-maven-plugin · GitHub
Required Skills: Java, Maven, familarity with Docker, Containers
Potential mentors : Alex Soto Bueno (asotobue@redhat.com), Devang Gaur (dgaur@redhat.com)
Project 2: Adding support for missing resources & missing test coverage in Kubernetes-Client.
Part 1: Kubernetes-Client currently lacks support for the multiple resources. The supports should be added and there must be proper test coverage along with it.
Github: Add support for missing resources · Issue #1380 · fabric8io/kubernetes-client · GitHub
Part 2: There are tests missing for several Resources. Those tests need to be added.
Github: Test coverage missing for multiple resources · Issue #1381 · fabric8io/kubernetes-client · GitHub
Required Skills: Java, Maven, Testing, basic familiarity with Docker, Kubernetes & Openshift.
Potential mentors : Rohan Kumar (rokumar@redhat.com), Devang Gaur (dgaur@redhat.com)
Project 3: Adding Tomcat as an extension to Quarkus.
Quarkus is a Kubernetes Native Java stack tailored for GraalVM & OpenJDK HotSpot, crafted from the best of breed Java libraries and standards. With the recent launch of Quarkus we would like to add Tomcat as a additional extension to it, taking advantage of the great features that came with it.
Sample guide: https://quarkus.io/guides/extension-authors-guide
GitHub: GitHub - apache/tomcat: Apache Tomcat
Required Skills: Java, Containers, Kubernetes
Skill Level: Intermediate-Advanced
Potential mentors : Coty Sutherland (csutherl@redhat.com, freenode: csutherl), George Zaronikas (gzaronik@redhat.com, freenode: gzaronikas)
Category: Documentation - Tooling
Document/Release Notes generation tool
Summary of idea:
A Document generation tool that communicates and scans the various bug tracking systems(JIRA, Bugzilla et cetera) and automatically creates release notes based on tracking system information. One should be able to generate release notes/Issue Tracker reports periodically, on demand or on specific events using this tool. The tool should be able to scan, custom or not, issue tracker fields and generate release notes or documents based on the user given configuration.
Knowledge prerequisite: Python
Skill level: Beginner
Contact(s) / potential mentors(s): George Zaronikas (freenode: gzaronikas, gzaronik@redhat.com) , Sokratis Zappis (szappis@redhat.com)
Associated JBoss community project(s): Starting from JWS, applicable to everything
Comments