Skip to content
Snippets Groups Projects
Commit 2f249386 authored by Maciej Fijalkowski's avatar Maciej Fijalkowski
Browse files

merge

parents 382385a4 a8ec2b4e
No related branches found
No related tags found
No related merge requests found
---
layout: page
title: Python 3 funding
---
Call for donations: PyPy to support Python 3!
=============================================
The release of Python 3 has been a major undertaking for the Python
community, both technically and socially. So far the PyPy interpreter
implements only version 2 of the Python language and is increasingly
used in production systems. It thus contributes to the general risk
of a long lasting Python community split where a lot of people
continue using Python 2 while others work with Python 3, making it
harder for everyone.
The PyPy project is in a unique position in that it could support
**both Python 2 and Python 3** versions from the same code base, fully
reusing its unique translation and JIT-Compiler technologies.
However, it requires a lot of work, and it will take a long time
before we can complete a Python 3 port if we only wait for volunteer
work. Thus, we are asking the community to help with funding the
necessary work, to make it happen faster. Here_ is a more detailed view on how our proposed work benefits the Python community and the general public.
Below you'll find the `planned stages of work`_ and the associated
fundraising targets we need to make things happen. Once we reach the
necessary target for each stage, we will start contracting
developers. Contracts and money are managed by the non-profit
`Software Freedom Conservancy`_ of which the PyPy project is a member.
The current elected representatives are Carl Friedrich Bolz, Holger
Krekel and Jacob Hallen and they will - in close collaboration - with
Conservancy and the core developers, select the best developers for
the Python 3 porting job among well known PyPy contributors.
If you want to see PyPy support Python 3 and Python 2, donate here:
XXX insert links to Paypal and Google Chekcout links categorized such
that things will get accounted properly on the Conservancy side
Should we not receive enough donations to complete all stages by 1st March 2012
at the latest, we will try our best to make PyPy support Python 3 anyway. We
however reserve the right to shift any unused funds to other PyPy activities
when that date is reached. Of course, since the Conservancy is a
501(c)(3) chartiable organization incorporated in NY, USA, all funds will,
regardless of their use, be spent in a way that benefits the general
public, the advancement of Open Source and Free Software,
and in particular the PyPy community and the PyPy codebase.
**Note** For donations higher than $XXX we can arrange for an invoice and a different payment method to avoid the high Paypal fees. Please contact pypy at sfconservancy.org if you want to know details
on how to donate via other means.
.. _`Software Freedom Conservancy`: http://sfconservancy.org/
.. _`planned stages of work`:
Workplan
========
The goal of this project is to write an interpreter that interprets
version 3 of the Python language. To be precise we would aim at having
a Python 3.2 interpreter together with the same codebase as the Python 2.7
one.
At the end of the project, it will be possible to decide at
translation time whether to build an interpreter which supports Python
2.7 or Python 3.2 and both versions will be nightly tested and
available from nightly builds.
The focus of this project is on compatibility, not performance. In
particular, it might be possible that the resulting Python 3
interpreter will be slower than the Python 2 one. If needed,
optimizing and making it more JIT friendly will be the scope of a
separate project. (Our existing JIT generation technology should apply
out of the box; this disclaimer is only about the extra performance we
could obtain by tweaking the Python 3 interpreter or writing specific
interpreter-guided optimizations in the JIT.)
About estimates and costs
-------------------------
For each step, we estimated the time that it would take to complete for an
experienced developer who is already familiar with the PyPy codebase. From
this number, the money is calculated considering a hourly rate of $60, and a
5% overhead which goes to the `Software Freedom Conservancy`_, the non-profit
association of which the PyPy project is a member and which manages all the
issues related to donations, taxes and payments.
The estimated time to complete the whole project is about 10.5 person-months.
For comparison, the python-3000 mailing list was created in March 2006; Python
3.0 was released in December 2008 and Python 3.1, the first release genuinely
suitable for production use (due to the abysmal I/O performance of 3.0) was
released in June 2009. During these 3.5 years, a lot of people contributed to
the development of Python 3, and while it is hard to turn these numbers into
precise person-years, it sounds reasonable to think that in total it took
several person-years.
We have the advantage of targeting something that already exists without
having to define the destination as they go along, and also the internal
architecture of PyPy makes it easier to do the porting.
Step 1: core language
----------------------
In this step, we implement all the changes to the core language,
i.e. everything which is not in the extension modules. This includes, but it
is not necessarily limited to the following items, which are split into two
big areas:
* **Sub-step 1.1**: string vs unicode and I/O:
- adapt the existing testing infrastructure to support running Python 3 code
- string vs bytes: the interpreter uses unicode strings everywhere.
- the ``print`` function
- ``open`` is now an alias for ``io.open``, removal of the old file type.
- string formatting (for the part which is not already implemented in Python
2.7)
- the _io module (for the part which is not already implemented in Python
2.7)
- syntactic changes to make ``io.py`` importable (in particular:
``metaclass=...`` in class declarations)
- **Estimate cost**: $37,000
* **Sub-step 1.2**: other syntactic changes, builtin types and functions,
exceptions:
- views and iterators instead of lists (e.g., ``dict.items()``, ``map``,
``range`` & co.)
- new rules for ordering comparisons
- removal of old-style classes
- int/long unification
- function annotations
- smaller syntax changes, such as keyword-only arguments, ``nonlocal``,
extended iterable unpacking, set literals, dict and set comprehension, etc.
- changes to exceptions: ``__traceback__`` attribute, chained exceptions,
``del e`` at the end of the except block, etc.
- changes to builtins: ``super``, ``input``, ``next()``, etc.
- improved ``with`` statement
- **Estimate cost**: $26,000
Note that the distinction between sub-steps 1.1 and 1.2 is blurry, and it might be
possible that during the development we will decide to move items between the
two sub-steps, as needed.
For more information, look at the various "What's new" documents:
- http://docs.python.org/py3k/whatsnew/3.0.html
- http://docs.python.org/py3k/whatsnew/3.1.html
- http://docs.python.org/py3k/whatsnew/3.2.html
**Total estimate cost**: $63,000
.. Time estimate: 3.5 + 2.5 = 6 man/months
Step 2: extension modules
--------------------------
In this step, we implement all the changes to the extension modules which are
written in C in CPython. This includes, but it is not necessarily limited to:
- ``collections``, ``gzip``, ``bz2``, ``decimal``, ``itertools``, ``re``,
``functools``, ``pickle``, ``_elementtree``, ``math``, etc.
**Estimate cost**: this is hard to do at this point, we will be able to give a
more precise estimate as soon as Step 1 is completed. As a reference, it
should be possible to complete it with $37,000
.. Time estimate: 4 man/months
Step 3: cpyext
--------------
The ``cpyext`` module allows to load CPython C extensions in PyPy. Since the
C API changed a lot between Python 2.7 and Python 3.2, ``cpyext`` will not
work out of the box in the Python 3 PyPy interpreter. In this step, we will
adapt it to work with Python 3 as well.
Note that, even for Python 2, ``cpyext`` is still in a beta state. In
particular, not all extension modules compile and load correctly. As a
consequence, the same will be true for Python 3 as well. As a general rule,
we expect that if a Python 2 module works with ``cpyext``, the corresponding
Python 3 version will also work when this step is completed, although the
details might vary depending on the exact C extension module.
**Estimate cost**: $5,000
.. Time estimate: 0.5 man/month
.. _`here`:
Benefits of This Work to the Python Community and the General Public
====================================================================
Python has become one of the most popular dynamic programming languages in
the world. Web developers, educators, and scientific programmers alike
all value Python because Python code is often more readable and because
Python often increases programmer productivity.
Traditionally, languages like Python ran more slowly than static, compiled
languages; Python developers chose to sacrifice execution speed for ease
of programming. The PyPy project created a substantially improved Python
language implementation, including a fast Just-in-time (JIT) compiler.
The increased execution speed that PyPy provides has attracted many users,
who now find their Python code runs up to four times faster under PyPy
than under the reference implementation written in C. Some programs that
are particularly JIT-friendly see even greater speedups. See our speed__
website.
.. __: http://speed.pypy.org
Meanwhile, the Python community is undergoing significant change, with the
introduction of a new 'version 3' of the Python language (Python 3).
Python 3 breaks some backwards compatibility with 2.x series, so
programmers who seek to use Python 3 must port old code. For example,
programmers who needed old libraries might want to use Python 2 only and
programmers wanting to use new language features would like to use Python
3, but would not be able to use libraries that written for Python 2.x
without substantial rewrites. This issue could lead to a dangerous
community split: programmers who needed old libraries might only use
Python 2 and programmers seeking new language features would use Python 3,
but would not be able to use libraries written for Python 2.x.
PyPy currently supports only Python 2.7. While PyPy supports only version
2 of the Python language, PyPy users have an incentive to avoid Python 3.
Python programmers must chose between the language features in Python 3,
and the substantial performance benefits offered by PyPy.
To address this issue, the PyPy team proposes to implement Python 3 on
PyPy. With such improvements to PyPy, PyPy can support the entire
Python-using community and hopefully help to prevent any community split.
PyPy support of Python 3 would also bring the excellent code execution
performance of PyPy to those who wish to migrate to Python 3.
Moreover, by ensuring the latest version of the Python language
specification (Py3k) works properly and fully on PyPy, the maximal benefit
of collaboration, learning, and software improvement can happen in the
entire Python language community.
A broad community of developers support and develop the PyPy project,
many of whom work as volunteers. The Py3k grant should help with turning
some attention towards implementing Python 3. This will not hinder other
directions in which PyPy is going like improving performance. The goal
of the PyPy community is to support both Python 2 and Python 3 for the
forseeable future.
PyPy's developers make all PyPy software available to the public without
charge, under PyPy's Open Source copyright license, the permissive MIT
License. PyPy's license assures that PyPy is equally available to
everyone freely on terms that allow both non-commercial and commercial
activity. This license allows for academics, for-profit software
developers, volunteers and enthusiasts alike to collaborate together to
make a better Python implementation for everyone.
Finally, tracing JITs and other programming language execution technology
used in PyPy are of current and particular interest in computer science
research. PyPy helps cross-pollinate knowledge between academic computer
science and industrial use of Python, since PyPy can function well both as
a research tool and real-world Python programming language implementation.
Continued support and evolution of PyPy in any direction, such as support
for Py3k, increases the features available from PyPy and such improvements
are expected to spark even more general interest in PyPy itself and the
Python programming language generally.
References on Educational Uses of Python:
- http://wiki.python.org/moin/SchoolsUsingPython
- http://www.python.org/doc/essays/cp4e.html
References for PyPy and its benefits:
- http://pypy.org/
- http://pypy.org/features.html
- http://pypy.org/compat.html
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment