Hi everyone,

I'm new here and relatively new to Pd, though I'm a long time programmer with a vfx development background (in addition to being a musician, of course). So this may be an incredibly stupid question but: How the hell do you "comment out"/deactivate/turn off parts of a patch short of deleting it? I've been driving myself crazy having to completely cut out pieces of graphs and set them aside, then reconnect the remaining portion, then disconnect it again and then reconnect the code I set aside or simply delete them altogether for debugging because there's no way to turn them "off". I've looked everywhere online, including the loadbang book, but I can't find anywhere that explains how to do it. Or maybe I'm doing it wrong and that is not the paradigm. Please point me to the Pd-idiomatic way of doing this if not. Thanks!

There are many ways to do so. I guess [spigot] could be useful in some cases. You can also use [route] to send the data to the desired part of your patch. Maybe you should think in terms of "not sending the data" to some part of your patch instead of trying to "deactivate" it.
Lucien

What I told you would work for control data, but maybe you're talking about signal data, I think you should post your patch and ask for more precise advice.

Thanks Lucien. I would rather not post a patch because people are then going to give me a way to do it for that specific patch and that's not what I'm asking. By your comments, I'm guessing there's not a way to do what I'm asking. If we were programming in code we'd do something like this:

// program is throwing an error, I suspect the following block is the culprit,
// so I comment it out. I can simply remove the "//" when I'm done to return
// the program to where it was.

//if (self) {
// _sequence = [self.sequenceLookup objectForKey:[self signature]];
//}

In Pd what I'm asking is if you have a branch of processing "A" that follows a wire to another input to another branch of processing "B" which flows through another wire to a branch "C":

A-->B-->C

If I suspect B is problematic, or I simply want to see what the result of A sent to C will be without B's contribution, is there a way to keep the flow from A-->C intact, but functionally remove B without deleting the connections between A-->B and B-->C, then moving B aside, then connecting A-->C. And then, when I'm done, I will have to delete the connections from A-->C and connect A-->B then B-->C again. It's extremely tedious and time consuming to do this. It would be tantamount to cutting out my block of code in the programming example above, pasting it into a separate text file, running the program, then copying the code snippet from the external file back into the program when I'm done testing. [route] and [spigot] could be used in certain cases, but that would be more like "unit testing" than commenting as you'd have to plan out your scenario ahead of time.

Ok, I think I understand what you mean now. Let's say the ouptput of A and B is a [send] object, you can direct the data either from A directly to C or thru B quite simply. You just have to send [send]'s right inlet (in both A and a different symbol, corresponding to the data flow you want. This way you can switch from A->B->C to A->C in just one click. Tell me if you don't see how to do it, i'll send you an example.
Lucien

It is deceivingly simple:

[moses 42]
|
[some]
|
[likely]
|
[bug]
|
[culprit]

becomes...

[moses 42]

[some]
|
[likely]
|
[bug]
|
[culprit]

In other words, just snip the wire at the beginning of the branch. It's equivalent to a '/*' in C that automatically inserts a '*/' at the place where the branch terminates.

As for A-->B-->C, keep in mind that the brackets within a C function are equivalent to a [pd] subpatch in Pure Data. That gives you less granularity than a text-based language, but it will force you to make 'B' modular so that hooking A up to C is hopefully just reconnecting a single wire. (And of course there are abstractions if you want those modules to be reusable.)

A good rule of thumb is that if you find yourself wanting to continue a chain of objects past the size of the canvas window, you probably need to organize what you have into subpatches or abstractions.

jancsika you're right I guess I didn't think of that! Since I'm new to Pd, I still see the remaining portions of the branch as "active" or "contributing" even though there's no data flowing through it once you've removed the input. LucienR I'm not quite sure if I follow you, could you send me that example? Thanks for the help guys!

Ok here is a simple example. Part A creates a sequence of 0 and 1, and part B is just a ramp. When you click the toggle, the [send] object in part A receives a symbol and the data flows through part B. This is one way among many others to achieve this.
Lucien

http://www.pdpatchrepo.info/hurleur/abc.pd

LucienR thanks for that example. For some reason I was not originally able to open it; it just opened a box with a number input and that was it... but I was just able to get it to work just now. This is really helpful. Very cool!