NaCl docs: add project ideas

native_client_sdk/src/doc/reference/ideas.rst

Index: native_client_sdk/src/doc/reference/ideas.rst
diff --git a/native_client_sdk/src/doc/reference/ideas.rst b/native_client_sdk/src/doc/reference/ideas.rst
new file mode 100644
index 0000000000000000000000000000000000000000..71d43600c5a066bf85855c47cf83984a7437eb9f
--- /dev/null
+++ b/native_client_sdk/src/doc/reference/ideas.rst
@@ -0,0 +1,361 @@
+.. _ideas:
+
+#################
+Contributor Ideas
+#################
+
+.. contents::
+   :local:
+   :backlinks: none
+   :depth: 3
+
+Contributing? Me‽
+=================
+
+NaCl and PNaCl are very big projects: they expose an entire operating system to
+developers, interact with all of the Web platform, and deal with compilers
+extensively to allow code written in essentially any programming language to
+execute on a variety of CPU architectures. This can be daunting when trying to
+figure out how to contribute to the open-source project! This page tries to make
+contributing easier by listing project ideas by broad area of interest, and
+detailing the required experience and expectations for each idea.
+
+This isn't meant to constrain contributions! If you have ideas that aren't on
+this page please contact the native-client-discuss_ mailing list.
+
+If you like an idea on this page and would like to get started, contact the
+native-client-discuss_ mailing list so that we can help you find a mentor.
+
+.. _native-client-discuss: https://groups.google.com/group/native-client-discuss
+
+Ideas
+=====
+
+We've separated contributor ideas into broad areas of interest:
+
+* **Ports** encompass all the code that *uses* the PNaCl platform. Put simply,
+  the point of ports is to make existing open-source code work.
+* **Programming languages** sometimes involves compiler work, and sometimes
+  requires getting an interpreter and its APIs to work well within the Web
+  platform.
+* **LLVM and PNaCl** requires compiler work: PNaCl is based on the LLVM
+  toolchain, and most of the work in this area would occur in the upstream LLVM
+  repository.
+* **NaCl** mostly deals with low-level systems work and security.
+
+
+..
+  Adding a proposal to this document should follow this format:
+    Project:                *project title*
+    Brief explanation:      *brief description*
+    Expected results:       *how do we evaluate the project's success?*
+    Knowledge Prerequisite: *programming languages, CS topics, ...*
+    Mentor:                 *one or multiple, their roles in this project*
+  The above list is inspired by the Google Summer of Code guidelines, and the
+  KDE project list.
+
+Ports
+-----
+
+New Filesystems
+^^^^^^^^^^^^^^^
+
+* **Project:** Expose new filesystems to :doc:`nacl_io
+  </devguide/coding/nacl_io>`.
+* **Brief explanation:** nacl_io exposes filesystems like html5fs and RAM disk,
+  which can be mounted and then accessed through regular POSIX APIs. New types
+  of filesystems could be exposed in a similar way, allowing developers to build
+  apps that "just work" on the Web platform while using Web APIs. A few ideas
+  include connecting to: Google Drive, Github, Dropbox.
+* **Expected results:** A new filesystem is mountable using nacl_io, is well
+  tested, and used in a demo application.
+* **Knowledge Prerequisite:** C++.
+* **Mentor:** Sam Clegg.
+
+Open Source Porting
+^^^^^^^^^^^^^^^^^^^
+
+* **Project:** Port substantial open source projects to work in naclports.
+* **Brief explanation:** naclports contains a large collection of open source
+  projects that properly compile and run on the PNaCl platform. This project
+  involves adding new useful projects to naclports, and upstreaming any patches
+  to the original project: running on PNaCl effective involves porting to a new
+  architecture and operating system. Project ideas include: Gimp, Inkscape, Gtk.
+* **Expected results:** New open source projects are usable from naclports.
+* **Knowledge Prerequisite:** C/C++.
+* **Mentor:** Brad Nelson.
+
+
+Languages
+---------
+
+PNaCl already has support for C and C++, and virtual machines such as
+JavaScript, Lua, Python and Ruby. We'd like to support more languages, either by
+having these languages target LLVM bitcode or by making sure that the language
+virtual machine's APIs work well on the Web platform.
+
+Rust
+^^^^
+
+* **Project:** Support the Rust programming languages.
+* **Brief explanation:** The Rust_ programming language uses LLVM. The aim of
+  this project is to allow it to deliver PNaCl ``.pexe`` files.
+* **Expected results:** The Rust test suite passes within the browser. How to
+  use Rust to target PNaCl is well documented and easy to do.
+* **Knowledge Prerequisite:** Compilers, LLVM.
+* **Mentor:** Ben Smith.
+
+.. _Rust: http://www.rust-lang.org
+
+Haskell
+^^^^^^^
+
+* **Project:** Support the Haskell programming language.
+* **Brief explanation:** GHC_ targets LLVM. The aim of this project is to allow
+  it to deliver PNaCl ``.pexe`` files. One interesting difficulty will be to
+  ensure that tail call optimization occurs properly in all targets.
+* **Expected results:** The Haskell test suite passes within the browser. How to
+  use Haskell to target PNaCl is well documented and easy to do.
+* **Knowledge Prerequisite:** Compilers, LLVM.
+* **Mentor:** Ben Smith.
+
+.. _GHC:
+   http://www.haskell.org/ghc/docs/latest/html/users_guide/code-generators.html
+
+Julia
+^^^^^
+
+* **Project:** Support the Julia programming language.
+* **Brief explanation:** Julia_ targets LLVM, but it does so through LLVM's
+  Just-in-Time compiler which PNaCl doens't support. The aim of this project is
+  to allow it to deliver PNaCl ``.pexe`` files.
+* **Expected results:** The Julia test suite passes within the browser. How to
+  use Julia to target PNaCl is well documented and easy to do.
+* **Knowledge Prerequisite:** Compilers, LLVM.
+* **Mentor:** Ben Smith.
+
+.. _Julia: http://julialang.org
+
+Scala
+^^^^^
+
+* **Project:** Support the Scala programming language.
+* **Brief explanation:** The aim of this project is to allow Scala_ to deliver
+  PNaCl ``.pexe`` files.
+* **Expected results:** The Scala test suite passes within the browser. How to
+  use Scala to target PNaCl is well documented and easy to do.
+* **Knowledge Prerequisite:** Compilers.
+* **Mentor:** Ben Smith.
+
+.. _Scala: http://www.scala-lang.org
+
+Elm
+^^^
+
+* **Project:** Support the Elm programming language.
+* **Brief explanation:** The aim of this project is to allow Elm_ to deliver
+  PNaCl ``.pexe`` files.
+* **Expected results:** The Elm test suite passes within the browser. How to use
+  Elm to target PNaCl is well documented and easy to do.
+* **Knowledge Prerequisite:** Compilers.
+* **Mentor:** Jan Voung.
+
+.. _Elm: http://elm-lang.org
+
+Mono
+^^^^
+
+* **Project:** Support C# running inside Mono.
+* **Brief explanation:** C# is traditionally a Just-in-Time compiled language,
+  the aim of this project is to be able to run C# code withing Mono_ while
+  compiling ahead-of-time.
+* **Expected results:** The Mono test suite passes within the browser. How to
+  use Mono to target PNaCl is well documented and easy to do.
+* **Knowledge Prerequisite:** Compilers.
+* **Mentor:** Derek Schuff.
+
+.. _Mono: http://www.mono-project.com
+
+Perl
+^^^^
+
+* **Project:** Support Perl.
+* **Brief explanation:** Port the Perl programming language and its packages to
+  the PNaCl platform.
+* **Expected results:** The Perl test suite passes within the browser. How to
+  use Perl to target PNaCl is well documented and easy to do.
+* **Knowledge Prerequisite:** C.
+* **Mentor:** Brad Nelson.
+
+TCC
+---
+
+* **Project:** Port Fabrice Ballard's Tiny C Compiler _TCC to NaCl and PNaCl.
+* **Brief explanation:** Port TCC to NaCl and enhance to follow NaCl sandboxing
+  rule, as well as emitting PNaCl bitcode. The same could be done with `Pico
+  C`_.
+* **Expected results:** Compiler ported and code generator working. Can run a
+  small benchmark of your choice.
+* **Knowledge Prerequisite:** C, assembly, compilers.
+
+.. _TCC: http://bellard.org/tcc/
+.. _`Pico C`: https://code.google.com/p/picoc
+
+
+LLVM and PNaCl
+--------------
+
+PNaCl relies heavily on LLVM in two key areas:
+
+* On the developer's machine, LLVM is used as a regular toolchain to parse code,
+  optimize it, and create a portable executable.
+* On user devices, LLVM is installed as part of Chrome to translate a portable
+  executable into a machine-specific sandboxed executable.
+
+Most of the contribution ideas around LLVM would occur in the upstream LLVM
+repository, and would improve LLVM for more than just PNaCl's sake (though PNaCl
+is of course benefiting from these improvements!). Some of these ideas would
+also apply to Subzero_, a small and fast translator from portable executable to
+machine-specific code.
+
+.. _Subzero: https://chromium.googlesource.com/native_client/pnacl-subzero/+/master/README.rst
+
+Sandboxing Optimizations
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+* **Project:** Improved sandboxed code generation.
+* **Brief explanation:** PNaCl generates code that targets the NaCl sandbox, but
+  this code generation isn't always optimal and sometimes results in a
+  performance lost of 10% to 25% compared to unsandboxed code. This project
+  would require looking at the x86-32, x86-64, ARM and MIPS code being generated
+  by LLVM or Subzero and figuring out how it can be improved to execute
+  faster. As an example, one could write a compiler pass to figure out when
+  doing a zero-extending ``lea`` on NaCl x86-64 would be useful (increment and
+  sandbox), or see if ``%rbp`` can be used more for loads/stores unrelated to
+  the call frame.
+* **Expected results:** Sandboxed code runs measurably faster, and gets much
+  closer to unsandboxed code performance. PNaCl has a fairly extensive
+  performance test suite to measure these improvements.
+* **Knowledge Prerequisite:** Compilers, assembly.
+* **Mentor:** Jan Voung.
+
+Binary Size Reduction
+^^^^^^^^^^^^^^^^^^^^^
+
+* **Project:** Reduce the size of binaries generated by LLVM.
+* **Brief explanation:** This is generally useful for the LLVM project, but is
+  especially important for PNaCl and Emscripten because we deliver code on the
+  Web (transfer size and compile time matter!). This stands to drastically
+  improve transfer time, and load time. Reduces the size of the PNaCl translator
+  as well as user code, makes the generated portable executables smaller and
+  translation size faster. Improve LLVM’s ``mergefuncs`` pass to reduce
+  redundancy of code. Detect functions and data that aren’t used. Improve
+  partial evaluation: can e.g. LLVM’s command-line parsing be mostly removed
+  from the PNaCl translator?  Potentially add a pass where a developer manually
+  marks functions as unused, and have LLVM replace them with ``abort`` (this
+  should propagate and mark other code as dead). This list could be created by
+  using code coverage information.
+* **Expected results:** Portable executables in the PNaCl repository are
+  measurably smaller and translate faster.
+* **Knowledge Prerequisite:** LLVM bitcode.
+* **Mentor:** JF Bastien.
+
+Vector Support
+^^^^^^^^^^^^^^
+
+* **Project:** Improve PNaCl SIMD support.
+* **Brief explanation:** PNaCl offers speed on the Web, and generating good SIMD
+  code allows developers to use the full capabilities of the device (better user
+  experience, longer battery life). The goal of this project is to allow
+  developers to use more hardware features in a portable manner by exposing
+  portable SIMD primitives and using auto-vectorization. This could also mean
+  making the architecture-specific intrinsics “just work” within PNaCl (lower
+  them to equivalent architecture-independent intrinsics).
+* **Expected results:** Sample code and existing applications run measurably
+  faster by using portable SIMD and/or by auto-vectorizing.
+* **Knowledge Prerequisite:** Compilers, high-performance code tuning.
+* **Mentor:** JF Bastien.
+
+Atomics
+^^^^^^^
+
+* **Project:** Improve the performance of C++11 atomics.
+* **Brief explanation:** C++11 atomics allow programmers to shed inline assembly
+  and use language-level features to express high-performance code. This is
+  great for portability, but atomics currently aren't as fast as they could be
+  on all platforms. We had an intern work on this in the summer of 2014, see his
+  LLVM developer conference presentation `Blowing up the atomic barrier`_. This
+  project would be a continuation of this work: improve LLVM's code generation
+  for atomics.
+* **Expected results:** Code using C++11 atomics runs measurably faster on
+  different architectures.
+* **Knowledge Prerequisite:** Compilers, memory models.
+* **Mentor:** JF Bastien.
+
+.. _`Blowing up the atomic barrier`: http://llvm.org/devmtg/2014-10/#talk10
+
+Security-enhanced PNaCl
+^^^^^^^^^^^^^^^^^^^^^^^
+
+* **Project:** Security in-depth for PNaCl.
+* **Brief explanation:** PNaCl brings native code to the Web, and we want to
+  improve the security of the platform as well as explore novel mitigations.
+  This allows PNaCl to take better advantage of the hardware and operating
+  system it's running on and makes the platform even faster while keeping users
+  safe. It’s also useful for non-browser uses of PNaCl such as running untrusted
+  code in the Cloud. A few areas to explore are: code randomization for LLVM and
+  Subzero, fuzzing of the translator, code hiding at compilation time, and code
+  tuning to the hardware and operating system the untrusted code is running on.
+* **Expected results:** The security design and implementation successfully pass
+  a review with the Chrome security team.
+* **Knowledge Prerequisite:** Security.
+* **Mentor:** JF Bastien.
+
+
+NaCl
+----
+
+Auto-Sandboxing
+^^^^^^^^^^^^^^^
+
+* **Project:** Auto-sandboxing assembler.
+* **Brief explanation:** NaCl has a toolchain which can sandbox native
+  code. This toolchain can consume C/C++ as well as pre-sandboxed assembly, or
+  assembly which uses special sandboxing macros. The goal of this project is to
+  follow NaCl's sandboxing requirements automatically which compiling assembly
+  files.
+* **Expected results:** Existing assembly code can be compiled to a native
+  executable that follows NaCl's sandboxing rules.
+* **Knowledge Prerequisite:** Assemblers.
+* **Mentor:** Derek Schuff, Roland McGrath.
+
+New Sandbox
+^^^^^^^^^^^
+
+* **Project:** Create a new software-fault isolation sandbox.
+* **Brief explanation:** NaCl pioneered production-quality sandboxes based on
+  software-fault isolation, and currently supports x86-32, x86-64, ARMv7's ARM,
+  and MIPS. This project involves designing and implementing new sandboxes. Of
+  particular interest are ARMv8's aarch64 and Power8. This also requires
+  implementing sandboxing in the compiler.
+* **Expected results:** The new sandbox's design and implementation successfully
+  pass a review with the Chrome security team. Existing NaCl code successfully
+  runs in the new sandbox.
+* **Knowledge Prerequisite:** Security, low-level assembly, compilers, LLVM.
+* **Mentor:** David Sehr.
+
+64-bit Sandbox
+^^^^^^^^^^^^^^
+
+* **Project:** Create a 64-bit sandbox.
+* **Brief explanation:** NaCl currently supports sandboxes where pointers are
+  32-bits. Some applications, both in-browser and not in-browser, would benefit
+  from a larger address space. This project involves designing and implementing
+  a model for 64-bit sandboxes on all architecture NaCl currently supports. This
+  also requires supporting 64-bit pointers in PNaCl using the ``le64`` platform,
+  and updating the code generation for each platform.
+* **Expected results:** The new sandbox's design and implementation successfully
+  pass a review with the Chrome security team. Existing NaCl code successfully
+  runs in the new sandbox.
+* **Knowledge Prerequisite:** Security, low-level assembly, compilers, LLVM.
+* **Mentor:** David Sehr.