[wingide-users] Improving Wingware workflow

Christopher Fry cfry1 at MIT.EDU
Fri Oct 12 20:01:10 EDT 2012

This is more than a simple feature request. But I also consider it

to be of much more utility than all the work in all the updates I've

seen to wingware for the past year, and, I suspect, would be a lot less work.

That is because you've got all the pieces in place, its just that they aren't

connected together in the right way. (Or if there's some way to do what I want,

its not obvious enough for me to figure out.)

What I am proposing is a way to work that was common on the Lisp Machine,

that I built in to Macintosh Common Lisp and the Water IDEs so its not

some theory about "I bet it would be good if you had ..." its

"I know it would improve my productivity and many others if you had ..."

and due to several existing implementations, I know its not just possible,

but not so hard to do, esp given that you've already done all the really hard parts.

I will explain the needed funtionality with what I consider to be the normal

way to develop software.

We've got a large program with many files but for this purpose let's just

use one file with 2 methods in it to make it concrete:


def foo (self, a, b):

 """the foo method computes a list. Example: foo(4, 5)

  You might also want to call bar directly: Example: bar(234)


  return bar(b)

def bar(self x):

 """Bar returns a 2 element list: Example:  bar(17)"""

  return [x, x+1]


1. After typing in the source code above I want to run it and see if it works.

2. Evaluate the whole file

3. Now select  foo(4, 5) in the doc string of method foo and STEP through it.

4. After stepping through it I want to INSPECT the value that it returned.

5. Now I want to edit the bar method, say change the 1 to a 2,

   and select just the def of bar and evaluate that.

6. select "foo(4, 5)" again and step through that, now using the new definition of bar.

7. In the middle of stepping I want to eval some new snipet of code that

   I type in with all the lex vars bound, ie as you can now do when stepping

   in Wingware in the Debug Probe window.

8. Also in the middle of stepping I want to inspect data, as you can now do in the

   the Stack Data view. But don't force me to set something to a lex var,

   let me be able to inspect the value of a return of a call. In fact, whenever I eval

  any expression that returns a val (call, var, list, path, etc)

  while stepping, show me its value and allow me to inspect that value

  if I care to.

Here's what I don't want to do and shouldn't have to do:

1. set any breakpoints (this is still a nice feature to have, and you want to be able to

   "eval until the next breakpoint" like you already have when stepping.)

2. set the returned value of foo(4, 5) to a lex var, ie x = foo(4, 5) just to be able to inspect its result.

3. eval the whole file (or multiple files) just because one def changed.

   Just let me eval that one def.

4. mess around with "eval file in shell", etc.

A few non-obvious things from the above.

1, I should, at some point, decide that my python env is all screwed up and be able to say

  "start with a fresh python env." In my programming in the past, this has RARELY been

  necessary, but it is occassionally necessary. The easiest thing is just quit the whole IDE and come back in,

  but it would be good to have that be a button click as it would be mentally less disruptive,

 even if it did take roughly the same amount of time.

2. If we have

   class boat:

      def launch():


and I edit the body of def launch, then want to select that def and "eval" it,

and have it replace the boat.launch you have to figure out that it is in boat.

This means walking up the parse tree from launch to class boat.

There are other ways to do this, maybe just walk up until you see "class" then

eval that whole class, but then maybe you have a nested class, etc.

Don't let this problem derail the core ideas.

At worst you just let the user re-eval the whole file (though it would be nice to

 exclude from that eval any top level import statements.)

Please don't let these 2 hard parts derail the overall improvements.

Relaunching the ide and evaling the whole file aren't so bad.

Get the core functionality up and you can work on this "icing on the cake" later.

-------------- next part --------------
An HTML attachment was scrubbed...
URL: </pipermail/wingide-users/attachments/20121013/f7089c38/attachment.html>

More information about the wingide-users mailing list