[Idle-dev] Fwd: Discussion: 2 many IDE's...don´t we want more?!

[Paul D. Fernhout]

Stani-

Somewhat belated, but here are some ideas I earlier posted on the edusig 
list, related to adding some of the featueres of a Squeak Smalltalk 
development experience to Python, and might be of interest to discuss here.

I like the promising idea of developing and debugging across images (or 
VMs) -- that is, you develop using tools in a VM you are not also 
changing, but they work across a socket to talk to another VM where your 
application is running. I have one prototype that does that somewhat (for 
a custom language); I built a socket server into the VM.

I realized later it would probably be better to build a client in instead. 
That is, you have just one server on the machine, which coordinates client 
debuggers and client applications, and redirects their messages to each 
other as a switch board. That way you just use one common port, and can 
debug multi-VM communications stuff as well.

I would try to
ship the objects around as pickled Python objects, but would need to look
hard at current security issues there; otherwise they would end up as some
other format.

To support this at first might involve
using a separate thread running in the application, and would initially
use a sort of module or per function reloading approach, but later the
Python VM could be modified to support a debugger socket connection
natively.

To be clear, what I am going for here is the "feel" of developing in
Smalltalk, where you can point your inspector at an arbitrary application,
not necessarily the specifics of the Squeak experience. In this case, the
Python philosophy of being like glue :-) suggests treating any
OS as analogous to a Squeak VM, and finding a way, sockets in this case,
to make seemingly different things work together.

It's a bit like the notion behind "Dabo" but for development, evaluating 
one-off Python expressions inspecting existing objects, and debugging.

As long as everyone agreed on specific versions of the communications 
protocol this common subsystem, which would run as a common server, one 
could use IDE tools written in any language (or Python flavor) and any 
widget set (even just the command line shell) to debug any application 
which is a client to this server (including self-referentially the IDEs).

I think that might not exactly address this proliferation of IDEs, but it 
would allow them to be fractured into components that each do what they do 
best, and the parts of several IDEs could be used selectively together to 
develop or debug the same application.

Remote debugging is nothing new. VisualAge Smalltalk has had it for years, 
for example, but I think this idea takes it to a whole new level.

--Paul Fernhout

SPE Stani's Python Editor wrote:
> Hi Kurt, Noam and every other IDLE developer,
> 
> I tried to send you this by mail, but maybe it didn't arrive. 
> drPython and Eric3 joined as well.
> 
> I would be very glad to receive your reaction.
> 
> Thanks in advance,
> Stani