[pypy-dev] Question on the future of RPython

Leonardo Santagada santagada at gmail.com
Mon Sep 27 21:58:51 CEST 2010

On Mon, Sep 27, 2010 at 4:44 PM, Terrence Cole
<list-sink at trainedmonkeystudios.org> wrote:
> On Sun, 2010-09-26 at 23:57 -0700, Saravanan Shanmugham wrote:
>> Well, I am happy to see that the my interest in a general purpose RPython is not
>> as isolated as I was lead to believe :-))
>> Thx,
> What I wrote has apparently been widely misunderstood, so let me explain
> what I mean in more detail.  What I want is _not_ RPython and it is
> _not_ Shedskin.  What I want is not a compiler at all.  What I want is a
> visual tool, for example, a plugin to an IDE.  This tool would perform
> static analysis on a piece of python code.  Instead of generating code
> with this information, it would mark up the python code in the text
> display with colors, weights, etc in order to show properties from the
> static analysis.  This would be something like semantic highlighting, as
> opposed to syntax highlighting.
> I think it possible that this information would, if created and
> presented in the correct way, represent the sort of optimizations that
> pypy-c-jit -- a full python implementation, not a language subset --
> would likely perform on the code if run.  Given this sort of feedback,
> it would be much easier for a python coder to write code that works well
> with the jit: for example, moving a declaration inside a loop to avoid
> boxing, based on the information presented.
> Ideally, such a tool would perform instantaneous syntax highlighting
> while editing and do full parsing and analysis in the background to
> update the semantic highlighting as frequently as possible.  Obviously,
> detailed static analysis will provide far more information than it would
> be possible to display on the code at once, so I see this gui as having
> several modes -- like predator vision -- that show different information
> from the analysis.  Naturally, what those modes are will depend strongly
> on the details of how pypy-c-jit works internally, what sort of
> information can be sanely collected through static analysis, and,
> naturally, user testing.
> I was somewhat baffled at first as to how what I wrote before was
> interpreted as interest in a static python.  I think the disconnect here
> is the assumption on many people's part that a static language will
> always be faster than a dynamic one.  Given the existing tools that
> provide basically no feedback from the compiler / interpreter / jitter,
> this is inevitably true at the moment.  I foresee a future, however,
> where better tools let us use the full power of a dynamic python AND let
> us tighten up our code for speed to get the full advantages of jit
> compilation as well.  I believe that in the end, this combination will
> prove superior to any fully static compiler.

This all looks interesting, and if you can plug that on emacs or
textmate I would be really happy, but it is not what I want. I would
settle for a tool that generates at runtime information about what the
jit is doing in a simple text format (json, yaml or something even
simpler?) and a tool to visualize this so you can optimize python
programs to run on pypy easily. The biggest difference is that just
collecting this info from the JIT appears to be much much easier than
somehow implement a static processor for python code that do some form
of analysis.

I think that fijal is at least thinking about doing such a tool right?

Leonardo Santagada

More information about the Pypy-dev mailing list