We have an excellent list of projects, and I’d like to thank all the project mentors for taking the time to work with our students.
1. Review Board
Review Board is a powerful web-based code review tool that helps developers do peer review as they write code. Review Board is used by thousands of software companies including Twitter, Yahoo, and VMware, as well as many open-source projects like Apache and KDE.
- Making improvements to Review Board’s extensions infrastructure, which allows third party developers to build features that aren’t generic enough to be part of the product.
- New kinds of integration with other services, such as deeper bug tracker integration, an adapter for GitHub pull requests, or allowing users to log in using Mozilla Persona.
- Reworking parts of the UI to work better on touch devices like tablets and smartphones.
For a full list of project suggestions, check out our wiki: Student Project Ideas
For more information, see the project web page at https://www.reviewboard.org/, or our students demo videos at https://www.youtube.com/channel/UCTnwzlRTtx8wQOmyXiA_iCg/featured
Umple is an open source toolkit whose objective is to merge UML modeling and programming into a single activity. Umple can be used in several ways: It can be used as a textual language for UML. It can also be used as a programming-language pre-processor, allowing UML concepts like associations and state machines to be added directly to Java, C++, and PHP. In addition, Umple allows drawing UML diagrams online and generating code directly from those diagrams.
It is the goal of the Umple team to have large numbers of programmers and modelers incrementally adopt Umple. The barriers to entry are low, since using Umple can be done in a minimal way, without disrupting the existing model or code. Umple is an open-source project hosted on Github. You will have the opportunity to learn some or all of the following:
- Model-driven design using UML
- Test-driven development using JUnit
- Compiler design including parsing and code generation
- Web site design (of the UmpleOnline tool)
- Eclipse plugin development (of the Umple plugins)
- A variety of other libraries and tools
- Agile open source development with continuous integration
The exact set of skills you will employ depends on the task(s) you choose to work on.
3. Firefox debugger
Within the past two years, the Firefox Debugger team released a new UI that was developed on Github and written in React. Today it has a modern web stack (React, Webpack, Babel) and is one of the most widely contributed to Mozilla projects.
With this project, we want to continue improving the debugger’s user interface and accessibility, ensuring an enjoyable user experience for all developers. We also want to continue the relationships we’ve created with major framework developers, like React, Ember, and Angular. We hope that our framework integrations will make the debugger feel more like a React or Ember debugger than just a JS debugger.
Some examples of framework and library integrations include:
- Highlighting framework frames in the call stack.
- Showing framework components in the source tree.
- Previewing library objects on hover.
Some examples of user experience improvements include:
- Updating user interface elements to match changing Firefox brand and design updates.
- Ensuring icon and symbol integrity throughout multiple components.
- Modernizing the debugger search interfaces.
- Improving accessibility so that developers of varying backgrounds can enjoy a great user experience.
The examples cited above, as well as a host of other opportunities to improve and extend the Firefox Debugger, will provide an exciting learning experience for the student.
Formulize is a tool for making data management systems on the web.
Formulize has extensive support for modelling workflows, so that organizations can customize how users interact with the data that Formulize is managing. It is aimed at “power users” in not-for-profits and other organizations without large IT departments and resources, empowering them to create systems that would otherwise require custom programming to deploy.
The most basic operation in Formulize, is the creation of forms. Administrators can specify what elements should appear on the form, and also how different groups of end users should be able to interact with the form. From there, administrators can make custom screens that control how lists of entries in each form are shown to end users.
Administrators can also control how different forms relate to each other, similar to describing table relationships in an ERD. These relationships then govern how data is queried from the database, enabling screens to display complex sets of information to users, rather than just entries from a single form.
Formulize can work as a standalone application, installed on a web server. Formulize can also be embedded within any PHP-driven web application on the same server where it is installed. A Drupal module has been created that supports extensive integration with the Drupal content management platform, including single sign-on for users. Integration plugins for WordPress and Joomla have also been created (by previous UCOSP students!).
Who uses Formulize?
Formulize is used by organizations around the world, for a variety of purposes, from tracking the status of housing renovations, to recording the activities of wilderness rescue teams. Formulize was created by Freeform Solutions, a Canadian not-for-profit organization that helps other not-for-profits with IT.
How is Formulize built?
Because it is a tool that you use to create other systems, rather than a tool that does something for end users by itself, there is a high degree of abstraction throughout the codebase, especially the parts that interact with the database. The code has to read configuration information specified by the administrators, and use that to dynamically generate all operations, including database queries.
The newer parts of the codebase employ some object orientation. Older parts remain largely procedural. The codebase is maintained on GitHub. Over the years, Formulize has developed a specific process for managing code, tests and documentation all through our GitHub repository. Our the tests are run automatically by a continuous integration system, based on Travis-CI and Sauce Labs. Students will have exposure to this process as part of contributing to the Formulize project.
What will students learn?
Students will have extensive exposure to PHP of course, and related web technologies. There are several priority areas of work at the moment, which students may participate in depending on aptitude and interest: the Selenium-based functional testing environment needs updating to fix failing tests; we would like to make it possible to copy/clone elements from one form to another so users don’t need to recreate the same settings manually; we would like more automatic handling of creating database relationships between forms (one-to-one, one-to-many) and a better user interface for managing relationships.
Learn more about Formulize
Browse the GitHub repository: https://github.com/jegelstaff/formulize
Video tutorials for using Formulize (the full series is about three hours, but you can skip around between various videos at your leisure): http://formulize.org/formulize-workshop
Learn about our version control and continuous integration process: http://www.formulize.org/developers/
4. Safe Browsing and Tracker Prevention
Project keywords: Data Mining, Tracking Protection, Machine Learning, Web Technologies.
Current work on the Mozilla Overscripted corpus is aimed at developing a prototype method for online tracking interventions using large scale data analysis and Machine Learning. Current state-of-the art tracking protection methods largely rely on heuristic approaches or (semi) manually updated white/black lists. When it comes to measuring the efficacy of such approaches, both the client-side experience and the actual efficacy at disrupting tracking is difficult to asses.
This project will continue to extend the exploratory analysis into the potential for real-time and element-wise tracker protection that can operate independent of a whitelist/blacklist paradigm by offline training of classification models that are pushed to the client so as to deliver tracking protection without compromising client privacy.
This information leakage criteria will inform a browser-loaded webextension to help users attain a general understanding of what Tracking Technologies are prevalent on today’s Web. Then we will use the combined view of the crawler data and telemetry form the webextension to evaluate various strategies for dynamic tracking protection models.
Sarah Bird, Daid Zeber, Victor Ng, Luke Crouch, Martin Lopatka (Mozilla)
6. Firefox for iOS
Mozilla will be shipping version 8.0 of Firefox Focus for iOS sometime in Q4. We are still filling out what items will be in version 8.0, but you can see the current items here. One large feature is to add multitasking (i.e., tabs) to Focus iOS. Some other items we are considering adding are Search Suggestions and a hook into our A/B testing platform Fretboard and further integration with new iOS12 features. We contemplate there would also be bug fixes and other smaller feature requests in 8.0.
As part of this project we expect the engineering team would be part of our usual Agile Release process, which include participating in triage, sprint planning, localization, and QA.
Susheel Daswani, Stefan Arentz, Barbara Bermes, Vesta Zare
7. Rewrite the Firefox internal configuration user interface (“about:config”) using Web technologies
Typing “about:config” in the address bar brings users to an internal configuration page where several settings can be changed. These settings occasionally need to be modified on end user machines to troubleshoot compatibility and performance, and can be used to enable or disable experimental features. Some persistent data is also stored here, and this page allows Firefox engineers to see and modify this configuration database during feature development.
This is a chance to:
- Improve user interface used daily by thousands of people.
- Write code in a high-quality, real-world production environment.
- Use test-driven development, writing automated tests alongside the production code.
- Work alongside the in-house development team with code and design review process.
- Improve the usability and usefulness of the configuration user interface.
- Use the Firefox design system to improve the look and feel of the page.
The code writing is a small part of the task. Given the nature of packaged software, students should expect to spend significant time studying the architecture of the browser, writing small proofs of concept, communicating with other team members and the community, keeping ongoing documentation, and multitasking through different aspects of the project at the same time.
Paolo Amadini, Brian Grinstead, Dave Townsend
8. Firefox Code Coverage
Code coverage can be used for many purposes. At Mozilla we have great ideas of how to use code coverage to better the quality of each version of Firefox and to make developers job easier by providing more data and easier testing.
We have two long term goals we would like see implemented:
- Run a code coverage run every day on our infrastructure (linux64 only) for all unittests and generate a report that can be compared against a previous report.
- Customer: Release Management will use this to spot trends of increased or decreased coverage by module (top level directory in the source tree) and work with module owners/managers to understand risks and plan future work.
- Collect code coverage per test for each of the unittests we run and store the data in active data.
- Customer: Developers would be able to determine what unittests they need to run based on the changes in their patch
- Customer: Release Management will be able to see code coverage of a new patch that they are considering uplifting to a beta/release version of Firefox.
For the purposes of the 2016 Fall UCOSP program we will start by delivering goal #1. In order to achieve this we will need to:
- Ensure we can build and run Firefox with c++ code coverage built in (build work, taskcluster work)
- Ensure we can collect coverage from all test suites and proper gcda and gnco files are generated (taskcluster work, harness work)
- Retrieve all coverage data files and merge them together into a single lcov report (taskcluster work, lcov toolchain work, possibly docker image work)
- Determine hosting requirements for storing nightly reports and hosting the data, and the optimal way to store/serve the data (webserver, database, activedata)
- Ensure we can easily compare one report to another to easily highlight differences (python script/tool, web interface)
- Ensure we have coverage data broken down by module- top level directory in the Firefox source tree. (validating data, organizing report/queries/storage)
- Schedule a nightly run of code coverage builds+tests in a scheduler (taskcluster)
9. Firefox React debugger
Last year, the Firefox Debugger team decided to re-write the UI on Github with React. Today it has a modern web stack (React, Webpack, Babel) and is one of the most widely contributed to Mozilla projects.
With this project, we want to take the next step and build on our relationships with the major framework and library teams to build the kind of tools that we would have liked to have while building the Debugger. We hope that these integrations will make the debugger feel more like a React or Ember debugger than a JS debugger.
Some examples of framework and library integrations include:
- Highlighting framework frames in the call stack.
- Showing framework components in the source tree.
- Previewing library objects on hover.
Highlighting framework frames in the call stack will let us tell the user what frameworks are doing when the application pauses. For instance, if the user pauses while making an API call, the debugger call stack can show the user that the application is updating the user record because the “save” button was pressed.
Showing framework components in the source tree will let users see their application’s framework types. In the case of React and Redux that includes (Components, Actions, and Stores). We think this view can be more valuable than just seeing source files because it is closer to how developers think about their applications. It also provides us a way to link to other framework information in the future.
Previewing library objects will let frameworks format the objects the way they were intended to be seen. For instance, the most important data in a React component is the props and state. We hope to give frameworks control over how users see their framework objects because we think it paves the way for future integration points in the future.
These features are exciting because it shows that when we work closely with libraries and framework teams, we can build new types of tools that help developers every day.
10. Firefox Developer Tools – Inspector inline editor widgets
In the Inspector, we will be working on a number of tools related to various CSS properties, Layout and Font inspection. Some examples of these new tools and features that previous students have worked on included:
- CSS Grid Inspector
- Box Model Layout panel improvements
- CSS Variables Inspection
To read about some of the accomplishments from previous UCOSP students, visit https://hacks.mozilla.org/2017/06/new-css-grid-layout-panel-in-firefox-nightly/
For the Inspector, we want to continue to working on better CSS Layout tooling such as CSS Grids and z-index inspector. In addition, we are aiming to implement more visual editors that will help developers and designers with debugging and editing complex CSS properties visually.
Since CSS is very declarative by nature, we can provide tools that are commonly found in digital design tools, such as Adobe Photoshop and Illustrator, and Sketch, in order to bridge the learning gap of new developers and designers learning CSS. This would allow them to edit various CSS properties such as box-shadow, clip-path, gradient, filters, etc without knowing what the properties are.
Our goal is to help developers and designers come into the Inspector and be able to easily edit and learn HTML and CSS, and make changes to their web pages and eventually provide better authoring tools to help them also extract these changes.
11. Mozilla Taskcluster Resource Monitoring and Management
The Taskcluster team at Mozilla builds a platform for performing the continuous integration of the Firefox web browser. We currently perform many of our operations using cloud resources, primarily the AWS suite of tools. We would like to expand our monitoring and management of our AWS resources. The first area we’d like to focus on is EC2 (VMs as a service).
We have a component that manages our EC2 account called ‘ec2-manager’. In this service, we’d like to monitor things like how many instances we have, how many spot requests are open and how many EBS volumes we have. We’d like to feed that into our standardized reporting tool called ‘statsum’ so that we can spot trends and highlight issues.
We’d also like to have tools to monitor for unused resources which cost us money or are causing our account to be messy. Examples are reporting on machine images (AMI) snapshots which haven’t been used in a long time, EBS Volumes which aren’t attached to anything and SSH key pairs.
A third thing we would like to do is monitor the reasons for instance termination and spot request outcomes. This can be used to gather information on the health of EC2, since the Amazon provided means of determining health are incomplete.
The final component would be to introduce management of resources. The main resource here is Security Groups for EC2 instances. These are a white list based set of firewall rules which can be attached to EC2 instances. We’d like to have facilities for automated management and monitoring for them. We would like to have checks in place to ensure that we are alerted if any changes from the expected security group settings are made.
12. Swift Support in WALA
Apple is a dominant player in the mobile space, and Swift is its new language for writing mobile apps. While Apple provides tooling based on LLVM, that is low-level machinery that is not readily usable by researchers working on program analysis at a higher level. Current research frameworks such as WALA and SOOT have little support for Swift, while, on the other hand, they provide extensive support for Android, even its latest versions.
The result is a plethora of published tools for Android, e.g. Flowdroid, Scandroid, Stringoid, DroidInfer to name a few, and a relative dearth of tools for Apple platforms. Given the popularity of Apple products and that wealth of published work for Android based on available infrastructure, we believe that lack suitable Swift infrastructure is a significant impediment. So support for Swift in a major platform like WALA would enable a wide range of new work.
Apple’s security model is significantly different from that of Android, for example; similarly Swift is rather different from popular languages on Android, especially at the type system level. It would be interesting to understand how these aspects affect program analysis, and analysis infrastructure is a prerequisite for such investigations.
There has been some ongoing work on Swift support since the WALA hack-a-thon held at PLDI 2017 , where the hack-a-thon participants implemented some basic level of functionality for people to explore call WALA from within the Swift compiler.
Concrete project idea
Evaluate and extend Swift call graph construction in WALA for some open source Swift code, and create any needed special-purpose policies to avoid precision loss in the face of advanced Swift features.
- Karim Ali, University of Alberta
- Julian Dolby, IBM T. J. Watson Research Center
- Good knowledge of compilers and/or some knowledge of the LLVM infrastructure
- Knowledge of Swift is beneficial
- C/C++ programming
- Java programming
- Knowledge about program analysis is a plus.
13. Safe Browsing and Tracker Prevention
Current state-of-the art work on safe browsing and tracker prevention largely rely on heuristic  approaches or (semi) manually updated white/black lists . When it comes to measuring the efficacy of privacy and tracking protection service, client-side performance is difficult to asses. Using web crawler technology to study the incidence and prevalence of tracker code also has limitations in terms of the portion of the web that can be seen.
We would like to gather a labeled dataset to guide development of (rule-based) classification of page elements in real time. The aim would be to prevent tracking code from executing while minimizing page breakage. The classifier should be evaluated such that it generalizes well to new pages without the need for a black-list/white-list paradigm.
The project will combine a small set client-side measurements for a group of opt-in users’, measured during unperturbed web browsing. The set of metrics to be collected in this context will be discussed during the September UCOSP sprint with the first full team deliverable being a finalized list of measurements to be delivered on or before October 18th.
Measurement of features indicative of fingerprinting should be the primary focus with additional features relating to the user experience also considered; for example: page breakage, load-times, layout disruption, etc. Some starting points of projects active in this technology space are here: chameleon, panopticlick, cliqz.
Design and Deliverables
Collaboration on this project between Mozilla and openWPM maintainer Steven Engelhardt will allow us to combine this information with a broader view of such API calls by detecting their occurrence in a large corpus of crawl data. One team member will be tasked with interfacing the classifier trained on our client data with the openWPM platform.
In order to improve upon current methods for assessing anti-tracking performance, a criteria of “information leakage” will be developed and articulated in the context of reference statistics derived from the crawl data. This quantity will relate to the distinctiveness of a particular browser visit to a page in a feature space defined by the information accessible by the page.
The data derived from this two-prong collection will generate a semi-labeled dataset with which to train a classifier that does not rely on black-list/white-list resources. Assuming a sufficiently level of performance is achieved, such a classifier could be used to generate and update a black-list by periodic crawls or perform tracking-blocking in real time if deployed in a web extension. A reach goal of this project will be to investigate the feasibility of detecting and clocking first-party tracking efforts, which are a growing concern as a small number of entities gain ever-larger presence on the web.
Modular components (student roles)
- Data analytics and classifier implementation: In order to make use of the data collection efforts from both the client-collection and crawl portions, a feature selection procedure must be carried out. This will be performed by a fourth team member. This task may consider the additional context of information we can get from project Fathom. The features selected here will form the input space of a classifier that will assign a label of safe/not-safe to specific page elements. The efficacy of classification strategies will be evaluated against the information leakage metric described above. A substantial validation step will be required here to prototype and evaluate various approaches to this problem that are expected not only to prevent fingerprinting, but also (where possible) preserve page functionality.
Project lead: Martin Lopatka (Mozilla)
Differential Privacy expert: Dave Zeber (Mozilla)
TrackWare specialist: Luke Crouch (Mozilla)
OpenWPM and browser fingerprinting specialist: Steven Engelhardt (Princeton)
 privacybadger, adblockplus
 disconnect.me, ghostery, uBlock
MarkUs is a web-based grading tool built with Ruby on Rails. The primary goal of MarkUs is to make it easy for graders to read and annotate students’ code. Graders also fill in a marking scheme or rubric created by the instructor. Annotations may be saved for later reuse. Students submit their code using either the web interface or using standard Subversion tools, and can form their own groups when allowed by the instructor. We are also working towards completing and integrated testing infrastructure that allows students to run instructor created tests on their submission and get realtime feedback. This summer we have been working on adding a feature to allow students to review other students’ work.
Students working on MarkUs will learn basic web application development technologies using Ruby and Rails. MarkUs is hosted on Github so students will become familiar with Git and the process we use when working on the code. Because MarkUs is used by several thousand students in more than 4 universities (on 3 continents!), we take code quality seriously. All code submissions go through a code review, so the first task that students are asked to complete is fixing a trivial bug so that they become familiar with the code review process.
Students working on MarkUs need to be able to work in Linux either natively or in a virtual machine. As the fall term comes to a close, we are putting together a list of the next projects.
More information: https://github.com/MarkUsProject/Markus
15. Firefox Developer Tools – 3D Z-index Tool
Firefox Developer Tools allow developers to inspect HTML pages to better understand and debug how the structure of a web page translates into an image on the screen. Ultimately the image that is rendered to the screen is 2d, but it is composed of a variety of elements on the screen including blocks of color, text, images, and video. Conceptually these elements can be represented as a 3d document where the z-index of each element determines its height in the space.
The higher z-indexed elements end up blocking the elements with lower z-indexes. However, this can become more complicated with the different types of positioning like ‘absolute’, ‘relative’, and ‘fixed’ positioning. Users can quickly become confused and struggle with stacking elements correctly.
The goal of this project would be to create a tool that intuitively lets users understand this overlapping structure of their webpage by visualizing it in three dimensions. Firefox devtools used to have a 3d debugging tool called Tilt, but its focus was on showing the nesting structure of a webpage, rather than the z-index stacking behavior. That tool is also no longer shipped with the Firefox devtools as it does not support multiprocess Firefox.
Pulse (https://pulseguardian.mozilla.org/) is an open message bus that carries messages about all sorts of automated systems at Mozilla, including detailed information about the status of Firefox builds and tests. TaskCluster uses pulse extensively behind the scenes. PulseGuardian is a part of Pulse which allows anyone with an email address to create credentials that allow reading and creating Pulse messages. However, these credentials are permanent and thus not suitable for transient uses such as web-site users or ephemeral computations.
The UCOSP project will involve understanding the problem space, proposing and agreeing on a design (including security concerns), and then implementing that design.
Mylyn’s task-focused interface reduces information overload and makes multitasking easy. Mylyn makes tasks a first class part of the IDE, integrates rich and offline editing for ALM tools, and monitors your programming activity to create a “task context” that focuses your workspace and automatically links all relevant artifacts to the task-at-hand. This puts the information you need at your fingertips and improves productivity by reducing information overload, facilitating multitasking and easing the sharing of expertise.
Mylyn is written in Java and built on Eclipse, and it’s included in most Eclipse downloads, so students will have the chance to work on a tool that is downloaded over a million times every month! We have a number of projects for students to work on, including the following:
- Task editor enhancements a. inline refresh as values change on the remote system b. provide a way to see the previous value of changed attributes, using the Eclipse compare framework to diff text attributes c. more frequent refresh of the active task.
- Mylyn context a. Improving the support for automated management of breakpoints as part of task context b. Providing a way to restrict a search to files in the task context.
- Improvements to the Hudson/Jenkins connector which provides access to builds from CI systems from within Eclipse.
- Improvements to the Gerrit connector which provides access to Gerrit code reviews from within Eclipse
Students are also welcome to contribute their own ideas for consideration.
Pontoon is a localization tool by Mozilla, designed for producing high quality translations. Its core asset to support this goal is translation within the actual web application, presenting real-time translation preview, context and spatial limitations right in front of you.
To move translation quality support further ahead, we’d like to design the translation review workflow that will: * help reviewers identify and categorize translation issues, * allow translators to learn from the received feedback from translation reviewers and * empower team managers to evaluate performance and progress of their team members.
At the core of this process will be the Multidimensional Quality Metric (MQM) standard, which is a framework for identifying and categorizing translation issues. Your task will be to create a set of 4 different UX prototypes of the translation review workflow in Pontoon.
By contributing to Pontoon, you will: * be taught how to design user interfaces to maximize the usability of software product, * become familiar with the basics of web application development using Django, * learn programming through the educational code review process, * get to know the code hosting and version control platform GitHub and * track development progress in Bugzilla.
FlyWeb is an experimental new addition to the web platform that allows browsers to discover and connect to web servers (or application servers) that are near you. FlyWeb also lets web pages to directly host web servers that are visible to other nearby browsers.
Our goal is to allow the web to let people interact with things and other people near them, without needing apps, or even a connection to the internet. There are two classes of use cases that FlyWeb is targeted at:
1. User interfaces for smart devices
As the number of smart devices grows, the problem of interacting with them increases. Smartphone apps are currently the most common interface to these devices, but having a different app for every different thing you want to control doesn’t scale. With FlyWeb, a smart device can simply advertise itself as a FlyWeb server, allowing browsers to discover and connect to it. The UI for the device can be delivered as a standard web application via protocols such as HTTP and WebSocket.
The user doesn’t need to search for, download, and install apps just to interact with a new device. They can just user their browser to discover and interact with it like they would an internet service.
2. App-less interaction between smartphones
FlyWeb lets web-pages publish their own discoverable FlyWeb servers. This means that web pages can “extend themselves” between phones in a programmable way.
For example, a web game could expose a multiplayer mode which uses FlyWeb to start and publish a server. When your friend discovers and connects to the game with their browser, the web page on your phone can send them a copy of the game code (the same as you received it from an internet server), and the two of you can play a multiplayer game without either of you having to download an app, or create an account, or tell each other your usernames, or any other coordination.
This mechanism can be extended to other interactions between people, like file-sharing, or shared whiteboards.
The UCOSP goal for the project is open-ended. We want to see what ideas smart developers can come up with for applications that leverage the capabilities of FlyWeb. Whether you want to build a smart device demo using Raspberry Pi, or a pure “browser to browser” demo using the web-page-publish-server feature, we want to see what you can come up with.
Your project, if successful, will be featured (given your permission) on our demo showcases, and potentially used to help promote the project.
Getting started is as easy as going to flyweb.github.io and following the instructions listed.
20. HTML5 Applications with BlackBerry
Research In Motion is embracing application development with HTML5 and seeking to push the boundaries of what can be accomplished with web technologies on a mobile device. Our goal is to be the premier platform for the mobile web, with the most compliant, high performance, hardware accelerated Webkit engine we can create.
We are rounding out the development experience with emulators, simulators, live Web Inspector debugging, support for all major frameworks, and we’re doing all of this in the open on Github.com under the Apache 2 license. This is your opportunity to join us in contributing to Open Source software and we have a wide variety of places to participate.
Projects will be flexible based on student skill sets, and examples are:
- Participation in a variety of open source projects from frontend frameworks and WebGL to core architecture libraries and everything in between. We are actively involved with all the major projects and quite a few of the minor ones.
Students can expect the opportunity to contribute code to major projects using the most current tools and techniques. All projects will be public on Github.com and involve working with a distributed community of developers from around the world.
21. Eclipse Projects
Eclipse is a community of open source communities. Technology from Eclipse is used to create the famous Eclipse IDE that is used by many millions of developers worldwide to develop software and applications in a number of languages.
The Eclipse Foundation is creating an innovative program to support organizations that develop products and services based on Eclipse technology. To enable this program, the Foundation requires technology to support developers collaborating over the long term (years and up to decades).
Working on these projects as part of UCOSP is an incredible opportunity to collaborate with some of the best and most talented developers in the world. It is also a great opportunity for visibility with many influential technology companies including IBM, Oracle, SAP, Google, Red Hat, and many more.
Project: Code2Cloud features (tentative)
Code2Cloud is a development environment providing many useful features to make developers productive. These include a code repository, build server, bug tracker, wiki, project meta data, code review, and more. It is very similar to the features offered by Github and goes a bit beyond.
This project was prototyped by Tasktop & VMWare. This project is to pick and implement a new feature to Code2Cloud such as:
- LDAP Support
- Gerrit support (for code review)
- The ability to fork a project
- The ability to fork an organization
- Others features that we brainstorm
The technology is implemented in Java (Server) & Ruby (Administration UI). Some familiarity with Eclipse and the Eclipse community is an asset. Code is managed in git.
Project: Enhance Nexus support for p2 repositories
Nexus is a build artifact manager developed by a company called Sonatype. It is the repository and distribution technology used by the famous Maven build engine. We’ll be working on the open source version of Nexus. The Eclipse Foundation plans to use Nexus for managing build artifacts. This system makes it easy for people to find and download components they want to re-use in their projects. It also lets projects upload components directly from their build.
This project will involve considerable interaction with the community and a lot of analysis and design as challenging problems are sorted. For example, there are differences between conventions used by Maven & Nexus and OSGi & p2 which is used by Eclipse. These differences are incompatible in some cases requiring us to figure out how to address them, or to decide to fully embrace/support/distribute to both (Maven repository & p2 repository) formats.
The Maven build engine, and Tycho plug-in will likely also need extension to allow it to calculate dependencies and find p2 repositories stored in Nexus.
The technology is implemented in Java (Server). Some familiarity with Eclipse and the Eclipse community is an asset. Code is managed in git.
Freeseer is a powerful screen-casting tool. It enables you to record from a various video and audio sources such as local desktop, usb, microphone, and other sources. It supports live streaming. It also provides rich meta data handling capabilities in which the speaker, title, event, and other meta data are encoded in the video files.
The Freeseer project is a project still growing rapidly and perhaps one of the best open source video screen casting tools available.
Freeseer is implemented in Python. Code is managed in git.
Project: Upload tool
This project is to enable freeseer to upload videos to YouTube quickly and easily and automatically populate meta data fields from fields encoded into the video file during recording. Work was done on this tool previously resulting in a strong GUI. This project is to complete the work, test it, and ensure it works robustly.
Project: UStream streaming support
UStream is a popular video streaming site. This project is to enable Freeseer to support it for video streaming.
Project: Prerequisite cleanup
From time to time developers contribute code to freeseer that is experimental. Sometimes this code uses a particular third party library that made sense at the time but perhaps can be replaced with an existing library that Freeseer already uses thus making it require fewer external components. This project is to evaluate all prerequisites and remove them where it makes sense.
Examples: Move rss import to qt https://github.com/Freeseer/freeseer/issues/175
Project: Integrated video player
When recording talks at conferences, as part of training the team, we encourage them to watch videos in between talks to be able to make any adjustments needed. For example if the microphone is too high or low.
This project is to enable a simple option for recording technicians to watch the videos.
23. The Technology Explorer for IBM DB2
The Technology Explorer (TE) is a light weight, web based console for DB2 for Linux, UNIX and Windows. The Technology Explorer strives to be a teaching tool for all users of DB2 and is also used to demonstrate and prototype new interfaces for upcoming features.
This has also had the benefit of making the TE a flexible and customizable interface for DB2 (Think phpMyAdmin meets Drupal or Lego for database administrators). Over the past few year there has been a number of requests for core features by contributors and core users of the TE that can not be contained by the IBM internal TE team.
More information: https://sourceforge.net/projects/db2mc/
24. Basie on Pinax (on Django (on Python))
Basie is a web-based software project forge that integrates revision control, issue tracking, mailing lists, wikis, status dashboards, and other tools that developers need to work effectively in teams. Basie is simple enough for students to master in ten minutes, but powerful enough to support large, distributed teams, and is freely distributed under the
We are currently rebuilding Basie on top of Pinax, a set of components for Django (which is itself a Python web framework). Our goal for this term is to create a better mailing list manager; using ideas originally explored in DrProject, we will build and test a mail relay, address registration, and whitelisting so that project members can keep in touch with each other, and easily find what’s been done before.
The Fab4 browser builds a modern UI around the Multivalent framework for digital document management, and extends it with support for distributed annotations and new file formats.
The project involves the development of a set of interactive visualizations based on the data collected by the CLR tool, built on the Fab4 browser.
More information: https://code.google.com/archive/p/fab4browser/
POSIT aims to create a portable, opensource tool for the Android platform to aid search and rescue efforts by allowing the transmission of data between users and to central servers.
Imagine you are a rescue worker searching for victims and survivors in the aftermath of a hurricane or other natural disaster. Or, imagine you are botanist mapping a geographical area for an invasive species. Or, an environmental scientist searching for hazardous waste deposits.
What’s needed is a portable tool that is able record information about Finds and transmit it to a central server or control center. As mobile phone technology becomes ubiquitous and more powerful, such a tool is now feasible. Building such a device on the FOSS Android platform would make it widely and freely available to rescue workers, environmental scientists, and other field workers.
More information: http://posit.hfoss.org/
27. Encyclopedia of Life
The Encyclopedia of Life (EOL) is a free, online collaborative encyclopedia intended to document all of the 1.8 million living species known to science. It is compiled from existing databases and from contributions by experts and non-experts throughout the world.
The ultimate criteria of success for a web application is the user experience. EOL is no exception. This project involves creating a framework for describing how visitors are suppose to interact with Encyclopedia of Life. It automatically checks that a new version the EOL code is functioning as expected. It is very beneficial for open source projects to be released often, and automated tests decrease the cost of releases dramatically and ensure the integrity of the data, code, and visual representation.
The tests are run either in production or a duplicate of the production environment. The acceptance testing framework can be extended to check any website, not only EOL, by changing the configuration and defining new test suites. It also enables testing a web application with different browsers and operating systems.
Acceptance testing is an import skill for aspiring developers. By participating in this project you will learn the inner mechanics of operating a browser automatically using scripts, emulating a real person actions. This project will provide experience using Selenium (a leading open source acceptance testing tool), XML, XPATH, CSS selectors, and Behavior Driven Development.
28. Opencast Matternhorn
Matterhorn is a free, open-source platform to support the management of educational audio and video content. Institutions will use Matterhorn to produce lecture recordings, manage existing video, serve designated distribution channels, and provide user interfaces to engage students with educational videos.