[wingide-users] Incremental development

Wingware Support support at wingware.com
Tue Jun 14 10:10:12 EDT 2005


On Tue, 14 Jun 2005 konrad.hinsen at laposte.net wrote:
> I have been using WingIDE for a few weeks now, and I find it very
> valuable for debugging my applications. However, I note that I hardly
> use it to develop new code, and I wonder if that's because of some
> oversight - I can't claim to have read the manual cover to cover.
>
> My typical mode of development is best described as incremental. I
> start writing a script that will include both new classes and testing
> code, with the idea of factoring out the classes into modules once the
> code is reasonably stable. I feed the code that I write in small chunks
> to a Python interpreter as I write it, and then I run interactive
> checks before writing and testing the next chunk (all this using Emacs'
> Python mode). If something crashes, I fix the code and resubmit the
> changed parts to the interpreter.
>
> I would love to do all this inside WingIDE, but it seems that I always
> have to run the complete script, I can't just execute successive parts
> of it under debugger control. Considering that my scripts often do some
> lengthy computation in the beginning (e.g. loading a big protein
> structure, which can easily take a minute or two), having to start from
> scratch for every change slows down development beyond my patience.
>
> Any ideas?

I work similarly and have so far (more or less) satisfied my needs with:

1) The Python Shell tool, where I try things out that don't require a lot
    of setup or environment (as far as imported modules, initialization,
    etc).

2) The Debug Probe (Wing Pro only), where you can run to a breakpoint or
    exception in your debug process and then execute code in the context
    of your currently selected stack frame.  This is useful together with
    conditional breakpoints to get to the particular case/state for which
    you're trying to write some code.

3) On occassion, I just write code in small bits and debug that instead
    of launching a whole app into the debugger.  A good way to do this is
    by writing unit tests and developing the code against the unit tests
    first, and then trying it in the context of the whole app.

Both (2) and (3) will benefit once we allow multiple debug processes at
once so you don't have to exit your play space to try the code in the
context of your real app.

>From what you write, the Debug Probe is probably what you want (you can 
load your protein structure once and try different things against it). 
However, we'ld be interested in any suggestions for other capabilities that 
might make your work easier.

Thanks for using Wing.

Stephan Deibel

--
Wingware
Wing IDE for Python
Advancing Software Development

www.wingware.com


More information about the wingide-users mailing list