Dynamic IDE for Python
======================

The main idea is to use run-time information to make life of developer easier in
such aspects as:
 * debugging in the editor, when you can evalute the function or the method
   you are writing with the same arguments as before. So you can invoke it once for
   real, and then invoke it in the editor, and see its return value and debugging output
 * smart code-completion, using run-time value information. When we know the values
   of all arguments of the function, we can invoke part of the function to determine
   the values of local variables, and provide accurate information on avalible methods


Dynamic debugging
-----------------

Python module is connected with the editor (emacs, but it should be easy to write
bindings to other editsor as well) via a very simple interface - editor invokes
python script with 4 args - option (currently "call_fn" | "call_fn_butlast"),
absolute path to the file, line number of cursor, and position in line.
The script determines
in which function the cursor is, checks if if knows any aruments to this function.
If there are, it invokes the function with the given argument, prints all output from
the function, and its return value. If there is an exception (even a syntax error),
it prints the stacktrace, and enough information for the editor to jump to the place
of the exception in the current file. If the function has no known arguments,
then the script just imports given file, and again lets the editor jump to the line
of the error in the file.


How are the arguments of the functions recorded
-----------------------------------------------

The function arguments are recorded via function decorator simulation.pickling_decorator

TODO - continue

Smart auto-complete
-------------------

Smart auto-complete uses full run-time information, so it has informations of actual
values of objects and can provide completion variants based on them.
The main idea is to modify the source code and execute modified source with the last
args, like in dynamic debugging. We modify source in such a way that function is
executed as normal till it reaches the place where we want to auto-complete, and
at that place we insert an invocation of function that prints all variants to stdout
and termenates execution. So we can get auto-complete even inside list comprehensions
(but I still have to think about auto-complete in generator expressions and
lambda expressions that are not invoced in this function).

We can not modify the file beeing edited, so instead we create a copy, and apply
source modifications to it, then invoke function via simulation.py, and delete the file.
(TODO - its possible to optimize it and not make a copy of the whole file,
but maybe its not worth it).
But in order to use simulation.py via its standart interface, we need some way to
associate function from modified file with the same named function from unmodified
(perhaps, we'll just need to strip some pre-defined suffix from the name of the file
at the place where we are looking for saved function args).

The input interface is the same as the interface of simulation.py
From command line args we get action, the name of the file, line number and position in
current line, and output completion variants, one on each line.


Auto-removing of pickling decorators (or how to live well with the others)
--------------------------------------------------------------------------

In order to live well with other programmers, working on the same project with you,
and to avoid caching of input arguments to function in production usage, there is
an easy way to remove all traces of this pickling decorators, for example before
commit, or after you finished debugging some part of the system. In the editor
you just specify the directory or a file where you want to clean up,
and run the command. Another useful facility could be removing all traces before
commit, and then placing them back (but maybe we should not do it).

foo