TX:
I agree with Hokie. The ACI318-63 code is the one he and I both learned to use first, and at that time everyone pretty well understood the intent, rational, and the fundamental engineering principles and materials considerations involved in the design process, we were taught that. And, the next couple editions where pretty straight forward extensions of the previous editions, given what we had learned over the intervening years. Occasionally there was a free or inexpensive addendum because a significant issue came to light. We also read the tech. literature to keep abreast of the latest research and thinking. Without the need for a full blown code revision, every few years, these new ideas, once vetted, could be applied at our (the engineer’s) discretion. It wasn’t until code writing became a cottage industry unto itself, and that publishing frequently to support that industry and to provide full employment for some, became an end in itself, that things got out of hand for the practicing engineers. For all the confusion and complexity, extra expense of new codes and standards, we are not really producing better structures, nor are old structures falling down around us for lack of this complexity having been applied.
I also agree with the type of logic expressed in your last paragraph ‘Minimum reinforcement provisions...., so put in this minimum amount.’ We should be teaching this kind of fundamental thinking and logic (common sense) to young engineers, rather than adding another 35 pages of disjointed B.S. to the code to try to cover that; one section referring to four other sections, which refer to...., etc., and then around again, to get to the same logical solution. The problem with all the codes is that their complexity, arbitrary new factors and variables, use of other codes and standards by reference, pretty much baffles any logic, common sense or engineering judgement and experience factors. We spend all our time, when trying to use the codes trying to be sure that we have applied and understand ever new phe, phi, pho & phum, and literally end up losing sight of the real engineering principles involved in the solution of the problem. I suspect many engineers will attest to this, we aren’t doing engineering any longer, we are just following an ever more complex set of cookbooks, and then debating how much a pinch of salt really is, without knowing what the hell we are actually cooking.
While codes may be “complicated for reasons,” which are not always obvious to the experienced engineer any longer, they certainly have strayed from their intended purpose in their development and that process. The best codes are the cleanest, simplest codes possible, and that should be the code writers foremost duty and focus; so, clean up “the layout and location of the provisions,” and get rid of “the irrelevant minutia.” Their job should not be complexity to assure self employment preservation, or to complicate the practicing engineer’s life, or for no real improvement in final product. Once the intent of various code sections and concepts is taught and understood, the code should become a background document referred to for truly difficult conditions. There are plenty of times a complexity crops up in one of our designs, and we should be smart enough as engineers, to know that we must dig a little deeper to solve this one to our own satisfaction and for the public safety. Then the extra complexity is appropriate and brought on by our own design. But, 90% of what we design should not have to be dragged through this swamp of crap, just to justify a simple spread footing, as in this case. We shouldn’t be working in fear of missing some obscure factor slipped into the latest code, and causing some major problems or legal action. Rather, our work should be a continuous learning and educational process to really improve the product we design, and to more fully understand what we do and why.
I certainly hope you are on the code writing committee or have some direct input, because you seem to apply some common sense to the process, and seem to understand our difficulties. Codes are not an end in themselves, they are a means to an end, and should not overly complicate the process of getting there. They ill never be made to cover every condition under every possible situation, so let’s quite trying to have them do that. That’s what engineering judgement and experience are supposed to cover. And, maybe everyone won’t be qualified to design everything and anything, without some experienced supervision, and more complex codes won’t change this situation or dynamic.
