Marcus Brown, D. Cordes
{"title":"识字编程在软件工程生命周期中的作用","authors":"Marcus Brown, D. Cordes","doi":"10.1145/98949.99007","DOIUrl":null,"url":null,"abstract":"The software life-cycle identifies a formal strategy for the systematic development of software. It pro vides a broad organizational platform for the genera tion of both small-scale and large-scale software sys tems. This platform defines a methodology for the specification, design, implementation, testing and maintenance of computer systems. Knuth's Literate Programming pnradigm presents a novel approach to coding software. It has proven beneficinl to the process of system implementation. This paper ex plores the fundamental characteristics of the literate parndigm, and looks at how they might be utilized within other stages of system development. The current (and potential) role of a literate pnradigm within the overall software life-cycle is examined. I n t r o d u c t io n As the demand for reliable, maintainable soft ware continues to increase, a growing concern is be ing placed on a developmental process that promotes comprehension and understandability. Such a tech nique would provide the development team with an effective tool for mnnnging the demands plnced upon them by software that is increasing in both size nnd complexity. Additionally, the method would sim plify maintenance of the developed product, nnd also promote code reusability. Permission lo copy without fee nil or part of this material is granted provided that the copies nre not made or distributed for direct com mercial advantage, the ACM copyright notice and (lie title of the publication and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requires a fee and/or specific per mission. © 1990 ACMO-8979I-356-6/90AMOO/OIOI $1.50 Knuth’s literate programming pnradigm [8] in troduces a technique for the coding of software that focuses on understandability. While literate pro gramming is normally associated with system im plementation, the general concerns addressed by the literate environment are not confined to the cod ing phase of software development. In fact, these concerns arise during all stages of softwnre devel opment. Issues such as underslandnbility, compre hension, readability, traceability nnd documentation are realized throughout the life-cycle. The literate paradigm represents a novel approach in addressing these items. To dale, the literate paradigm has remained entrenched within the implementation phase of the software life-cycle. System specification, design, test ing and maintenance must all rely on other develop ment techniques. However, the literate paradigm addresses issues of concern to these stages of de velopment. This paper reviews the current literate parndigm, identifies the underlying concepts central to this paradigm, nnd exnmines the impact of a fil trate approach on other phases of the software lifecycle. T h e C u r r e n t LH etnl.e I’n rn d igm Typical computer programs are conceived of as a set of instructions from a human programmer to a computer telling the computer what actions to per form. Due to the rising costs associated with soft ware development, it is imperative that such pro grams be developed in a readable, understandable format. Therefore, emphasis in softwnre develop ment has shifted from a quick generation of work able instruction sets lo the methodical construction of readable, comprehendnble instructions. The ma jor concern in writing programs must now be fo cused on enabling the human progrnmmer(s) to undcrstnnd the program. This is the basic philosophy underlying the concept of Literate Programming. Tlie WEB system represents Knuth’s implemen tation of the literate programming paradigm. Orig inally created for the Pascal language, it has since been adapted to C [10, 15j, Ada [13] and other lan guages. It has been used for both small programs [2, 3, 4] and large ones [9]. In all enses, writing a program designed for user comprehension has been the primary goal. The literate program is designed for two dis tinct audiences: other programmers and a compiler. To address these two different audiences, the WEB program must be processed in two different paths. For the human audience, the WEB source code is pro cessed by WEAVE, producing a TfeX document for typesetting. This in turn generates an indexed, struc tured listing of the original program. For the com puter, the WEB source is processed by TAIGLE, pro ducing a source code progrnm suitable for the com piler but unfit for human consumption (rending). This processing path is shown in Figure 1. m y f ile .T E X Typeset listing","PeriodicalId":409883,"journal":{"name":"ACM-SE 28","volume":"46 1","pages":"0"},"PeriodicalIF":0.0000,"publicationDate":"1990-04-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":"0","resultStr":"{\"title\":\"The role of literate programming in the software engineering life-cycle\",\"authors\":\"Marcus Brown, D. Cordes\",\"doi\":\"10.1145/98949.99007\",\"DOIUrl\":null,\"url\":null,\"abstract\":\"The software life-cycle identifies a formal strategy for the systematic development of software. It pro vides a broad organizational platform for the genera tion of both small-scale and large-scale software sys tems. This platform defines a methodology for the specification, design, implementation, testing and maintenance of computer systems. Knuth's Literate Programming pnradigm presents a novel approach to coding software. It has proven beneficinl to the process of system implementation. This paper ex plores the fundamental characteristics of the literate parndigm, and looks at how they might be utilized within other stages of system development. The current (and potential) role of a literate pnradigm within the overall software life-cycle is examined. I n t r o d u c t io n As the demand for reliable, maintainable soft ware continues to increase, a growing concern is be ing placed on a developmental process that promotes comprehension and understandability. Such a tech nique would provide the development team with an effective tool for mnnnging the demands plnced upon them by software that is increasing in both size nnd complexity. Additionally, the method would sim plify maintenance of the developed product, nnd also promote code reusability. Permission lo copy without fee nil or part of this material is granted provided that the copies nre not made or distributed for direct com mercial advantage, the ACM copyright notice and (lie title of the publication and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requires a fee and/or specific per mission. © 1990 ACMO-8979I-356-6/90AMOO/OIOI $1.50 Knuth’s literate programming pnradigm [8] in troduces a technique for the coding of software that focuses on understandability. While literate pro gramming is normally associated with system im plementation, the general concerns addressed by the literate environment are not confined to the cod ing phase of software development. In fact, these concerns arise during all stages of softwnre devel opment. Issues such as underslandnbility, compre hension, readability, traceability nnd documentation are realized throughout the life-cycle. The literate paradigm represents a novel approach in addressing these items. To dale, the literate paradigm has remained entrenched within the implementation phase of the software life-cycle. System specification, design, test ing and maintenance must all rely on other develop ment techniques. However, the literate paradigm addresses issues of concern to these stages of de velopment. This paper reviews the current literate parndigm, identifies the underlying concepts central to this paradigm, nnd exnmines the impact of a fil trate approach on other phases of the software lifecycle. T h e C u r r e n t LH etnl.e I’n rn d igm Typical computer programs are conceived of as a set of instructions from a human programmer to a computer telling the computer what actions to per form. Due to the rising costs associated with soft ware development, it is imperative that such pro grams be developed in a readable, understandable format. Therefore, emphasis in softwnre develop ment has shifted from a quick generation of work able instruction sets lo the methodical construction of readable, comprehendnble instructions. The ma jor concern in writing programs must now be fo cused on enabling the human progrnmmer(s) to undcrstnnd the program. This is the basic philosophy underlying the concept of Literate Programming. Tlie WEB system represents Knuth’s implemen tation of the literate programming paradigm. Orig inally created for the Pascal language, it has since been adapted to C [10, 15j, Ada [13] and other lan guages. It has been used for both small programs [2, 3, 4] and large ones [9]. In all enses, writing a program designed for user comprehension has been the primary goal. The literate program is designed for two dis tinct audiences: other programmers and a compiler. To address these two different audiences, the WEB program must be processed in two different paths. For the human audience, the WEB source code is pro cessed by WEAVE, producing a TfeX document for typesetting. This in turn generates an indexed, struc tured listing of the original program. For the com puter, the WEB source is processed by TAIGLE, pro ducing a source code progrnm suitable for the com piler but unfit for human consumption (rending). This processing path is shown in Figure 1. m y f ile .T E X Typeset listing\",\"PeriodicalId\":409883,\"journal\":{\"name\":\"ACM-SE 28\",\"volume\":\"46 1\",\"pages\":\"0\"},\"PeriodicalIF\":0.0000,\"publicationDate\":\"1990-04-01\",\"publicationTypes\":\"Journal Article\",\"fieldsOfStudy\":null,\"isOpenAccess\":false,\"openAccessPdf\":\"\",\"citationCount\":\"0\",\"resultStr\":null,\"platform\":\"Semanticscholar\",\"paperid\":null,\"PeriodicalName\":\"ACM-SE 28\",\"FirstCategoryId\":\"1085\",\"ListUrlMain\":\"https://doi.org/10.1145/98949.99007\",\"RegionNum\":0,\"RegionCategory\":null,\"ArticlePicture\":[],\"TitleCN\":null,\"AbstractTextCN\":null,\"PMCID\":null,\"EPubDate\":\"\",\"PubModel\":\"\",\"JCR\":\"\",\"JCRName\":\"\",\"Score\":null,\"Total\":0}","platform":"Semanticscholar","paperid":null,"PeriodicalName":"ACM-SE 28","FirstCategoryId":"1085","ListUrlMain":"https://doi.org/10.1145/98949.99007","RegionNum":0,"RegionCategory":null,"ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":null,"EPubDate":"","PubModel":"","JCR":"","JCRName":"","Score":null,"Total":0}
引用次数: 0
The role of literate programming in the software engineering life-cycle
The software life-cycle identifies a formal strategy for the systematic development of software. It pro vides a broad organizational platform for the genera tion of both small-scale and large-scale software sys tems. This platform defines a methodology for the specification, design, implementation, testing and maintenance of computer systems. Knuth's Literate Programming pnradigm presents a novel approach to coding software. It has proven beneficinl to the process of system implementation. This paper ex plores the fundamental characteristics of the literate parndigm, and looks at how they might be utilized within other stages of system development. The current (and potential) role of a literate pnradigm within the overall software life-cycle is examined. I n t r o d u c t io n As the demand for reliable, maintainable soft ware continues to increase, a growing concern is be ing placed on a developmental process that promotes comprehension and understandability. Such a tech nique would provide the development team with an effective tool for mnnnging the demands plnced upon them by software that is increasing in both size nnd complexity. Additionally, the method would sim plify maintenance of the developed product, nnd also promote code reusability. Permission lo copy without fee nil or part of this material is granted provided that the copies nre not made or distributed for direct com mercial advantage, the ACM copyright notice and (lie title of the publication and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requires a fee and/or specific per mission. © 1990 ACMO-8979I-356-6/90AMOO/OIOI $1.50 Knuth’s literate programming pnradigm [8] in troduces a technique for the coding of software that focuses on understandability. While literate pro gramming is normally associated with system im plementation, the general concerns addressed by the literate environment are not confined to the cod ing phase of software development. In fact, these concerns arise during all stages of softwnre devel opment. Issues such as underslandnbility, compre hension, readability, traceability nnd documentation are realized throughout the life-cycle. The literate paradigm represents a novel approach in addressing these items. To dale, the literate paradigm has remained entrenched within the implementation phase of the software life-cycle. System specification, design, test ing and maintenance must all rely on other develop ment techniques. However, the literate paradigm addresses issues of concern to these stages of de velopment. This paper reviews the current literate parndigm, identifies the underlying concepts central to this paradigm, nnd exnmines the impact of a fil trate approach on other phases of the software lifecycle. T h e C u r r e n t LH etnl.e I’n rn d igm Typical computer programs are conceived of as a set of instructions from a human programmer to a computer telling the computer what actions to per form. Due to the rising costs associated with soft ware development, it is imperative that such pro grams be developed in a readable, understandable format. Therefore, emphasis in softwnre develop ment has shifted from a quick generation of work able instruction sets lo the methodical construction of readable, comprehendnble instructions. The ma jor concern in writing programs must now be fo cused on enabling the human progrnmmer(s) to undcrstnnd the program. This is the basic philosophy underlying the concept of Literate Programming. Tlie WEB system represents Knuth’s implemen tation of the literate programming paradigm. Orig inally created for the Pascal language, it has since been adapted to C [10, 15j, Ada [13] and other lan guages. It has been used for both small programs [2, 3, 4] and large ones [9]. In all enses, writing a program designed for user comprehension has been the primary goal. The literate program is designed for two dis tinct audiences: other programmers and a compiler. To address these two different audiences, the WEB program must be processed in two different paths. For the human audience, the WEB source code is pro cessed by WEAVE, producing a TfeX document for typesetting. This in turn generates an indexed, struc tured listing of the original program. For the com puter, the WEB source is processed by TAIGLE, pro ducing a source code progrnm suitable for the com piler but unfit for human consumption (rending). This processing path is shown in Figure 1. m y f ile .T E X Typeset listing