On programming languages belonging (or not) to their community
For example, C and especially C++ are community languages and this shows in what gets added to their standards. You can find a lot of people who think that C++'s growth is not a good thing. Go is unlikely to grow that way partly because the Go core team is willing to do nothing.
There are language communities and standards committees that are willing to do nothing, but generally there are lots of voices for doing something and so something gets done. Once you're a community thing, saying 'no, we're not doing anything' is very hard.
C++ is my canonical example of a language that definitely belongs to its community, for better or worse. There are several major implementations, two of which are themselves genuine community projects, and the direction of C++ is set by an open standards committee with a relatively distributed membership. C++ is also a famously complicated language which has had major changes over the years that have apparently significantly affected how you should write C++ code today, and I've read any number of gripes about the directions in which it's moving and whether or not future changes are good ideas (including Bjarne Stroustrup himself, per Remember the Vasa! [PDF] (via)).
Some of this is due to C++'s specific situation, but beyond that I think that communities have structural influences that make it hard for them to avoid heading in this direction. There are always loud people who have ideas and in general it is hard for a community to consistently say 'no, we're not doing anything', especially in a fuzzy situation; for example, often there is social pressure to give sufficient justification for your refusal to take action. In one way, the big advantage that languages with some form of control by a benevolent dictatorship have is that there are people who can say 'no' over and over again and get away with it.
(It helps a great deal if these people have good taste and say no to the right things, of course. But saying 'no' to everything can work too, if the language is in the right shape to start with. You may miss out on useful advances, but at least you won't ruin the good things that the language already has.)
The two obvious problems with a benevolent dictatorship are the other sides of this. A benevolent dictatorship can ram through a change even when it's a bad idea, and they can stop changes that are good ideas. The more that a language genuinely belongs to its community, the more the language will reflect what the community wants and needs (or thinks it does), rather than what some people think the community should have (for its own good). Just ask people about Python 2 and Python 3 for an illustration of that.
(Even when a forced change is theoretically a good thing, it has social and pragmatic effects on the community of people using the language that can be overlooked or waved away by the enthusiasts at the center of their language. You can get rousing debates over whether the pain is 'worth' the end result, but it is undeniable that pain was inflicted.)