The Gang of Four book is wrong about delegation (2012)

Post by josteink » Thu, Jun 29, 2017, 7:59 PM UTC

favorited wrote: post #3

> If the message is delegated further, all questions about the values of variables or requests to reply to messages are all inferred to the object that delegated the message in the first place. I'm not sure how the author jumps from that quote to: > When that object delegates to another, then any reference to "self" always refers to the original message recipient. Always. The high-order bit is that the delegating obj…

Post by geezerjay » Thu, Jun 29, 2017, 8:05 PM UTC

norswap wrote: post #8

The Gang of Four book is terrible. The explanation are very unclear (often because of excessive abstraction, even in the description and discussion). It's been a long time so my memory is hazy on its particular sins, but I've vowed never to touch it again. I never understood what anyone saw in that book (except that it was one of the first book on the topic of design patterns).

Post by Denzel » Thu, Jun 29, 2017, 8:12 PM UTC

eropple wrote: post #5

steego wrote: post #2

I'd hate to be the Gang of Four, especially since they wrote their book 20 years ago. Since then numerous people (including myself) have discussed how to evolve some of their ideas given today's landscape. My position is many ideas are still valid in their book, but they are less novel today and are often implemented with simpler tools. I'm sure the Gang would concur. Other ideas may be less valid over time and I'd b…

I forget who said it, but I ascribe to the notion that most design patterns exist to work around insufficiencies in languages or ecosystems. To that end, a lot of them totally still exist--they've just been reduced in difficulty and ceremony, as you mention. The command pattern, for example, is literally just a closure.

Post by humanrebar » Thu, Jun 29, 2017, 8:39 PM UTC

    #include 
    #include 

    struct Container {
        template 
        void announce(Self const & self) const
        {
            std::cout  announce;

        template 
        explicit Bucket(
            Delegate const & delegate,
            std::string const& aThings) :
                things(aThings),
                announce([&](){ delegate.announce(*this); } )
        { }
    };

    int main()
    {
        // Container works with anything with a 'things'
        // attribute
        Container container;
        // Bucket takes anything with an announce method
        // that accepts a Bucket-like object
        Bucket bucket(
            container,
            "planes, trains, and automobiles"
        );
        bucket.announce();
        return 0;
    }

Post by steego » Thu, Jun 29, 2017, 8:50 PM UTC

InclinedPlane wrote: post #16

steego wrote: post #2

I'd hate to be the Gang of Four, especially since they wrote their book 20 years ago. Since then numerous people (including myself) have discussed how to evolve some of their ideas given today's landscape. My position is many ideas are still valid in their book, but they are less novel today and are often implemented with simpler tools. I'm sure the Gang would concur. Other ideas may be less valid over time and I'd b…

Same problem a lot of good ideas have (like unit testing or agile), an idea meant to be evolved and applied thoughtfully instead becomes ossified instantly and applied mindlessly, with many mistakes, and zealously. The concept of design patterns is highly useful. The particular patterns in one book would always be of limited usefulness. Often times devs are more eager to prove their smarts than to get a job done well…