Do you really want to introduce this sort of complexity into every topic we discuss? Will this really make our discussions more comprehensible?
Well, yes, definitely yes!
To me, it is obvious that increasing the cognitive complexity of our conversations is something which ought to be done with only the greatest of consideration and necessity, and at each moment we should take the utmost care to add only the necessary amount of complexity, and no more. What you propose would seem to add a lot of cognitive complexity, for questionable benefit.
Hardly any programmer today would argue that we should use only global variables to escape the confusion of scope. Far sooner would a programmer tell you to never declare globals at all, and stick to local scope. Scope is just so convenient. We should avoid practices which make understanding scope difficult, like the examples you mention, but that is a matter of good style. Scope itself is invaluable.
Well, making the “argument from current programming practices”, as it were, is perilous, because many current programming practices are deeply misguided and have fundamental and far-ranging problematic effects.
You might guess, from the above line, that I’m making a fairly trivial point about passing fads in technology (to be followed up, perhaps, by a jab at Scrum). I’m not. The issue at hand is this: programming is extremely complex. It is growing more so, by the year and by the month. To say that not every person possesses the cognitive capacity to hold such vastly complex abstract structures in their mind, and to comprehend their workings, is to vastly understate the matter.
Scope helps, yes. But scope is more confusing than namespaces, and namespaces are more confusing than simple globals (i.e., a single global namespace). These things are necessary because our code is so complex. They are not themselves an improvement in terms of comprehensibility. A much simpler code base, in a much simpler language, can and should use globals. It’s easier.
You propose to greatly increase the complexity of our conversations, and then, to manage that complexity, to introduce all the vagaries of variable scope. I say: take two steps back. Curb the complexity, and relieve yourself of the need for lexical scope.
Well, making the “argument from current programming practices”, as it were, is perilous, because many current programming practices are deeply misguided and have fundamental and far-ranging problematic effects.
Yeah, better for me to say that I personally agree with this practice (and would strongly disagree with the alternatives I could think of) than to rely on the authority of common consensus.
You propose to greatly increase the complexity of our conversations, and then, to manage that complexity, to introduce all the vagaries of variable scope.
Rather: I claim my conversations are ordinarily this complex. In those cases where conversation participants insist on consistency with the global namespace, I find those conversations less valuable and harder to make progress in. When I originally called out the use-of-words issue in our previous conversation, it wasn’t because I think this is a thing most people are doing wrong that I want to set them straight on; rather, I think most people I talk to do the thing I’m suggesting, but might have less of an explicit model than I do. (Thinking of words as existing in a global namespace, or that plus a small number of specialized namespaces, is a reasonable default model to have if you don’t look at all the namespacing you do.) I’m experimenting with explicitly calling it out as a strategy for conversations that don’t work that way.
I say: take two steps back. Curb the complexity, and relieve yourself of the need for lexical scope.
What simplification strategies would you suggest? Obviously it would be a good thing to have better strategies for freeing up more computation for what matters; it’s just been my experience that “scope” type behavior is what manages to free up the most computation.
Scope helps, yes. But scope is more confusing than namespaces, and namespaces are more confusing than simple globals (i.e., a single global namespace). These things are necessary because our code is so complex. They are not themselves an improvement in terms of comprehensibility.
They are in themselves an improvement all other things being constant; IE, I’d need to make some other (and rather dramatic) change in my coding practices before it would be an improvement to use all globals. (I am speaking literally here, although it is also a good analogy for what I was saying earlier.)
What simplification strategies would you suggest? Obviously it would be a good thing to have better strategies for freeing up more computation for what matters; it’s just been my experience that “scope” type behavior is what manages to free up the most computation.
Less abstraction. Less indirection. More examples. Way more examples. Way more attention paid to whether you can think of good examples. More concreteness. Extensions over intensions.
That’s just off the top of my head. This particular cluster of problems is huge, in recent rational-sphere discourse. There are others, no doubt.
To me, it is obvious that increasing the cognitive complexity of our conversations is something which ought to be done with only the greatest of consideration and necessity, and at each moment we should take the utmost care to add only the necessary amount of complexity, and no more. What you propose would seem to add a lot of cognitive complexity, for questionable benefit.
Well, making the “argument from current programming practices”, as it were, is perilous, because many current programming practices are deeply misguided and have fundamental and far-ranging problematic effects.
You might guess, from the above line, that I’m making a fairly trivial point about passing fads in technology (to be followed up, perhaps, by a jab at Scrum). I’m not. The issue at hand is this: programming is extremely complex. It is growing more so, by the year and by the month. To say that not every person possesses the cognitive capacity to hold such vastly complex abstract structures in their mind, and to comprehend their workings, is to vastly understate the matter.
Scope helps, yes. But scope is more confusing than namespaces, and namespaces are more confusing than simple globals (i.e., a single global namespace). These things are necessary because our code is so complex. They are not themselves an improvement in terms of comprehensibility. A much simpler code base, in a much simpler language, can and should use globals. It’s easier.
You propose to greatly increase the complexity of our conversations, and then, to manage that complexity, to introduce all the vagaries of variable scope. I say: take two steps back. Curb the complexity, and relieve yourself of the need for lexical scope.
Yeah, better for me to say that I personally agree with this practice (and would strongly disagree with the alternatives I could think of) than to rely on the authority of common consensus.
Rather: I claim my conversations are ordinarily this complex. In those cases where conversation participants insist on consistency with the global namespace, I find those conversations less valuable and harder to make progress in. When I originally called out the use-of-words issue in our previous conversation, it wasn’t because I think this is a thing most people are doing wrong that I want to set them straight on; rather, I think most people I talk to do the thing I’m suggesting, but might have less of an explicit model than I do. (Thinking of words as existing in a global namespace, or that plus a small number of specialized namespaces, is a reasonable default model to have if you don’t look at all the namespacing you do.) I’m experimenting with explicitly calling it out as a strategy for conversations that don’t work that way.
What simplification strategies would you suggest? Obviously it would be a good thing to have better strategies for freeing up more computation for what matters; it’s just been my experience that “scope” type behavior is what manages to free up the most computation.
They are in themselves an improvement all other things being constant; IE, I’d need to make some other (and rather dramatic) change in my coding practices before it would be an improvement to use all globals. (I am speaking literally here, although it is also a good analogy for what I was saying earlier.)
Less abstraction. Less indirection. More examples. Way more examples. Way more attention paid to whether you can think of good examples. More concreteness. Extensions over intensions.
That’s just off the top of my head. This particular cluster of problems is huge, in recent rational-sphere discourse. There are others, no doubt.