Revision as of 22:35, 25 September 2015

Projects for Outreachy December 2015 to March 2016

Key Dates

• September 29 application process opens
• November 2 application deadline
• November 17 accepted applicants announced (Mozilla intends to announce earlier due to travel and hardware logistics)
• December 7 - March 7 internship dates

Application Process

Applicants and mentors, please review the Outreachy Eligibility and Application Information page to learn more about applying for Outreachy.

Projects

Battery Friendly Platform Networking Deadline Scheduler

Mentor: Patrick McManus

Battery performance for networking is strongly influenced by the number of times the radio is brought into a higher powered state for transmission. Data that is batched together minimizes the number of power-up events and extends battery life. Normally HTTP requests are dispatched as soon as possible, but by strategically delaying ones that do not have an impact on user interaction this batching can be acheived.

The Intern will add an optional deadline parameter to the Gecko networking interface. Callers that specify a deadline allow their transactions to be delayed for some period of time in order to coalesce and intelligently schedule it with other resource events. The navigator Beacon API is a an obvious candidate to use this functionality.

The intern needs to be familiar with C++ for the platform code, and some exposure to javascript for the test infrastructure would also be helpful.

Enumerate (and Dockerize) the tests! (Quality Assurance)

Mentor: Karl Thiessen

Our intern would be responsible for helping the team create Dockerfiles and images for as many of the deployment/functional tests as possible, across all of the many repositories Cloud Services QA works with. Along the way, the intern would help clean up and update documentation, and complete an inventory of all of our repositories and their status (deprecated, active, or healthy) based on how often the tests get run.

This project would require the intern to take a short tutorial in how Dockerfiles are prepared, but no previous Docker experience would be necessary. The enumeration part would require the ability to navigate GitHub and a willingness to ask members of the team questions about how and when their tests are running.

Also, the intern may wish to run the tests as they are Dockerized, which would require some experience with Docker (and possibly AWS) and some software engineering inclination.

Kinto — Make instances discoverable

Mentor: Alexis Métaireau

Details

The Kinto project aims to bring storage instances to everyone, attached to their Firefox Accounts. It actually supports multiple authentication schemes, but FxA is integrated with it, and that is part of the solution we want to deliver.

Currently, Kinto is thought as a centralized server: there is one instance, and everyone authenticates on this instance. Items are shared between users of a same instance.

This doesn't resonates well with multiple goals we have: scalability is harder when there is one endpoint, and it's also not interoperable.

For instance, imagine Alice and Bob. Bob is using Mozilla's servers to store his data, whereas Alice deployed her own Kinto instance.

There are different use cases:

• Alice wants to use Routina, an application that stores its data inside a Kinto instance. As such, Routina needs a way to discover where it should store its data, and send the requests to this server;
• Bob and Alice want to collaborate on a set of data (think about a shared expense webapp). There should be a way for Alice to host everything and grant access to Bob to her data. The webapp should be able to use the correct server.

Here are the different steps that could allow these scenarios:

• At the moment they authenticate, the client detects the email address used, and relies on the domain part to do a Web Finger request on the domain (*) and for the specified user.
• In case the identified server doesn't support WebFinger, it uses a central repository to lookup where the Kinto server is located.
• Once the Kinto server located, all requests should be issued against this server.

(*) It is also possible to use the same mechanism to discover the FxA endpoints. But as FxA isn't a federated protocol, users from one FxA realm would need to be accepted explicitely by the Kinto server, in its configuration.

In terms of code changes, here is what it looks like (rough step by step):

• Update the Kinto.js client to find the server location. It should first rely on WebFinger;
• Create a central repository of server locations. This could be contained in the FxA profile server or in a central Kinto collection;
• Update the Kinto.js client to fall-back to this central repository in case no Web Finger exists;
• Investigate on ways to store this information directly in the web browser. It could also be configurable by the JavaScript client (with

an UX that looks like what Remote Storage proposes).

• Work on the first user experience: how can client learn they can chose which server to use?
• Ship it!

To get started on Kinto:

• Read the kinto documentation, especially tutorials
• Join us! Work through our communication channels chapter which includes joining the Kinto development mailing list and joining the #storage channel on irc.mozilla.org

Open Source Designer, Mozilla Foundation

Mentor: Ricardo Vasquez

"At Mozilla Foundation, we spend a lot of our energy promoting web literacy. We’ve been hard at work the past year building innovative tools, supporting communities, teaching, learning, and shaping the environments in which the open web is made possible. We want everyone in the world to create, not just consume, the Web around them.

As an Open-Source Designer, the applicant will be immersed in the world of products such as Thimble and Webmaker for Android, communities such as Mozilla Learning Networks and Mozilla Hive groups, and initiatives such as Mozilla Advocacy and Fundraising.

The intern will:

• Approach design through an iterative process with our growing user base and community
• Design and implement interfaces and collateral work for our products and initiatives
• Illustrate collateral work for our products and initiatives
• Create and conduct user testing research to generate insights of our products
• Bridge the gap between the behaviour we want users to take and the interface that gets them there
• Prototype and implement work using HTML, CSS, and JavaScript "

SUMO - Work on a tutorial or training tool for new technical writers

Mentor: Joni Savage

Mozilla’s Support site (SUMO) provides around-the-clock help for 30 million users a month through thousands of knowledge base articles. We rely on the community to keep the knowledge base up to date with each release. While there’s growing interest in contributing to the knowledge base, there’s also a learning curve. Here’s where you come in.

SUMO is looking for someone with an interest in storytelling, teaching, writing, design or video to help us transform our lengthy training documents into fun, interactive and effective training tools to empower new contributors who have a wide range of skills.

You will work closely with Joni, the content manager, along with our community to brainstorm learning activities, create storyboards and outlines for training guides, design and research interactive and intuitive contributor tools, and write friendly and effective copy. Got additional ideas? We’d love to hear those too.

To get started:

1. Look through this page.
2. Get in the mindset of a new contributor. Pick out what you think is important information from the page in step #1 and turn it into a mini tutorial (or an outline for a tutorial). This can be an infographic, video, slideshow, storyboard or any format of your choice.
3. Send your tutorial or storyboard to Joni Savage along with an explanation.

Servo: Complete implementation of Fetch standard

Mentor: Josh Matthews

Details

Servo is a brand new web rendering engine written from the ground up in Rust. This allows us to try implementing old web features in new ways, including the underlying model for performing network requests inside the browser. The Fetch standard defines a series of steps to ensure proper security checks are performed when necessary, and we want to try using it everywhere in Servo!

A partial implementation of this model already exists in Servo, but there are large pieces missing. You will be responsible for the following:

• integrating our existing network request code with the HTTP-network-or-cache-fetch step (see prior art)
• moving cross-origin security checks out of callers and into the fetch implementation
• converting existing code that makes network requests to use the new fetch APIs
• writing tests to ensure specification conformance

Servo is written almost entirely in Rust; besides some diversions into HTML and JavaScript for reading and writing tests, this project will require you to work exclusively in the language. Do not fear! We regularly receive contributions from first-time Rust programmers, and it's a great motivator to gain experience in a new low-level language. There will be many opportunities to practice reading, understanding, and refactoring existing code, in addition to writing new implementations when necessary. Furthermore, you will gain proficiency in reading web specifications.

What you can do to get involved:

• Clone and build the code
• Find an issue that looks interesting (ones with the E-easy label recommended as a first step)
• Leave a comment stating that you're working on it, then get to work
• Feel free to introduce yourself on IRC (#servo) or on the mailing list

TLS Canary and Security Dashboard

Mentor: Anne Van Kesteren

TLS Canary is a tool created and used by the Firefox development team to gather connection statistics on various Firefox branches, using large lists of top SSL sites. This information, along with live Firefox telemetry, helps us detect regressions, assess risk, and drive decisions on security feature development.

The intern working on this project will be introduced to some of the components that help us gather this data. This includes Firefox telemetry probes, bash scripts, XPCShell programs written in JavaScript, and client-side web pages for reporting results.

The intern should have a desire to create new features, and an improved dashboard experience for TLS usage in general.

Requirements:

• Strong JavaScript knowledge
• Desire to learn about SSL and security
• Ability to build usable web applications with HTML and CSS
• Familiarity with bash programming and Python

An existing background in security is a plus.

This internship will involve extending the capabilities of TLS Canary and creating a dashboard to monitor other areas of Web Security.

Visual Design with Research Data

Mentor: Ilana Segall

We have a huge opportunity for a lot of unexplored data from various projects to be represented visually, both for research purposes and to be displayed in other parts of the organization. We have data on search, participation in heartbeat surveys, and months and months of telemetry that are rife for exploration. Our ideal candidate would have some coding experience and the desire/ability to learn javascript and the d3 visualization library. Someone with an element of design interest would also be preferred so that we can work on the most effective data vizzes possible. The intern would also have the ability to work on executive-facing work including infographics and slide decks.