Complexity. Software entities are m

Complexity. Software entities are more complex for their size than perhaps any other human construct because no two parts are alike (at least above the statement level). If they are, we make the two similar parts into a subroutine--open or closed. In this respect, software systems differ profoundly from computers, buildings, or automobiles, where repeated elements abound.

Digital computers are themselves more complex than most things people build: They have very large numbers of states. This makes conceiving, describing, and testing them hard. Software systems have orders-of-magnitude more states than computers do.

Likewise, a scaling-up of a software entity is not merely a repetition of the same elements in larger sizes, it is necessarily an increase in the number of different elements. In most cases, the elements interact with each other in some nonlinear fashion, and the complexity of the whole increases much more than linearly.

The complexity of software is an essential property, not an accidental one. Hence, descriptions of a software entity that abstract away its complexity often abstract away its essence. For three centuries, mathematics and the physical sciences made great strides by constructing simplified models of complex phenomena, deriving properties from the models, and verifying those properties by experiment. This paradigm worked because the complexities ignored in the models were not the essential properties of the phenomena. It does not work when the complexities are the essence.

Many of the classic problems of developing software products derive from this essential complexity and its nonlinear increases with size. From the complexity comes the difficulty of communication among team members, which leads to product flaws, cost overruns, schedule delays. From the complexity comes the difficulty of enumerating, much less understanding, all the possible states of the program, and from that comes the unreliability. From complexity of function comes the difficulty of invoking function, which makes programs hard to use. From complexity of structure comes the difficulty of extending programs to new functions without creating side effects. From complexity of structure come the unvisualized states that constitute security trapdoors.

Not only technical problems, but management problems as well come from the complexity. It makes overview hard, thus impeding conceptual integrity. It makes it hard to find and control all the loose ends. It creates the tremendous learning and understanding burden that makes personnel turnover a disaster.

Conformity. Software people are not alone in facing complexity. Physics deals with terribly complex objects even at the "fundamental" particle level. The physicist labors on, however, in a firm faith that there are unifying principles to be found, whether in quarks or in unifiedfield theories. Einstein argued that there must be simplified explanations of nature, because God is not capricious or arbitrary.

No such faith comforts the software engineer. Much of the complexity that he must master is arbitrary complexity, forced without rhyme or reason by the many human institutions and systems to which his interfaces must conform. These differ from interface to interface, and from time to time, not because of necessity but only because they were designed by different people, rather than by God.

In many cases, the software must conform because it is the most recent arrival on the scene. In others, it must conform because it is perceived as the most conformable. But in all cases, much complexity comes from conformation to other interfaces; this complexity cannot be simplified out by any redesign of the software alone.

Changeability. The software entity is constantly subject to pressures for change. Of course, so are buildings, cars, computers. But manufactured things are infrequently changed after manufacture; they are superseded by later models, or essential changes are incorporated into later-serial-number copies of the same basic design. Call-backs of automobiles are really quite infrequent; field changes of computers somewhat less so. Both are much less frequent than modifications to fielded software.

In part, this is so because the software of a system embodies its function, and the function is the part that most feels the pressures of change. In part it is because software can be changed more easily--it is pure thought-stuff, infinitely malleable. Buildings do in fact get changed, but the high costs of change, understood by all, serve to dampen the whims of the changers.

All successful software gets changed. Two processes are at work. First, as a software product is found to be useful, people try it in new cases at the edge of or beyond the original domain. The pressures for extended function come chiefly from users who like the basic function and invent new uses for it.

Second, successful software survives beyond the normal life of the machine vehicle for which it is first written. If not new computers, then at least new disks, new displays, new printers come along; and the software must be conformed to its new vehicles of opportunity.

In short, the software product is embedded in a cultural matrix of applications, users, laws, and machine vehicles. These all change continually, and their changes inexorably force change upon the software product.

Invisibility. Software is invisible and unvisualizable. Geometric abstractions are powerful tools. The floor plan of a building helps both architect and client evaluate spaces, traffic flows, views. Contradictions and omissions become obvious. Scale drawings of mechanical parts and stick-figure models of molecules, although abstractions, serve the same purpose. A geometric reality is captured in a geometric abstraction.

The reality of software is not inherently embedded in space. Hence, it has no ready geometric representation in the way that land has maps, silicon chips have diagrams, computers have connectivity schematics. As soon as we attempt to diagram software structure, we find it to constitute not one, but several, general directed graphs superimposed one upon another. The several graphs may represent the flow of control, the flow of data, patterns of dependency, time sequence, name-space relationships. These graphs are usually not even planar, much less hierarchical. Indeed, one of the ways of establishing conceptual control over such structure is to enforce link cutting until one or more of the graphs becomes hierarchical. [1]

In spite of progress in restricting and simplifying the structures of software, they remain inherently unvisualizable, and thus do not permit the mind to use some of its most powerful conceptual tools. This lack not only impedes the process of design within one mind, it severely hinders communication among minds.

Kết quả (Anh) 1:

Complexity. Software entities are more complex for their size than perhaps any other human construct because no two parts are alike (at least above the statement level). If they are, we make the two similar parts into a subroutine--open or closed. In this respect, software systems differ profoundly from computers, buildings, or automobiles, where repeated elements abound.Digital computers are themselves more complex than most things people build: They have very large numbers of states. This makes conceiving, describing, and testing them hard. Software systems have orders-of-magnitude more states than computers.Likewise, a scaling-up of a software entity is not merely a repetition of the same elements in larger sizes, it is necessarily an increase in the number of different elements. In most cases, the elements interact with each other in some nonlinear fashion, and the complexity of the whole increases much more than linearly.The complexity of software is an essential property, not an accidental one. Hence, descriptions of a software entity that abstract away its complexity often abstract away its essence. For three centuries, mathematics and the physical sciences made great strides by constructing simplified models of complex phenomena, properties deriving from the models, and verifying those properties by experiment. This paradigm worked because the complexities ignored in the models were not the essential properties of the phenomena. It does not work when the complexities are the essence.Many of the classic problems of developing software products derive from this essential complexity and its nonlinear increases with size. From the complexity comes the difficulty of communication among team members, which leads to product flaws, cost overruns, schedule delays. From the complexity comes the difficulty of enumerating, much less understanding, all the possible states of the program, and from that comes the unreliability. From complexity of function comes the difficulty of invoking function, which makes programs hard to use. From complexity of structure comes the difficulty of extending programs to new functions without creating side effects. From complexity of structure come the unvisualized states that constitute security trapdoors.Not only technical problems, but management problems as well come from the complexity. It makes overview hard, thus impeding conceptual integrity. It makes it hard to find and control all the loose ends. It creates the tremendous learning and understanding burden that makes personnel turnover a disaster.Conformity. Software people are not alone in facing complexity. Physics deals with terribly complex objects even at the "fundamental" particle level. The physicist labors on, however, in a firm faith that there are unifying principles to be found, whether in quarks or in unifiedfield theories. Einstein argued that there must be simplified explanations of nature, because God is not capricious or arbitrary.No such faith comforts the software engineer. Much of the complexity that he must master is arbitrary complexity, forced without rhyme or reason by the many human institutions and systems to which his interfaces must conform. These differ from interface to interface, and from time to time, not because of necessity but only because they were designed by different people, rather than by God.In many cases, the software must conform because it is the most recent arrival on the scene. In others, it must conform because it is perceived as the most conformable. But in all cases, much complexity comes from conformation to other interfaces; This complexity cannot be simplified out by any redesign of the software alone.Changeability. The software entity is constantly subject to pressures for change. Of course, so are buildings, cars, computers. But manufactured things are infrequently changed after manufacture; they are superseded by later models, or essential changes are incorporated into later-serial-number copies of the same basic design. Call-backs of automobiles are really quite infrequent; field changes of computers somewhat less so. Both are much less frequent than modifications to fielded software.In part, this is so because the software of a system embodies its function, and the function is the part that most feels the pressures of change. In part it is because software can be changed more easily--it is pure thought-stuff, infinitely malleable. Buildings do in fact get changed, but the high costs of change, understood by all, serve to dampen the whims of the changers.All successful software gets changed. Two processes are at work. First, as a software product is found to be useful, people try it in new cases at the edge of or beyond the original domain. The pressures for extended function come chiefly from users who like the basic function and invent new uses for it.Second, successful software survives beyond the normal life of the machine, vehicle for which it is first written. If not new computers, then at least new disks, new displays, new printers come along; and the software must be conformed to its new vehicles of opportunity.In short, the software product is embedded in a cultural matrix of applications, users, laws, and machine vehicles. These all change continually, and their changes inexorably force change upon the software product.Invisibility. Software is invisible and unvisualizable. Geometric abstractions are powerful tools. The floor plan of a building helps both architect and client evaluate spaces, traffic flows, views. Contradictions and omissions become obvious. Scale drawings of mechanical parts and stick-figure models of molecules, although abstractions, serve the same purpose. A geometric reality is captured in a geometric abstraction.The reality of software is not inherently embedded in space. Hence, it has no ready geometric representation in the way that land has maps, silicon chips have diagrams, computers have connectivity schematics. As soon as we attempt to diagram software structure, we find it to constitute not one, but several, general directed graphs superimposed one upon another. The several graphs may represent the flow of control, the flow of data, patterns of dependency, time sequence, name-space relationships. These graphs are usually not even planar, much less hierarchical. Indeed, one of the ways of establishing conceptual control over such structure is to enforce link cutting until one or more of the graphs becomes hierarchical. [1]In spite of progress in restricting and simplifying the structures of software, they remain inherently unvisualizable, and thus do not permit the mind to use some of its most powerful conceptual tools. This lack not only impedes the process of design within one mind, it severely hinders communication among minds.

Kết quả (Anh) 2:

Complexity. Software entities are more complex for any other có có size human construct coal no two parts are alike vì (at nhất above the statement level). If chúng, WE MAKE the two similar parts Into a subroutine - open or closed. In this respect, differs profoundly from computers software systems, buildings, or Automobiles, where repeated elements abound. Digital computers are more complex Themselves người build coal nhất things: They have very large numbers of states. This Makes conceiving, describing, and testing add hard. Software systems have orders-of-magnitude more computers from coal states. Likewise, a scaling-up of a software entity is not merely a Repetition of the same elements to print larger sizes, it is necessarily safe in the number of khác tăng elements. In Most Cases, the elements interact with each other to print some nonlinear fashion, and the compLexity of the whole coal linearly increases much more. The software is an essential compLexity of property, not an accidental one. Hence, descriptions of a software entity mà away its abstract away its abstract essence often Do compLexity. For three centuries, mathematics and the physical sciences made ​​great strides by simplified models of complex phenomena Constructing, deriving properties from the models, and verifying những properties by experiment. This paradigm worked vì bị complexities in the models were not the essential properties of the phenomena. It does not work are the essence khi complexities. Many of the classic problems of Developing products derive from this software and its essential compLexity nonlinear increases with size. From the difficulty of communication comes the compLexity Among team members, mà leads to product flaws, cost overruns, schedule all delays. From comes the difficulty of the compLexity enumerating, much less understanding, all the possible The states of the program, and from mà comes the unreliability. From compLexity of function comes the difficulty of gọi function mà Makes programs hard to use. From compLexity of structure comes the difficulty of extending programs to new functions without creating in side effects. From the unvisualized compLexity of structure come mà constitute security trapdoors states. Not only technical problems, but management problems as well come from the compLexity. It Makes overview hard, impeding conceptual integrity thì. It Makes it hard to find and control all the loose ends. It tạo the asterisks allow for tremendous learning and understanding the burden mà Makes personnel turnover a disaster. Conformity. People are not alone print Software compLexity facing. Physics deals with terribly complex objects even level at the "fundamental" particle level. The physicist labors on, Tuy nhiên, in a firm faith có có Unifying Principles to be found, nếu print or print unifiedfield Theories quarks. Einstein argued there mà simplified explanations of nature Phải, God is not capricious or vì arbitrary. No such faith comforts the software engineer. Much of the compLexity mà compLexity he phải master is arbitrary, without rhyme or reason forced many human by the Institutions and systems to mà HIS phải chuẩn interfaces. These differs from interface to interface, and from time to time, but not only vì vì Necessity They were designed by khác people, thay by God. In many Cases, the software phải chuẩn vì nó the most recent arrival on the scene . In others, it phải chuẩn vì it is Perceived as the Most conformable. But print all Cases, much compLexity Comes from conformation to other interfaces; this can not be simplified compLexity out by any redesign of the software alone. Changeability. The software entity is subject to pressures for change Constantly. Of course, in comparison are buildings, cars, computers. But manufactured things are infrequently changed after manufacture; superseded by later models chúng, or essential changes are Incorporated Into-serial-number later copies of the same basic design. Call-backs are really quite infrequent of Automobiles; changes of computers somewhat less field compared. Both are much less frequent coal fielded modifications to software. In part, this is so vì embodies its software of a system function, and the function is the part mà feels the pressures of change nhất. In part it is vì software can be changed more Easily - it is pure thought-stuff, infinitely malleable. Buildings by printing fact get changed, but the High Costs of change, understood by all, serve to dampen the whims of the changers. All successful software gets changed. Two processes are at work. First, as a software product is found to be ích, try it in new người Cases at the edge of or beyond the original domain. The pressures for extended function come chiefly from users who like the basic function and invent new dùng for it. Second, successful software survives beyond the normal life of the machine, it is the first vehicle for mà Written speaker. If not new computers, then at nhất new disks, new displays, new printers come along; and the software conformed to its Phải new vehicles of opportunity. In short, the software product is embedded in a cultural matrix of applications, users, laws, and machine vehicles. These all Continually change, and ask for their changes inexorably force change upon the software product. Invisibility. Software is invisible and unvisualizable. Geometric abstractions are powerful tools. The floor plan of a building architect and client cả helps evaluate spaces, traffic flows, views. Obvious contradictions and omissions trở. Scale drawings of mechanical parts and stick-figure models of molecules, although abstractions, serve the same purpose. A geometric reality is captured in a geometric abstraction. The reality of software is not inherently embedded print space. Hence, it has no ready geometric mà Representation in the way land has maps, silicon chips have diagrams, computers have connectivity schematics. As soon as chúng thử diagram software structure, chúng find it to constitute not one, but vài, general directed graphs superimposed one upon another. The vài graphs the flow of control đại diện unfortunately, the flow of data, patterns of dependency, time sequence, name-space relationships. These graphs are not even level Thường planar, much less hierarchical. Indeed, one of the Ways of lập control over such 'conceptual structure is to enforce link cutting off until one or more of the graphs Becomes hierarchical. [1] In spite of progress print and simplifying the structures of restricting software, chúng Remain inherently unvisualizable, and do not permit the mind thì to use some of its powerful conceptual tools nhất. This not only impedes the process Lack of design trong one mind, it hinders communication Among Severely Minds.