Otherwise, think about converting some of the abstractions to subpatches
Please don't interprete what I'm gonna say as sarchastic or offensive to whom wrote the above sentence (which however has been suggested by more than one person). Just take it as a general and (hopefully) constructive discussion about PD issues...
Would you ever say to someone writing an application in C++:
"Think about converting some of your functions to macros"???
That is just not an option. And converting abstractions to subpatches is much more limiting than that.
Inefficiencies in handling a great number of instances of abstractions are a great obstacle to applying "good" programming practices to PD patches. Using and reusing a great number of abstractions with many many levels of nesting is the only reasonable way (I can think of) of developing a large, complex, scalable, reusable "application" in PD.
This reminds me about a discussion I lounched in the list some months ago about whether PD can be considered an environment for "production" development, or just a tool for "prototyping". I do use it in production, that is I use it to develop "applications" that have to be used on stage, and I don't rewrite them in any other language: I just develop them in PD and run them in PD. And that causes me a lot of frustration because I often find out that PD starts to be somewhat unstable and unreliable when things get "big". At least (or especially) when GUI is involved. Note that I do take all the care to make sure that cpu or memory usage does not increase more than it should when making things "bigger" (e.g. always switch~ing off any audio processing stuff that is not really being "used", etc.)
I would love to provide examples or specific information useful for debugging, but when I get that kind of problems, I've never been able to isolate them. In one case I had a big, complex, structured patch with a lot of stuff inside. Just adding one more instance of an abstraction there were tens of instances of (and the whole patch worked great up to that moment), made it crash on open.
Now a practical question: it has been mentioned that PD manages the patch structure with linked lists which make it inefficient in renewing it when saving an abstraction that is used many times. Does this linked-list implementation cause other efficiency issues that may affect the working of things during the normal flowing of data (i.e. running the patch) or is it "only" an issue when saving?