@whale-av @ben.wes @ddw_music
I am learning about dynamic patching. The documentation describes instance specific dynamic patching as being able to send messages to a specific instance of an abstraction, by renaming the abstraction using namecanvas. The renaming can be automated using $0 expansion.

I am not familiar with where to locate namecanvas and how to use it and I am not familiar with how to use $0 expansion. Can someone please show a complete visual example of how to use instance specific dynamic patching using the exact instructions given in the documentation link?
https://puredata.info/docs/tutorials/TipsAndTricks#instance-specific-dynamic-patching

And can someone show a visual example of how to use dynamic patching to dynamically create instances of an object in an abstraction? For example, if I create a patch with a sine oscillator that can be assigned a frequency, an amplitude, and has a dac object and then make that patch an abstraction how would I be able to use dynamic patching to allow my gui to let me assign a new sound source in place of the sine oscillator? Objects like the switch object have limitations. I would want to be able to assign/unassign any number of new sounds sources in place of the sine oscillator. For example a phasor object, a noise object, or even synthesizer patch abstraction. Suggestions for other ways to do this are good and I also want to be sure to have explanations for using dynamic patching since that is what I am learning. How could this be done using dynamic patching?

General Dynamic Patching
What is the difference between pd messages and patch messages? Are they both used for dynamic patching? And how are they different from instance specific dynamic patching?
https://puredata.info/docs/tutorials/TipsAndTricks#pd-messages
https://puredata.info/docs/tutorials/TipsAndTricks#patch-messages

I'm afraid I know next to nothing about dynamic patching... sorry but there's not much I can do here.

hjh

@Muology Generally it is better to stick a subpatch in the abstraction and do your dynamic patching in there so you can exploit the [clear( msg, method is about the same, don't need to keep track of object numbers as closely but sometimes it is the only way. iemguts is worth exploring if you are getting into dynamic patching.

dyn-abs.pd
dyn-abs-test.pd

Edit: Forgot the patch message question. PD messages send interface commands like save or open, patch messages are the dynamic patching messages, these are better found from opening patch files in a text editor or you can use my look abstraction, with it you can get you exact messages needed for any give dynamic patching, just patch together what you want to dynamically create in an empty patch or subpatch, create the [look] abstraction then select everything but it and control click the bang, your messages and their connects will print to the log for you to copy. It is important that [look] is created last other wise it will screw up your connect messages but it does number the objects for you so not difficult to adjust them as needed so you can even skip using an empty patch/subpatch without much fuss.

@Muology You can get more info on dynamic patching here........ https://forum.pdpatchrepo.info/topic/10813/collection-of-pd-internal-messages-dynamic-patching/4 and in that thread.
To replace just one object in an abstraction is complicated.... you have to find it and cut it..... using [find( [findagain( and [cut( messages........ then put your new object...... and then connect it.
To connect it you need to know it's object number (it's place in the order of creation of objects in the patch... starting at 0) .... and the object numbers of the objects you want to connect it to.

That is not really worth the bother.
As @oid says.... it is easier to clear the contents and use a message to replace everything you can do that in any canvas)..... but...
It is easier still to replace the abstraction with another..... but then you still have to reconnect it within your master patch...... so...
Replace the whole abstraction.... and use [send] [send~] etc. rather than [outlet] [outlet~] etc. so that you don't have to reconnect.

You don't need to use [namecanvas].... you can send messages to patches and sub-patches and arrays by their current name. $0 is an automatically assigned value greater than 1000 assigned to every canvas as it is opened (created). You can get its value by.......
[loadbang]
|
[$0]
|
[numberbox]
...... as it could well change when you reopen the patch (if for example you have opened another patch first).
So it can be used but it is better to actually give fixed arguments to your abstractions using $1 $2 etc using a counter as you create them.

My opening post here....... https://forum.pdpatchrepo.info/topic/9774/pure-data-noob contains a dynamic patch builder....... build_voices.pd .... which will help you to see how it can be done...... although I didn't show how to remove the objects you will be able to calculate their object numbers and cut them.
Further down that thread I attempted to thoroughly explain $0 $1 $2 etc...... "show me dollars".

For your particular purpose...... this.zip
A simple example, that you can build on once you learn a bit more.
Happy dynamic patching....

David.

@oid
Why does dyn-abs$0 appear twice but one is in a box (on the left) and one is not?
Is your example using regular pure data primitives?
What is iemguts?

Can you please explain the programming in the dyn-abs.pd patch and the dyn-abs-test.pd? What is the difference between the two and what is the end goal of these two patches? What is the dynamic patching concept being done here? Is one an abstraction and one a sub patch? I am new to this so please explain in a fundamental way.
?
dyn-abs-test.pd
dyn-abs$0 (in a box)
r $register
t b a
msg 10 10 hello abstraction
s

?
dyn-abs.pd
dyn-abs$0
hello abstraction
loadbang
symbol $0canvas
s $1register
namecanvas $0canvas

@Muology A $0 in an object (a box) gets its value assigned as the patch is created..... so as it is the argument for [dyn-abs $0]..... there is a space between dyn-abs and $0..... the value becomes the value of $1 (the first argument) inside the [dyn-dns $0] abstraction.
Then the sends and receives.... [s $1register] and [r $0register] become identical and can communicate.
The same is not true in a message box.... $0 will have the value 0...... not useful.
Please read this.....
https://forum.pdpatchrepo.info/topic/9774/pure-data-noob/4
David.

@Muology the dyn-abs on the right is just showing what is in the abstraction [dyn-abs]. If you open dyn-abs-test.pd you will see that box on the right is not there and nor is the abstraction [dyn-abs]. If you open dyn-abs.pd you will see that the message [hello abstraction( is not there, it is created when you run the abstraction. Sort of a way to self document things, it all ends up in the screenshot and is clearly labeled. It will make more sense once you learn to read patches.

Open [dyn-abs-test] and create a new object, name it dyn-abs $0 and then open the abstraction by control clicking on it or right clicking and selecting open, you will see that the message is now there, it was dynamically created by dyn-abs-test.pd. On creation the abstraction sends its unique canvas name as set by [namecanvas] to $1register, $1 being the $0 of the patch which the abstraction is in since $0 is the first argument passed to the abstraction. That name goes to the right inlet of the [send] in dyn-abs-test.pd so we can send the message [msg 10 10 hello abstraction( to the canvas of the most recent instance of [dyn-abs] which creates the massage in the abstraction. Normally you would store each abstraction's unique canvas name in something like a [text] or [list store] so you can retrieve the proper canvas name for the instance of the abstraction you desire to alter. Or you could send to pd-dyn-abs and alter all copies of the abstraction at once as David mentioned, this can get very messy very quickly if you are also altering them each individually. Best path depends on what you are trying to do.

iemguts is a library of externals which makes most everything regarding dynamic patching easier, it can be installed with deken by going to the help menu and clicking on "find externals."

Believe the rest was answered more or less? I did start on a dynamic patching tutorial a few days ago but no idea when it will be done, made a good amount of progress so far but need to do all the text. Kind of fun to do, the tutorial itself is dynamically patched.