Looking for Participant companies for the PyPy Project
=======================================================

PyPy is useful for a huge lot of things, since it is able
to optimize any existing or future Python application.
This is probably a convincing argument for using PyPy after
the fact, i.e. after it is ready and we have shown what it can do.

For the purpose to convince people that PyPy is
a great idea and needs to become supported right now,
we believe it is better to address an area where
PyPy can really fill a gap:

- Providing a very high level language that produces
  efficient low-level code for embedded systems.
  
- In extent of that, providing an efficient small operating
  system for embedded systems that is completely written in
  Python.
  
We would like to set up a collaboration on such development
together with one or more manufacturers of devices.
For instance:

 - Printers
 
   - Low-cost printers with small memory and storage are a good
     PyPy target, via cross-compiling.
    
     This would make it possible to write applications for printers
     completely in Python. It would enable to use existing
     software like ReportLab to extend the printers capabilities,
     like printing special forms and reports directly.
 
   - High-cost printers (like Postscript printers) are
     likely to be less of a target, since they usually
     have powerful processors and much memory, but PyPy can be used
     to save resources and therefore make the product cheaper.
     
 - Mobile Phones
 
   - at least cross-compiling like for small printers
   
   - maybe a full Python, as an alternative to JavaScript,
     providing downloadable applications.
     
 - Washing machines, dryers, kitchen machines
 
   - clearly targets for PyPy as a small OS.
   
 - PDAs, small hand-held computers
 
   - providing Python as a programming language.
   
   - very good performance even on slow devices,
     due to the optimization built into PyPy.
     
   - ability to save a running program for later re-use.
     A running application can be saved in a restartable
     way. Unless there are direct depencies from legacy GUI
     code, it is possible to save program state from the PDA,
     send it to the home computer and let it continue there.
     
 - Sound systems, Video systems
 
   - for low-end systems, PyPy can produce cross-compiled
     code.

   - there are systems under development which use Python
     to make intelligent high-end video systems, with
     scheduled MPEG recording, graphical menu control,
     downloadable program schedules. These are based upon
     a Linux kernel, use Python as-is, and the archtiecture
     has to be high-ended (GHz processor).

   - PyPy can reduce the cost of such systems very much
     due to its high efficiency, therefore opening the
     market to low-cost consumer products.

Common to all of the above is, in case we want to create
a stand-alone small operating system, we most probably
need to implement our own IP stack, or we would have to
interface to an existing one for every device.

Whatever solution we use, it enables some more areas where
PyPy becomes applicable as a small OS:

- Networking devices

  - transmitter stations for WLANs (see also the
    tendency to create public WLANs covering whole cities)
    
  - Intelligent network switches
   
    Due to the high optimization level of PyPy in its
    optimized state, it is possible to write the whole
    control software for switches in Python.
    
  - Telephone switches for cellphone networks

Another area where PyPy can be used as an advantage is
parallel computing, so we are interested to collaborate
with any company that needs parallelism.
  
PyPy helps with massively parallel computations:

  - supporting SIMD architecture to create efficient
    code for a computation node
  
  - allows to move running tasks between different
    netowrked computation nodes by thread pickling

  - increases efficiency of development: Rapid prototyping
    in Python creates high-speed applications and saves
    the time to create hand-optimized C code.
    
  - By supporting TCSP [*]_ (Timed Communicating Sequential Processes),
    PyPy can lead to provable correct, dead-lock free computation
    and simulation networks with high efficiency, while preserving
    the easy maintainability of Python.
   
    
.. [*] cf. Hoare. TCSP is not yet supported, but will be implemented
   for Stackless Python, soon, and that moves it into PyPy, too.