Click here to Skip to main content

Leslie Sanford - Professional Profile

@Leslie-Sanford

Summary

62,724
Author
2,559
Authority
3,897
Debator
120
Enquirer
240
Organiser
2,158
Participant
0
Editor
Aside from dabbling in BASIC on his old Atari 1040ST years ago, Leslie's programming experience didn't really begin until he discovered the Internet in the late 90s. There he found a treasure trove of information about two of his favorite interests: MIDI and sound synthesis.
 
After spending a good deal of time calculating formulas he found on the Internet for creating new sounds by hand, he decided that an easier way would be to program the computer to do the work for him. This led him to learn C. He discovered that beyond using programming as a tool for synthesizing sound, he loved programming in and of itself.
 
Eventually he taught himself C++ and C#, and along the way he immersed himself in the ideas of object oriented programming. Like many of us, he gotten bitten by the design patterns bug and a copy of GOF is never far from his hands.
 
Now his primary interest is in creating a complete MIDI toolkit using the C# language. He hopes to create something that will become an indispensable tool for those wanting to write MIDI applications for the .NET framework.
 
Besides programming, his other interests are photography and playing his Les Paul guitars.
Member since Monday, August 5, 2002 (12 years)

 

Contributions

Articles 18 (Legend)
Tech Blogs 0
Messages 1,537 (Master)
Q&A Questions 0
Q&A Answers 0
Tips/Tricks 0
Comments 0

Links

Reputation

For more information on Reputation please see the FAQ.

Privileges

Members need to achieve at least one of the given member levels in the given reputation categories in order to perform a given action. For example, to store personal files in your account area you will need to achieve Platinum level in either the Author or Authority category. The "If Owner" column means that owners of an item automatically have the privilege, and the given member types also gain the privilege regardless of their reputation level.

ActionAuthorAuthorityDebatorEditorEnquirerOrganiserParticipantIf OwnerMember Types
Have no restrictions on voting frequencysilversilversilversilverAdmin
Store personal files in your account areaplatinumplatinumSitebuilder, Subeditor, Supporter, Editor, Staff
Have live hyperlinks in your biographybronzebronzebronzebronzebronzebronzesilverSubeditor, Protector, Editor, Staff, Admin
Edit a Question in Q&AsilversilversilversilverYesSubeditor, Protector, Editor, Admin
Edit an Answer in Q&AsilversilversilversilverYesSubeditor, Protector, Editor, Admin
Delete a Question in Q&AYesSubeditor, Protector, Editor, Admin
Delete an Answer in Q&AYesSubeditor, Protector, Editor, Admin
Report an ArticlesilversilversilversilverSubeditor, Mentor, Protector, Editor, Staff, Admin
Approve/Disapprove a pending ArticlegoldgoldgoldgoldSubeditor, Mentor, Protector, Editor, Staff, Admin
Edit other members' articlesSubeditor, Protector, Editor, Admin
Create an article without requiring moderationplatinumSubeditor, Mentor, Protector, Editor, Staff, Admin
Report a forum messagesilversilverbronzeProtector, Editor, Admin
Create a new tagsilversilversilversilverAdmin
Modify a tagsilversilversilversilverAdmin

Actions with a green tick can be performed by this member.


 
GeneralApplying Generic Programming to Runtime Polymorphism PinmemberLeslie Sanford22-Feb-10 10:28 
One thing that's been a stumbling block to me in C++ is the tension between compile time polymorphism (or static polymorphism) and runtime polymorphism (or dynamic polymorphism).
 
Compile time polymorphism is done via templates; the decision about which type to use is decided when the program is compiled. Runtime polymorphism is done via virtual methods. The decision about which type to use is decided as the program is running.
 
These two approaches seem to be orthagonal(?) to each other.
 
I was (re)watching a video[^] on YouTube. It's a presentation by Sean Parent of Adobe. He's "a principal scientist at Adobe Systems and engineering manager of the Adobe Software Technology Lab." The entire video is interesting. He talks about generic programming and also designing software components that are connected together to form a directed acyclic graph.
 
There's a point in the video that has intrigued me ever since I first saw it. There's a bullet point (which unfortunately Sean doesn't elaborate on) that says: "Extend generic programming to apply to runtime polymorphism."
 
Ah, this seems to be getting at that tension I mentioned early between compile time and runtime polymorphism.
 
So I did some googling and found an interesting paper[^] describing a design pattern called External Polymorphism. This seems to provide a structure for merging generic programming with runtime polymorphism.
 
I won't describe the pattern, but I can describe how I applied it to writing VST plugins. The following assumes a basic knowledge of the VST v2.4 SDK, but hopefully you'll be able to follow along without being familiar with it.
 
Say you have a bunch of objects that you've created on the heap, e.g. you created them in createEffectInstance and then passed them to other objects that interact with them. The lifetime of these objects is the same as that of the plugin. You'd like a reuseable, generic way to dispose of them. Here's an approach using External Polymorphism:
 
class DisposableInterface
{
public:
    virtual ~DisposableInterface()
    {
    }
};
 
template<class T>
class Disposable : public DisposableInterface
{
public:
    Disposable(T *target)
    {
        this->target = target;
    }
 
    ~Disposable()
    {
        delete target;
    }
 
private:
    T *target;
};
 
Ok, in our base Plugin class we have a method for passing any object that will be garbage collected when the Plugin itself is destroyed:
 
class PluginBase : public AudioEffectX
{
public:
    virtual ~PluginBase()
    {
        std::list<DisposableInterface *>::iterator it;
 
        for(it = objects.begin(); it != objects.end(); it++)
        {
            delete *it;
        }
    }
 
    // Stuff...

    template<class T>
    void AddToGarbageCollector(T *object)
    {
        objects.push_back(new Disposable<T>(object));
    }
};
 
AudioEffect *createEffectInstance(audioMasterCallback audioMaster)
{
    Plugin *plugin = new MyPlugin();
 
    Lfo *lfo = new Lfo();
    AdsrEnvelope *env = new AdsrEnvelope();
    Oscillator *osc = new Oscillator(lfo, env);
 
    plugin->AddToGarbageCollector(lfo);
    plugin->AddToGarbageCollector(env);
    plugin->AddtoGarbageCollector(osc);
 
    // Stuff...

    return plugin;
}
 
Now, you may never need this kind of memory management, so don't get tripped up on the example. The main point is that we can treat "concrete types" polymorphically. We don't have to make sure that they implement a particular base class.
 
I'm not recommending using this approach to replace virtual methods in all classes, but I prefer to write my low-level classes without them. And I occasionally need to iterate over a collection of these concrete objects for one reason or another, e.g. updating the sample rate or whatever. As long as they meet the requirements of the algorithm that's being applied to them, e.g. provide a method or operators with specific signatures, this technique can be applied to fascilitate this.
 
Like...
 
class PluginBase : public AudioEffectX
{
public:
 
    template<class T>
    void AddTempoTarget(T *object)
    {
        tempoTargets.push_back(new TempoTarget(object));
    }
};
 
Then when the tempo changes, we could do this:
 
std::list<TempoTargetInterface *>::iterator it;
 
for(it = tempoTargets.begin(); it != tempoTargets.end(); it++)
{
    (*it)->Tempo(newTempo);
}
 
As long as the target objects have a method called Tempo that takes a double (or whatever) they can be notified when the tempo changes, they don't have to inherit from a specific class.
 
Anyway, this was a puzzle that had been in the back of my mind ever since I became interested in generic programming, and especially after seeing that bullet point in Sean's video. Just something else to add to my bag of tricks.
GeneralGeneric Programming [modified] PinmemberLeslie Sanford19-Jul-08 5:53 
GeneralOff-topic PinmvpRajesh R Subramanian19-Jun-09 12:48 
GeneralRe: Off-topic PinmemberLeslie Sanford19-Jun-09 19:06 
GeneralEnsuring Object State [modified] PinmemberLeslie Sanford27-Jun-07 8:00 
GeneralEvolution of Messaging PinmemberLeslie Sanford19-Oct-06 5:15 
GeneralEnumerators as Synthesizer Components PinmemberLeslie Sanford20-Sep-06 20:53 
GeneralAnonymous Methods as Glue PinmemberLeslie Sanford17-Sep-06 14:30 
GeneralRefining the approach PinmemberLeslie Sanford22-Jan-06 7:52 
GeneralFlowing down the Sink PinmemberLeslie Sanford21-Jan-06 16:45 
GeneralFlow-Based Programming in C# PinmemberLeslie Sanford29-Dec-05 13:07 
GeneralCombining Visitor, Observer, and Iterator PinmemberLeslie Sanford25-Dec-05 21:29 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.


Advertise | Privacy | Mobile
Web01 | 2.8.140827.1 | Last Updated 1 Sep 2014
Copyright © CodeProject, 1999-2014
All Rights Reserved. Terms of Service
Layout: fixed | fluid