Android SDK Tools in Debian

Description of the project: The Android platform is free software, including the tools used for developing apps for Android. Debian-derivatives are already a preferred platform for Android developers, and stretch already includes the core Android SDK tools, enough to build some apps. The Debian Android Tools team is working towards the goal of having the entire Android toolchain and SDK in Debian. That means Android apps can be developed using only free software from easy-to-use packages. In combination with Replicant, this will make the most popular operating system in the world, Android, into a 100% Free Software platform. This project is in conjunction with the Debian Java team, since many tools like gradle are for any Java software.

• Confirmed Mentor: Hans-Christoph Steiner

• How to contact the mentor: hans@at.or.at and @_hc on IRC

• Confirmed co-mentors:

  • Kai-Chung Yan | 殷啟聰, seamlikok@gmail.com and @seamlik on IRC

  • Chirayu Desai, chirayudesai1@gmail.com and @cdesai on IRC

• Deliverables of the project: The deliverables of this project will mostly be finished packages submitted to Debian sid, both for new packages and updated packages. Whenever possible, we should also try to get patches submitted and merged upstream in the Android sources.

• Desirable skills: Building and packaging C/C++ and Java code, an understanding of git. Android development is preferable.

• What the intern will learn: Students will learn to figure out large scale projects like Android, and how to organize their own work within such projects. They will also learn about building and packaging C and Java, as well as some of the guts of Android itself.

• Application tasks: (simple tasks that could show your determination):

  • build an Android app using only apt install android-sdk android-sdk-platform-23 android-sdk-helper, F-Droid is a good app to try

  • backport android-sdk-helper to stretch-backports

  • test Android Tools bash completion (e.g. for adb, fastboot, etc), file bugs if it doesn't work properly

  • anything else you think suitable.

• Related projects: Replicant, the 100% free software Android ROM, uses our packages to provide a 100% free software Android SDK.

There are many chunks of work to be done:

• finish packaging all of the core development tools (lint, SDK Manager, android update project utility, etc.)

• update android-tools and relevant pkg-java packages to the latest upstream version

• add Continuous Integration tests

• update androidsdk-tools to the Android Tools Team style, and update to latest upstream version

• package new parts of the Android upstream source, including the NDK, target platforms, emulators, Android Studio, etc.
• make all Android Tools packages build reproducibly
• improve package build systems to be more tightly integrated with upstream build systems
• package and improve related tools, like apktool, androguard, fdroidserver, drozer, libscout, qark, OWASP Dependency Check, etc.

• Update gradle to 4.x, which is a dependency by the Android Gradle Plugin

Since this project is a large one, multiple mentors and students could work on it simultaneously. You can find relevant documentation in READMEs in each git repo and source package. There is also this wiki section: AndroidTools

There is also a blog post about contributing to this project here

The Debian Android Tools Team works with git and git-buildpackage: PackagingWithGit

Automatic Packages for Everything (backports, new upstream versions, etc.)

• Confirmed Mentor: Lucas Nussbaum

• How to contact the mentor: mailto:lucas@debian.org

• Desirable skills: Debian packaging (including tools to build and test Debian packages), version control systems (Git)

• Application tasks: Prepare a backport for a package already in Debian, provide logs of sbuild and autopkgtest. The more complex the package, the better. Bonus points if the packaging work is done inside Git.

Project description:

Many packaging tasks can be automated, and are likely to succeed without any human intervention:

• creating a backport for Debian stable from a packaging in Debian testing
• upgrading a package to a newer upstream version

• packaging a simple Perl, Python or Ruby using one of the tools listed on AutomaticPackagingTools

However, doing those tasks still require Debian packaging knowledge.

As a step towards Debian's world domination, it would be great if we could automate those tasks and provide ready-to-use Debian packages, so that users are left with a deb-based alternative when there are no packages for their needs in Debian itself, instead of using upstream packages or building from source. So the goal of this project is to experiment with the idea of a service that would distribute unofficial Debian packages for the above scenarios.

Typically, that service would deal with:

• determining which packages should be generated
• generating those packages
• using several methods to detect problems (e.g. piuparts, autopkgtest tests)
• publishing them

The expected outcomes and deliverables are:

• an evaluation of the feasibility of the approach (how many packages fail to build? fail tests?), maybe represented as an Alluvial diagram?

• running infrastructure (most likely on one of Debian's cloud partners, given the need for processing power)
• code to provision and configure such an infrastructure

References:

• related discussion on debian-devel@

• Guido Günther's experiment

• debian-dad: automated source package updater assistant

• autodeb team @ salsa

Boot many machines via bittorrent

Description of the project: Network booting is widely used today: for thin-client computing, cluster computing, operating system installation and context switching in classrooms (i.e., for exams or different lessons). Currently available netboot protocols are the "trivial file transfer protocol" (TFTP) and "hypertext transfer protocol" (HTTP). When a group of machines need to simultaneously boot, the boot server becomes a bottleneck and it is very easy to reach the server network capacity, thus grinding the whole system to a halt. P2P network booting could relieve the server burden and some solution already "exists", but they are either too complicated, very O.S. specific or even "described in a paper but unavailable"... At Università di Milano (Italy) I supported a thesis that succeded in creating a (GPL-licensed) BitTorrent based two-phase booting system, implemented in a less-than-a-hundred-lines script achieving an almost flat boot time with respect to the number of nodes booting together. This project proposal aims at (at least) "packaging" it into a standard Debian package, then expanding it into a more automated e user-friendly product, maybe also integrating it into the famous LTSP project.

• Confirmed Mentor: Andrea Trentini (Università degli Studi di Milano, Italy)

• How to contact the mentor: http://atrent.it

• Confirmed co-mentors: Giovanni Biscuolo

• Deliverables of the project (in random order):

  • debian package for the current (already developed) system

  • integration into LTSP project (maybe creating a "plugin" package for LTSP, e.g. something such as ltsp-server-boottorrent)

  • doc translation into English (this would be done by the mentor, don't worry)
  • creation of a "GUI" (ncurses accepted!) to let the use choose (and optionally download) ISO images to be served for boot

• Desirable skills:

  • critical thinking

  • disciplined development/admin skills

  • SCM tools (i.e. git, nothing else)

  • network knowledge (above all PXE, bootp, TFTP, etc.)

• What the intern will learn:

  • creating Debian packages
  • documenting projects
  • advanced shell scripting

• Application tasks:

  • git commit, merge, solve conflicts, etc.
  • command line operations (filesystem, processes, etc.)
  • create small shell script
  • NOT using the mouse

• Related projects:

  • the current state of development

  • LTSP

  • Debian packages (some of these will be a dependency for this project): ltsp*, tftp|bootp|pxe packages

Automatic builds of clang using OBS

Description of the project: Currently, builds with clang are only done from time to time. This is done through a massive rebuilds of the archive on AWS. Results are published on http://clang.debian.net/ (sources & data: https://github.com/opencollab/clang.debian.net). The idea is to automate this so that the clang link on the right https://packages.qa.debian.org/f/firefox.html) points to the OBS CI.

• Confirmed Mentor: Sylvestre

• How to contact the mentor: sylvestre@debian.org irc://Sylvestre

• Deliverables of the project: CI build with clang instead of gcc

• Desirable skills: Packaging, CI, infra, deployment (salt for example), AWS

• What the intern will learn: How to build packages, the CI which builds Debian packages, some clang stuff

• Application tasks: Deploy an instance of OBS

• Related projects: https://fosdem.org/2018/schedule/event/debianopenbuild/

Two similar projects are proposed under the LLVM umbrella: http://llvm.org/OpenProjects.html#apt

Click To Dial Popup Window for the Linux Desktop

Description of the project: The result of this project is that clicking a tel: link in an application such as Firefox can start a pop-up window with these elements in the GUI: the phone number to be called, a "Call" button that places a phone call, details about the country in which the phone number is registered and another button to save the number to an address book. The application is to be developed as a standalone Python script which will be invoked as a MIME handler. The script will not need to understand how to dial the phone calls: when somebody clicks the "Call" button, the script can run another script such as sipdial in reSIProcate.

• Confirmed Mentor: Keith Larrimore, Thomas Levine

• How to contact the mentor:

  1. subscribe to the debian-outreach list

  2. subscribe to the Free-RTC discussion list

  3. click here, complete all details, make sure you are subscribed to the relevant mailing lists before posting

• Confirmed co-mentors: Applicants are asked to find one or two other developers, possibly somebody you know personally or somebody else from the free software community, who will support this project.

• Deliverables of the project: a Python script that displays a popup window (?PyQt) to help the user dial a phone number they have clicked in another application.

• Desirable skills: Version control systems (Git), Python, ?PyQt

• What the intern will learn: phone numbers, Google's libphonenumber, integrating an application in the Linux desktop, ?PyQt skills

• Application tasks: begin creating the application, demonstrate how you would parse the command line and show the first popup window

• Related projects/links: tel-URI support in GNOME Evolution, testing tel-URIs with Firefox, Epiphany and Thunderbird on Debian, PhoneClient code created in Prizren hackathon

• A sample /ProjectPlan

EasyGnuPG Improvements

• Description of the project: EasyGnuPG is a shell script that wraps GPG and tries to make it more accessible and more easy to use: https://github.com/dashohoxha/egpg In order to simplify things, it is opinionated about the "right" way of using GnuPG. Here are some improvements that can be done:

  • Rewrite EasyGnuPG (or parts of it) so that it is built with Python and GPGME (https://www.gnupg.org/software/gpgme/)

  • Implement a GUI to EasyGnuPG (maybe with Python).
  • Extend EasyGnuPG with scripts/commands that automate other common usage scenarios (for example keeping the master key on a card).
  • Write a Debian package for installing EasyGnuPG.
  Even completing some of them would be considered a success.

• Confirmed Mentor: Dashamir Hoxha

• How to contact the mentor: dashohoxha@gmail.com

• Confirmed co-mentors: T K Sourabh (sourabhtk37@gmail.com)

• Deliverables of the project: To be defined later

• Desirable skills: Python, GPG, Bash scripting

• What the intern will learn: The desirable skills that he does not yet know

• Application tasks:

  • Write a bash script for solving the problem of Towers of Hanoi.
  • Send a message signed and encrypted with GPG.
  • Write a simple GUI program with Python

• Related projects:

Extracting data from PDF invoices and bills for financial accounting

Description of the project: This project aims to develop a complete workflow for discovering bills (in a directory, mail folder or with a browser plugin to extract them from web pages), storing them (a document management system, folder or Git repository), extracting relevant data (bill data, currency and amount) and saving the data (in a format like cXML) in the same document management system. It may be necessary to create a GUI window to help the tool 'learn' how to read a PDF, remember the placement of different data fields in the PDF and automatically extract the same fields next time it sees a bill from the same vendor.

Little or no work on the underlying PDF parsing software should be necessary, as there are already various projects like invoice2data that attempt to extract data from PDF invoices such as phone bills. The summer project will use invoice2data, or a similar software, as the underlying data extraction component.

• Confirmed Mentors: Manuel Riel

• How to contact the mentor: click here, complete all details, make sure you are subscribed to the relevant mailing lists before posting

• Confirmed co-mentors: Thomas Levine

• Deliverables of the project: script or scripts performing the functions required

• Desirable skills: Version control systems (Git), Python, Regular Expressions

• What the intern will learn: financial and accounting workflows, document management

• Application tasks: make a small improvement to the invoice2data project and submit a pull request.

• Related projects: discussion on stack overflow, PDFMiner

This project has been selected for GSoC 2018

Student

Mentors

Project Introduction

Despite efforts to develop new formats for the exchange of invoices, most invoices are still exchanged via PDF, mainly due to the great fallback (can view, print, sign, add stamps, etc) they provide. Purely machine-readable formats, like EDIFACT[1] are only used for high-volumen business relationships by large companies.

In January 2018, France finalized a new standard, called Factur-X that builds on a different German standard ("ZUGFeRD"), as well as EU Norm EN 16931. This standard allows for the embedding of different XML-based invoice representations, like CII[17]. Benefits of using this standard are:

• No change in processes. Companies can keep sending invoices in PDF format.
• Invoices can still be printed and can have graphical design elements.
• Invoice recipients using compatible accounting software can directly process these machine-readable invoices.
• No separate record needs to be kept except the original file.
• Invoices lacking an embedded version can have it added retroactively.

More on the Factur-x standard (translated from [7]):

• Factur-X is a European standard (EN 16931) for mixed electronic billing (PDF for users and XML data for automated processing), the first implementation of the European Semantic Standard EN 16931 published by the European Commission on October 16th [2017]. Factur-X is at the same time a bill readable in PDF format , containing all information useful for its treatment, especially in case of discrepancy of reconciliation with orders or receptions, and invoice data presented as a structured file , complete or not, allowing information systems to perform automated integration and reconciliation. The primary objective of Factur-X is to enable suppliers, billers to create value-added invoices , containing a maximum of information in structured form, according to their ability to produce them in this form, and to let customers recipients free to use the added value thus provided, or not.

While there are a number of commercial libraries[2, 10] and several Java libraries[8, 9] that support the Factur-x standard, there is no fully developed easy-to-use open source Python library.[4]

This Debian-backed and Google-sponsored project aims to advance the ecosystem for machine-readable invoice exchange and make it easily accessible for the whole Python community by making the following contributions:

1. Python library to read/write/add/edit Factur-x metadata in different XML-flavors in Python.
2. Command line interface to process PDF files and access the main library functions.

3. Way to add structured data to existing files or from legacy accounting systems. (via invoice2data project)

4. New desktop (web?) GUI to add, edit, import and export factur-x metadata in- and out of PDF files.

Goals of 2018 GSoC

• Python library to handle metadata embedded in PDF invoices adhering to the Factur-X Standard.
  • Read metadata embedded in PDF files
  • Map XML metadata to Python dict
  • Edit existing metadata
  • Batch-update metadata from Python dictionary
  • Save new or existing metadata in different XML-flavors.

• Reference workflow for invoice generation: Using LibreOffice to compile a template into a PDF with added XML metadata.

• Integrate invoice2data to support the discovery and embedding of metadata in existing PDF files using templates for highest accuracy.
• Develop cross-platform desktop GUI:
  • edit metadata of existing PDFs
  • extract metadata TO standalone file
  • add metadata FROM standalone file
  • export metadata from multiple files to e.g. CSV?
• Website with documentation and introduction
• Testing and publication workflow for all projects

Bonus deliverables:

• cryptographical signing of PDF invoices to guarantee authenticity

Development tools and resources

Source code repositories

Source code is kept on Github for easy access by the wider community. Bugs, ideas and progress on features are tracked via Github issues.

• invoice-x contains libraries

  • invoice2data library to extract structured data from PDF files

  • factur-x library to handle metadata embedded in PDF invoices adhering to the Factur-X Standard

• InvoiceX-GUI: Factur-x GUI

Style guides and best practices

• https://gist.github.com/sloria/7001839

• https://www.python.org/dev/peps/pep-0008/

• https://www.python.org/dev/peps/pep-0257/

Communication channels

• #invoice2data on OFTC/Debian IRC (open to everyone)

Technical skills for student to become familiar with

• Python and related tooling for testing, continuous integration and publishing.
• XML and PDF processing
• Git
• Web development

Current Tasks

References

• 1: EDIFACT: https://en.wikipedia.org/wiki/XML/EDIFACT

• 2: http://www.pdflib.com/knowledge-base/pdfa/zugferd-invoices/

• 3: https://groups.google.com/forum/#!topic/zugferd/AwIh3X56fi8

• 4: https://groups.google.com/forum/#!topic/zugferd/BRBrlIvWAt4

• 5: Official standard - paid and DRMed: https://www.evs.ee/products/evs-en-16931-1-2017

• 6: French standard: http://fnfe-mpe.org/factur-x/

• 7: German standard: http://www.ferd-net.de/electronic-invoicing446/introduction/index.html (has extensive sample files)

• 8: Java implementation: https://github.com/ZUGFeRD/mustangproject

• 9: Another Java implementation: https://konik.io/docs/

• 10: Commercial Java library: https://developers.itextpdf.com/examples/zugferd/creating-zugferd-xml-files

• 11: http://www.unece.org/cefact/xml_schemas/index

• 12: Python library to add XMP data to different files: https://python-xmp-toolkit.readthedocs.io/en/latest/

• 13: https://github.com/akretion/factur-x/blob/master/facturx/facturx.py

• 14: Discussion about invoice metadata in PDFs: https://forums.adobe.com/message/7914863#7914863

• 15: Related service to provide business-focused metadata from PDF: https://www.pdfmapper.com/index_en.html

• 16: https://invoice.conciliator.ai/

• 17: UNECE invoice standard: http://tfig.unece.org/contents/cross-industry-invoice-cii.htm

• 18: UBL Invoice standard: http://docs.oasis-open.org/ubl/os-UBL-2.1/UBL-2.1.html#T-INVOICE

Firefox and Thunderbird plugins for free software habits

Description of the project: there are already several plugins for helping people think twice about visiting web sites they want to avoid. Let's take this concept further by helping people avoid non-free sites and recommending free alternatives. The plugins need to recognize non-free sites (for example, Doodle or Meetup) when they appear in the browser or in an email and encourage the user to use an alternative (for example, Framadate instead of Doodle). See this blog post for some initial ideas and suggested reading. Some ideas are also mentioned in this discussion thread

• Confirmed Mentor: MilenaLavanchy

• Confirmed co-mentors: Applicants are asked to find one or two other developers, possibly somebody you know personally or somebody else from the free software community, who will support this project.

• Deliverables of the project: new plugins (or enhancements to existing plugins) for Firefox and Thunderbird

• Desirable skills: Version control systems (Git), ?JavaScript, Firefox and Thunderbird plugin development, understanding of basic psychology and habits

• What the intern will learn: plugin development skills, helping change user behavior and habits

• Application tasks: find an existing plugin and make a small improvement to it

• Related projects:

This project has been selected for GSoC 2018

Students

Mentors

See the Mentors page for full mentor contact details

Development tools and resources

Recommended mailing lists for all students

• debian-outreach
• debconf-announce
• debian-announce
• debian-devel-announce
• local mailing list in your city/country

Recommended IRC channels for students

#debian-outreach #debconf-discuss

Technical skills for students to become familiar with

• editing Debian wiki pages on MoinMoin wiki

• ?JavaScript

• Mozilla Firefox plugin development
• Git
• basic Linux command line operations, environment variables and basic shell scripting
• IRC
• Synaptic
• Unit testing
• XML
• JSON
• RSS
• iCalendar

Related reading

Books, online articles, ...

• Daniel's blog post

• Enkelena's Project page on Debian wiki

• GSoC Project Proposal

• Documentation & product page

• Project Kanban (public link)

Install FreedomBox in a Container

Description of the project: FreedomBox is designed to be your own inexpensive server at home. It runs free software and offers an increasing number of services ranging from a calendar or jabber server to a wiki or VPN. The aim of this project is to install FreedomBox in a Docker container, using the docker-scripts framework: https://github.com/docker-scripts/ds

• Confirmed Mentors: Sunil Mohan Adapa, Dashamir Hoxha

• How to contact the mentors: dashohoxha@gmail.com, sunil@medhas.org

• Deliverables of the project: Docker scripts that install FreedomBox

• Desirable skills: Bash scripting, familiarity with Docker

• What the intern will learn: How to install and manage Docker containers with shell scripts

• Application tasks:

  • Install Moodle in container, using these scripts: https://github.com/docker-scripts/moodle

  • Install FreedomBox in VirtualBox: https://wiki.debian.org/FreedomBox/Download

• Related projects:

Generate DebConf from Elektra's specification

Description of the project: debconf allows us to ask questions while installing Debian packages. Implementing debconf can be tedious, especially if you allow jumping backwards. Elektra's specification contains all information to generate debconf scripts and templates, which would allow elektrified applications to automatically be installed via debconf.

• Confirmed Mentor: Markus Raab

• How to contact the mentor: markus.raab@complang.tuwien.ac.at

• Confirmed co-mentors:

• Deliverables of the project: (1) A tool that reads Elektra's specifications and generate everything as needed for debconf. (2) One debian package where the feature can be demonstrated. (3) A bug fix for a debian package which is related to the work.

• Desirable skills: General programming skills are necessary, ideally in Shell and C.

• What the intern will learn: You will get contact to people involved in the Debian project and will learn more about how packages are installed in Debian. The long-term aim is to have a single specification that works across distributions.

• Application tasks: You need to open a PR for Elektra which fixes a bug or adds a little feature.

• Related projects: https://www.libelektra.org

Improve the Debian mips, mipsel and mips64el ports

Description of the project: The Debian mips and mipsel ports have been around for a long time. The Debian mips64el port has been around for a short time. There are packages which could build and need some porting. Also, some of the recently uploaded packages stop building and we need to investigate what's causing the failures. The quality of Debian will be improved by fixing these problems. It is very common that a fix on one architecture is a similar fix on other architectures.

• Confirmed Mentor: Anibal Monsalve Salazar

• How to contact the mentor: anibal@debian.org

• Confirmed co-mentors:

• Deliverables of the project: mips, mipsel and mips64el bug fixing.

• Desirable skills:

• What the intern will learn: Debian packaging, patch upstreamming.

• Application tasks: Submit a patch for a Debian bug.

• Related projects:

Recommended IRC channels

#debian-ports

Improving distro-tracker to better support Debian Teams

Description of the project: distro-tracker is a set of services tailored to distribution developers, package maintainers, and anybody who might have to interact with those people (upstream developers, bug reporters, advanced users, etc). It lets you follow almost everything related to the life of a package (or of a set of packages). The goal of this project is to design and implement new features on distro-tracker to better support Debian Teams workflow. The idea is to implement features from PET (Package Entropy Tracker) in distro-tracker teams page with some enhancements. Moreover, this GSoC project may include several contributions to distro-tracker, such as bug fixes and refactoring.

• Confirmed Mentor: Lucas Kanashiro

• How to contact the mentor: kanashiro@debian.org and @kanashiro on IRC

• Deliverables of the project: Enhancements to existing teams features in distro-tracker deployed in https://tracker.debian.org and possible bug fixes

• Desirable skills: Version control system (git), python (specially django framework), web technologies (CSS, HTML and javascript)

• What the intern will learn: How to design, develop and deploy a Debian service

• Application tasks: propose a merge request against https://salsa.debian.org/kanashiro/distro-tracker closing one open issue

• Related projects: PET

Kanban Board for Debian Bug Tracker and CalDAV servers

Description of the project: using Python (?PyQt), create a desktop GUI application that can obtain task lists from various sources (Debian Bug Tracker's iCalendar feed and Github iCalendar, CalDAV servers like DAViCal and the Redmine REST API) and display a Kanban board, as used in Scrum/Agile. Additional considerations: how to manipulate the tasks in real-time with drag and drop, how to group subsets of tasks from different sources that need to be visualized on the same board.

• Confirmed Mentor: Balram Pariyarath

• How to contact the mentor: balbbrl@gmail.com

• Confirmed co-mentors: Applicants are asked to find one or two other developers, possibly somebody you know personally or somebody else from the free software community, who will support this project.

• Deliverables of the project: Python GUI application that can display the Kanban board.

• Desirable skills: Version control systems (Git), Python, exposure to Software Engineering methodologies like Agile

• What the intern will learn: ?PyQt, Agile, Software Engineering and Project Management skills, working with distributed systems

• Application tasks: make a small demonstration of drag-and-drop with ?PyQt

• Related projects: Kanboard, redmine_agile

Successor of the Debian SSO Service

Description of the project

Goal of the project is to design and develop a solution (or enhance the existing sso.d.o) to allow us (Debian) to use it as our project wide SSO solution for projects like nm.d.o, salsa.d.o, paste.d.n and hopefully a lot of others. It should be able to get users from (ud)ldap and another backend. It should also allow creating and selfservice for guest users and DMs. Those users belong into their own backend and should be suffixed with -guest. The current Debian SSO lacks some features that are needed with modern services:

• No Backend for Guests and DMs: currently Debian SSO is using alioth and udldap (the debian internal usermanagement) as backend. Alioth will vanish soon, which means we are lacking a proper backend.
• No self service - since there isn't a backend users aren't able to update their profile, passwords and maybe even SSH Keys
• Lacking support for Oauth2 and/or SAML - most services support one of those two protocols. It would be great to have support at least oauth2

Confirmed Mentor

• Alexander Wirt

How to contact the mentor

• IRC: formorer@oftc

• E-Mail: formorer@debian.org

Confirmed co-mentors

• enrico offered to answer questions
• Nicolas Mora

Desirable skills

• Python or Ruby (web)development experience

What the intern will learn

• How to design, evaluate, develop and (hopefully) deploy a crucial service for such a big project like Debian

Application tasks

• Learn about the current solutions ud-ldap and sso.debian.org
• Evaluate existing solutions
• Design a new architecture
• Announce the architecture
• Develop the solution
• Deploy the solution

Related projects

• https://sso.debian.org

OwnMailbox Improvements

Description of the project: Own-Mailbox is a personal email server you can run in your own home, with strong privacy protection measures integrated at its core. It providesself-hosted email addresses, and allows you to protect the content of your emails, and the meta-data, from mass surveillance. Own-Mailbox is based on technologies such as debian Gnu/linux, mailpile, postfix, gpg, tor.

• https://www.own-mailbox.com/

• https://github.com/Own-Mailbox/

Some of the improvements that can be done:

• Add an Administration panel to Own-Mailbox IHM
• Add support for GPG key server (publishing GPG key, and searching GPG keys)
• Add support for HSTS
• Study and implement new SMTP outging proxy method: port proxying
• Give information in Mailpile about which contact can be reached through tor or not.
• Multiple Email accounts on one Own-Mailbox

Students will select only one or two of these tasks, depending also on their skills and discussing them with the mentors.

• Confirmed Mentor: Pierre Parent

• How to contact the mentor: pierre.parent@insa-rouen.fr

• Confirmed co-mentors: Dashamir Hoxha (dashohoxha@gmail.com)

• Deliverables of the project: Code in Git-Hub that implements the selected tasks

• Desirable skills: Gnu/Linux system administration, Docker, Bash, Python, PHP

• What the intern will learn: Depends on what he already knows. Work on an existing project, read understand, and modify existing code. Make user-friendly interfaces. Cryptographic knowledge.

• Application tasks:

  • Install Own-Mailbox on a virtual machine with Vagrant.

  • Install Own-Mailbox and proxy with Docker.

• Related projects:

Clean Room for PGP and X.509 (PKI) Key Management

Description of the project: PGP is an important technology for a distributed online community like Debian. The PGP Clean Room aims to make it easier for new and existing participants to create and manage their PGP keys in a secure manner. An intern working on this project can focus on documenting the workflow, developing helper scripts to manage the filesystems for private key storage and developing a text-based UI using Newt (python-newt is preferred). Please also see Daniel's blog for the current status of this project.

• Confirmed Mentors: Daniele Nicolodi and Thomas Levine

• How to contact the mentor:

  1. subscribe to the debian-outreach list

  2. subscribe to the pki-clean-room list

  3. click here, complete all details, make sure you are subscribed to the relevant mailing lists before posting

• Confirmed co-mentors: Applicants are asked to find one or two other developers, possibly somebody you know personally or somebody else from the free software community, who will support this project.

• Deliverables of the project: making scripts and documents for the clean room project

• Desirable skills: Python, Newt, PGP, X.509, Cryptography, Shell scripting, User interface design

• What the intern will learn: Python, Newt, PGP, X.509, Cryptography, Shell scripting, User interface design

• Application tasks: try the project in KVM or VirtualBox. Make a small script that demonstrates your skills with Python (for example, making a window with python-newt).

• Related projects: GnuPG

Port Kali Packages to Debian

Description of the project: There is a ongoing work inside the pkg-security team to port Kali linux packages to Debian. This has a great impact on both distros as Kali is based upon sid (which gives them all the nice things that Debian does to its packages, like QA) and it packages the tools that are not present on Debian, this means that a lot of Kali packages are already "on the way" to become a Debian package. This project is meant to make Buster the best Debian release for pentesting ever. The work will consist of gathering information about Kali packages that are not present on Debian and would be useful to our users, then the student will package this softwares under Debian.

• Confirmed Mentor: Raphaël Hertzog

• How to contact the mentor: hertzog@debian.org

• Confirmed co-mentors: Gianfranco Costamagna <locutusofborg@debian.org>

• Deliverables of the project: NEW packages under pkg-security team.

• Desirable skills: Packaging for Debian and a good understanding of some programming languages for patches (Python, C and Ruby are used widely). Git is also needed.

• What the intern will learn: The student will see "in real life" how Debian benefits from its derivatives and vice-versa, how the pkg-sec team works and how we interact with upstreams.

• Application tasks: Prepare a NEW package.

• Related projects: https://www.kali.org/

Quality assurance for biological applications inside Debian

Description of the project: The Debian Med project has packaged a lot of applications for bioinformatics. In GSoC 2016 a big step for Continuous Integration of the most important applications regarding to the usage statistics provided by popularity contest was done. While it would be important to continue this effort to cover even more applications with sensible testing in this work some other tasks to enhance the quality of the Debian Med packages were uncovered. Besides testing single packages it needs to be verified that related sets of packages are playing well together and are packaged in a way that the user can expect the maximum performance out of the packages (for instance by ensuring that MPI features are used if available and the hardware features are used as best as possible).

• Confirmed Mentor: Andreas Tille

• How to contact the mentor: tille@debian.org

• Confirmed co-mentors: Lumin <cdluminate@gmail.com>

• Deliverables of the project: Enhanced packages for bioinformatics covering whole workflows of users as best as possible

• Desirable skills: The student should have a background in bioinformatics. Debian packaging skills are an extra plus but can be taught in the project run.

• What the intern will learn: Detailed insight into the bioinformatic tools inside Debian, Comparing and benchmarking biotools, Debian packaging skills, Optimising bioinformatics and other scientific tools

• Application tasks: Pick a bug out of the list 879619 , 879620, 879620, 890782, 890783, 890784, 890785, 890786, 890787, 890788, 890789, 890790 and try fixing it. This is on one hand proof that the students is able to understand Debian packaging and understands bioinformatics at a sufficient level

• Related projects: SummerOfCode2016/Projects/BioToolsTesting, SummerOfCode2017/Projects/Benchmarking

Reverse engineering radiator bluetooth thermovalves

Description of the project: Today's radiators can be controlled by programmable valves (thermostats), some valves sport a BLE (Bluetooth Low Energy) interface allowing a computer (or, more commonly, a smartphone) to program them "remotely" (at BLE ranges). The communication protocol is proprietary but can be reverse engineered, and it was. At Università di Milano (Italy) I supported a thesis that succeeded in completely reverse engineering (by sniffing BLE and by analyzing Android code). The thesis produced a GPL-licensed library in the form of a bunch of "single function" shell scripts that can be combined to create other (more complex) scripts for IoT applications and the BNF formalization of the protocol. This project proposal mainly aims at integrating the library into a full and well documented Debian package and (if possible) to port the software to a more modern language such as Go, Rust, Scala, Java or Ruby (but you can suggest more!). Moreover, it should produce a "best practice" guide for future developers interested in adding new valve protocols on the market.

• Confirmed Mentor: Andrea Trentini (Università degli Studi di Milano, Italy)

• How to contact the mentor: http://atrent.it

• Confirmed co-mentors: Giovanni Biscuolo

• Deliverables of the project (in random order):

  • debian package for the current (already developed) shell library
  • "best practice" guide for the reverse engineering process (packet analyzing, rev.eng. Android code, etc.) to add new valve protocols to the library, the guide should be as general as possible to let developers apply the process to other bluetooth devices (communicating with Android apps), NOTE: device firmware reverse engineering is NOT a goal of this project
  • porting to other (more modern?) languages such as Go, Rust, Java, Scala or Ruby
  • doc translation into english (this would be done by the mentor, don't worry)

  • integration into "domotics" projects such as home-assistant and openhab

• Desirable skills:

  • critical thinking

  • disciplined development skills

  • SCM tools (i.e. git, nothing else)

• What the intern will learn:

  • creating Debian packages
  • documenting code
  • unit testing
  • advanced shell scripting
  • BLE (Bluetooth Low Energy) protocols and related Debian packages
  • Go/Rust/Scala/Java/Ruby or other modern programming language
  • (maybe, depending on the language chosen) Object Oriented programming

• Application tasks:

  • git commit, merge, solve conflicts, etc.
  • command line operations (filesystem, processes, etc.)
  • create small shell script
  • NOT using the mouse

• Related projects:

  • the current state of development, in italian

  • Debian packages (some of these will be a dependency for this project): bluetooth, bluez-tools, wireshark and other bluetooth related packages depending on the future development choices

Recognize Debian-Med contributions via ORCID

The DebianMed team packages and improves many biomedical software applications. Many contributors are academics and we wish to increase the number of academics who participate in package maintenance and other team activities. We can achieve this by reporting their contribution in the same way reviewing for journals is reported: via ORCID profiles https://orcid.org/blog/2017/09/14/peer-review-orcid-update

Tasks

1. Collect ORCIDs of Debian contributors using the public API to connect them with their salsa.debian.org accounts.

2. On a monthly, quarterly, or yearly basis: generate a report of all contributions during that period and publish on Zenodo with correct metadata

3. The contribution is listed on the researchers' profiles alongside their other outputs.

• Confirmed Mentor: Michael R. Crusoe

• How to contact the mentor: https://salsa.debian.org/misterc-guest

• Confirmed co-mentors: TBD

• Deliverables of the project: 1. ORCID collection in salsa.debian.org 2. Initial report generated and stored in Zenodo and visible on ORCID profiles. 3. Regular report generation service installed on a DebianMed server.

• Desirable skills: Some web development, general coding skills

• What the intern will learn: At least 2-3 lines telling the applicants the skills they will develop and how they will improve Debian. Do not focus on the technologies, rather use something that could motivate the prospective interns to take on your project.

• Application tasks: some test tasks that you want your applicants to complete during the application process. This helps us make sure the applicants are motivated to do the project, and to assess mentor/intern communication during the application step.

• Related projects: links to some existing projects that are related.

A calendar database of social events and conferences

Description of the project: There are a wide range of social events and conferences for free software developers, including large conferences like DebConf or FOSDEM and smaller events like MiniDebConf and hackathons. As well as the dates of the events, there are also dates for various deadlines, such as submitting a talk proposal or applying for a travel subsidy. Some projects have started trying to gather data about these events, such as LWN Calendar, Agenda du Libre, Grical and Freie Termine. This project will involve improving one of those existing systems or developing additional systems to help communities advertise their events and to help people discover events.

The page SocialEventAndConferenceCalendars provides more details about the requirements and architecture for this project.

It would be desirable if the work you do is generic enough that it can be used in the free software community but also for other communities, for example, tracking the events published by student clubs at a university or local community events in the city where you live.

If you like visiting events yourself then this is an exciting project to work on.

• Confirmed Mentor: Balram Pariyarath

• How to contact the mentor: balbbrl@gmail.com

• Confirmed co-mentors:

• Deliverables of the project: one or more of the following (some tasks are Python, some are Ruby, some are PHP, you can choose):

  • enhancing the code behind Agenda du Libre

  • enhancing the code behind ?Grical

  • enhancing the code behind Freie Termine

  • making a plugin for other community web sites to maintain calendars within their existing web site (plugin for Discourse forums, MoinMoin, Drupal, MediaWiki, WordPress, etc) and export it as iCalendar data

  • developing web-crawlers to find iCalendar data on sites
  • developing tools for parsing iCalendar feeds and storing the data into a large central database
  • developing tools for searching the database to help somebody find relevant events or see a list of deadlines for bursary applications

• Desirable skills: Python, Ruby, PHP. Front-end web development skills may also be relevant (HTML, ?JavaScript, CSS)

• What the intern will learn: how communities announce and share data about their social events.

• Application tasks: learning about the iCalendar file format:

  • if you are a Ruby developer, send me (privately) your analysis and proposed solution for this bug

  • if you are a Python developer, send me (privately) your analysis and proposed solution for this bug

  • if you are a PHP developer, try to run the WPCall plugin for WordPress. Email me privately with your observations and a proposed enhancement to the code.

• Related projects: UltimateDebianDatabase, LWN Calendar, Agenda du Libre, Grical, Freie Termine, Github-iCalendar issue feed, Nagios-iCalendar, Debian UDD/BTS iCalendar, Agenda Livre (pt-br)

Virtual LTSP Server

Description of the project: LTSP allows computers of a LAN to boot through network from a single server. One of the benefits of this is for example to cut down the administration and maintenance time of a classroom of computers (instead of installing, configuring and updating each of them, we do it only once). It also works on VirtualBox, if a bridged adapter is added to an ethernet interface and the promiscuous mode is set to "Allow All".

The aim of this project is to build vagrant scripts that start up automatically a standard VirtualBox LTSP server, including tools for easy configuration and customization. This can be useful so that teachers can have their own LTSP server installed on their laptop (it works well with fat clients).

Another option is to install a LTSP server in a Docker container, using the Docker Scripts framework.

The student can attempt any of these tasks or both.

• Confirmed Mentor: Dashamir Hoxha

• How to contact the mentor: dashohoxha@gmail.com

• Confirmed co-mentors: (seeking for co-mentors)

• Deliverables of the project:

• Desirable skills: Familiarity with LTSP, VirtualBox, bash scripting, ruby

• What the intern will learn: How to build a LTSP server, how to use Vagrant, how to use Docker-Scripts

• Application tasks:

  • Install a LTSP server in VirtualBox following these instructions: http://dashohoxha.fs.al/ltsp-pnp/

  • Install a Moodle container: https://github.com/docker-scripts/moodle

• Related projects:

Wizard/GUI helping students/interns apply and get started

Description of the project: throughout the application process and first few weeks of programs like Google Summer of Code and Outreachy, applicants typically need to work through many things for the first time, such as creating their own domain name and blog, mail account with proper filters, creating SSH and PGP keys, linking these keys with a Github account, joining mailing lists, IRC and XMPP channels, searching for free software groups in their local area and installing useful development tools on their computer. Daniel Pocock's blog "Want to be selected for GSoC?" lists some of these steps with more details. This project involves creating a Python script with a GUI that helps applicants and interns complete as many of these steps as possible, in less than an hour. Imagine that a student has only just installed Debian, they install this script from a package using Synaptic and an hour later they have all their accounts, communications tools, development tools and a blog (using Jekyll/Git) up and running. After all that is completed, the script could also help the applicant to scan source code on their hard disk, identify their skills and try to help match them to relevant projects and mentors and maybe even help them prepare a project plan to cut and paste into the application form.

• Confirmed Mentor: Daniel Pocock

• Confirmed co-mentors:Urvika Gola Jaminy Prabaharan Pranav Jain Sanyam Khurana

• Deliverables of the project: a Python script, preferably distributed as a Debian package and uploaded to mentors.debian.net

• Desirable skills: Version control systems (Git), Python GUI design (?PyQt)

• What the intern will learn: the challenges that many new contributors face becoming engaged in the free software community and ways that we can help them.

• Application tasks: propose a Python function that uses a Python API to attempt one of the tasks in the description above.

• Related projects:

This project has been selected for GSoC 2018

Students

Mentors

See the Mentors page for full mentor contact details

Development tools and resources

We are still deciding about these:

Communication channels

Recommended mailing lists for all students

• debian-outreach
• debconf-announce
• debian-announce
• debian-devel-announce
• local mailing list in your city/country

Recommended IRC channels for students

#debian-outreach #debconf-discuss

Technical skills for students to become familiar with

• editing Debian wiki pages on MoinMoin wiki

• Python and related libraries
• Git
• vi editor
• basic Linux command line operations, environment variables and basic shell scripting
• IRC
• LVM
• Debian Installer
• Synaptic
• Unit testing
• XMPP
• Mail filters (e.g. Procmail, Horde, maildrop, Sieve)
• XML
• JSON
• DNS basics (A records, MX records, CNAME records, glue records)
• RSS
• iCalendar

Division of tasks between students

• to be decided

Some requirements

• design an icon
• create a web site for the Wizard (maybe just the wiki page to begin with)
• which mechanism will be used for managing translations?
• UI choices:

  • is ?PyQt the best choice?

  • Would Kivy work?
  • is there a framework that can support alternative front-ends or web?
  • Minkush's comment about using material design
• be more specific about modularization / architecture
• choose local data storage mechanism:
  • XML
  • JSON
  • sqlite
  • how to synchronize the data between multiple computers (desktop, laptop, etc)
• finalize workflow and related issues
  • can user move back and forth, jump around?
  • how to track which modules depend on others?
• develop wrappers for command line tools that don't have an API
• creating a news service for users of the wizard, e.g. email newsletter, RSS feed, or even NNTP?
• how to avoid problems with the Google promotions tab? can we fix it through an API?
• how to let users report errors and give feedback
• how to present links to things user can read next
• gamification ideas, points, milestones, badges, giving user challenges/problems
• how to build a community around this tool
  • how to integrate with other communities who use the tool for their new contributors

Broadcast data from GPredict for other Ham Radio Applications

Description of the project: add code to GPredict so that it can broadcast real-time data about satellite visibility, location and doppler shift to other applications using messaging solutions such as D-Bus and Apache Qpid or other asynchronous messaging solutions based on protocols like AMQP. Example use cases for this project: an SDR application like gqrx might use the doppler shift information to adjust the VFO in real-time, a Raspberry Pi attached to an antenna rotator might run an application to receive data from Apache Qpid and move the antenna or dish.

• Confirmed Mentor:

• How to contact the mentor:

  1. subscribe to the debian-outreach list

  2. subscribe to the debian-hams list

  3. click here, complete all details, make sure you are subscribed to the relevant mailing lists before posting

• Confirmed co-mentors: Jaime Robles

• Deliverables of the project: patches against Gpredict or similar applications.

• Desirable skills: Version control systems (Git), Build systems (e.g. autotools, cmake, Maven, Gradle), C programming, Python, asynchronous messaging/message queues

• What the intern will learn: messaging and inter-process communication (IPC) skills valuable in a range of environments ranging from a ham radio station up to large financial networks

• Application tasks: begin writing a patch for Gpredict or extending one of the Apache Qpid example applications to demonstrate your understanding of the topic

• Related projects:

Create a successor to the Telify plugin using WebExtensions

Description of the project: the Telify plugin for Firefox has not been updated for Firefox Quantum (WebExtensions API) and it doesn't have a free license (it is CC-BY-ND so it can't be included in a free operating system like Debian's main archive). The upstream web site has also gone away, it can be found here in the wayback machine / archive.org. There are similar projects like Skype-for-Chrome extension and TBDialOut for Thunderbird. Your goal is to explore the source code of all these extensions and develop a new extension using the ?WebExtensions API so that it will work in the latest versions of Firefox Quantum and Google Chrome.

• Confirmed Mentor: none at present - please check again shortly as we are discussing it but if a mentor is not confirmed it may not go ahead

• How to contact the mentor:

  1. subscribe to the debian-outreach list

  2. subscribe to the Free-RTC discussion list

  3. click here, complete all details, make sure you are subscribed to the relevant mailing lists before posting

• Confirmed co-mentors: Applicants are asked to find one or two other developers, possibly somebody you know personally or somebody else from the free software community, who will support this project.

• Deliverables of the project: a Firefox plugin similar to Telify

• Desirable skills: Version control systems (Git), Build systems (e.g. autotools, cmake, Maven, Gradle), browser plugin development (Firefox or Chrome), ?JavaScript

• What the intern will learn: browser plugin development, releasing a plugin, integration with telephone systems, free software licensing issues

• Application tasks: find the source code for Telify and put it into a new repository on Github. Try to start creating a new ?WebExtensions plugin in Github.

• Related projects:

Open Agriculture Food Computer

Description of the project: The Open Agriculture (Open Ag) community is building the Food Computer using Raspbian in the hardware and web-based tools for management. Students could potentially work on any part of the stack depending on their skills. Access to the hardware is not necessary for every aspect of this topic although if you have the possibility to access a Food Computer or build one in a local hackerspace or makerspace that may be helpful but to comply with GSoC expectations, students must spend the bulk of their time on the software-side of this project. As explained by Caleb Harper in the TED video, the project aims to apply principles from the open source movement to agriculture. The Debian project, as well as being the base for the food computer platform, has a long history of living the free software ethos and an important aspect of this project is to look at how Debian principles and practices could help solve problems in the development, deployment and use of food computers.

• Confirmed Mentor: none confirmed

• How to contact the mentor:

  1. subscribe to the debian-outreach list

  2. subscribe to the Open Agriculture forum

  3. post a message in the forum introducing yourself

• Confirmed co-mentors:

• Deliverables of the project: to be negotiated with the mentor before submitting your proposal

• Desirable skills: Version control systems (Git), Build systems, Embedded systems using Raspbian, networking and cloud, web

• What the intern will learn: learning about free software principles and practices from the Debian community and applying them to the challenges of agriculture

• Application tasks: propose a pull request against one of the projects in Github

• Related projects:

Recursively building Java dependencies from source

Description of the project: Many Java projects use a combination of JAR file dependencies from other Java projects. In some cases, third party JARs are also used to provide custom tools for the build process (e.g. custom ant tasks or maven plugins). Can the entire heirarchy of dependencies and build tools and their transitive dependencies all be built from published source code? If not, we can not be certain that a particular dependency JAR is clean, free of malicious code, easy to fix or adapt for future Java versions. This project aims to develop automated mechanisms for cataloguing the portfolio of Java libraries on sites like github and the Maven Central Repository, creating a database of dependencies, mirroring their source repositories, removing binary JARs from their source trees and trying to build them using symlinks to JARs found in Debian or built by the same recursive process. This project may be partially automated using a tool like Jenkins. Data for some of the dependencies can be harvested from Maven pom.xml files.

• Confirmed Mentor: none at present - please check again shortly as we are discussing it but if a mentor is not confirmed it may not go ahead

• How to contact the mentor:

  1. subscribe to the debian-outreach list

  2. subscribe to the debian-java list

  3. click here, complete all details, make sure you are subscribed to the relevant mailing lists before posting

• Confirmed co-mentors: Pranav Jain

• Deliverables of the project: the ideal outcome will be a full suite of tools for automating this process: a user could insert the name of some JAR in a form, the tool would study the JAR, find the source, recursively build everything and inform the user whether or not the JAR they want to use can be built without any dependency on any JAR that is missing source code. Building individual components to help achieve the aims of this project would also be satisfactory. The student is not required to automatically correct individual Java projects that are completely unsuitable for automated builds (e.g. projects that can only be built in Eclipse).

• Desirable skills: Java build tools (ant, maven, jenkins) and source repository tools (git, subversion)

• What the student will learn: Effective use of Java projects involving a large number of dependencies. Using automated systems to orchestrate commands that are normally invoked manually.

• Related projects: please see the work already completed on this topic by Andrew Schurman in GSoC 2014 (his application page, progress and Github repository