Spyder debugging can be a little confusing at first, but I can assure you that you can get used to it and be productive.
When you start debugging, the first (non-comment) line of code is the 'current line'. The current line is the next line to be submitted to the interpreter if you 'step', or the first line to run if you 'continue'. Unfortunately, Spyder uses the same line highlighting for the current debug line as it does for the currently selected line. So if you click on the script, you will lose the highlighting for the current debugging line until you step or hit a breakpoint and a new current line is highlighted. So just avoid selecting a new line in the IDE until you first identity (and remember) the current debug line (and as mentioned you can use 'list' to remind you which line it is on).
Also, the debugger will only stop on the next line in your script if you step, or on the next breakpoint if you continue (or if it is hit during a step). If control in your code passes out of your module (such as a return or uncaught exception thrown out of the root block of your main module), then debugging is complete, and there is no current line. Since Spyder provides very little visual feedback that it is currently debugging, if you don't realize that it happened it can be confusing. So it is normally a good idea (for more than just debugging) to make sure that all of your code is run in a try-except block, and either put a breakpoint or a messagebox in the except block so while debugging you can see if your script is about to error out and stop debugging.
The variable explorer in Spyder is really more useful for the POD variables you might define. It is not really all that useful to browse the property values you might get if you invoked all the properties on an API reference. You can get spoiled if you are used to debugging in JavaScript. When displaying the attributes of an object in JavaScript, it actually invokes the property accessors for every property and displays the results. But debuggers like Spyder and C++, typically do not do this (as it changes the current stack frame, so you would lose the context of where you are currently broken). So when you look at references to interface objects, there typically isn't anything very interesting to see on them (other than the member function references). So in launguages like C++ or Python, you can only see an interface instances properties if you explicitly call those property accessor functions.
Kris
Kris Kaplan