2 ms·
I'm not in that situation, virtually the whole software industry is in it. If you think "policies" can address that, we have a very different worldview. The re
by gruseom 17y ago
I'm not in that situation, virtually the whole software industry is in it. If you think "policies" can address that, we have a very different worldview.
The real point though (which remains unaddressed) was that the argument against higher-level abstractions is wrong because it assumes that what is true of a single function written at a certain level of abstraction will remain true if you try to build an entire complex system out of them. It won't. Therefore, as complexity grows, we need the ability to create new abstractions. There is something perverse about the argument that we should eschew powerful techniques for doing this because they'll make large systems hard to understand. It's like saying we should avoid water because dehydration is bad.
- rbanffy 17y agoI only jokingly implied you could be in such a mess. I also can assure you it's not the _whole_ industry. Some of us employ techniques that make it easier to maintain large chunks of code. I refrain to describe them as complex because complexity is something to be avoided like the plague.
- rbanffy 17y agoIsn't it nice to be able to disagree by modding down instead of engaging in an active argument?
- gruseom 17y agoIt's a legitimate way to disagree, as has been made clear here on many occasions. Besides, sometimes it's better not to engage in an active argument. For example, my contributions to this thread were borderline over-participation.
- rbanffy 17y agoThere should be no such thing as "over-participation". As long as you have something to say: as I implied - at least one group I participate in has managed to have a very large and long lived codebase that has little to no signs of the cruft described in the thread head. Careful choice of languages, paranoid test coverage evaluation, commit policies (like "you only merge into head if all the tests pass and no function is left untested"), extensive code reviews (one could go as far as do pair-programming all the time) and relentless refactoring and feature removal can get you very far. You can think of the current *BSD codebases as direct descendants of the original AT&T UNIX codebase that have survived by employing one or more of the techniques I mentioned in the previous paragraph.