Inafasiriwa moja kwa moja kutoka kwa Wikipedia ya Kiingereza na Tafsiri ya Google

Programu iliyopangwa

Structured programu ni programu dhana yenye lengo la kuboresha uwazi, ubora, na maendeleo ya wakati wa programu ya kompyuta kwa kutumia kina wa subroutines , kuzuia miundo , kwa na wakati tanzi -in tofauti na kutumia vipimo rahisi na anaruka kama vile kwenda kauli , ambayo inaweza kusababisha " code tambi " ambayo ni vigumu kufuata na kudumisha.

Iliibuka mwishoni mwa miaka ya 1950 na kuonekana kwa lugha za ALGOL 58 na ALGOL 60 , [1] na mwisho ikiwa ni pamoja na msaada kwa miundo ya kuzuia. Sababu zinazochangia kwa umaarufu wake na kukubalika kwa wingi, kwanza katika masomo na baadaye miongoni mwa wataalamu, ni pamoja na ugunduzi wa kile kinachojulikana kama theorem ya mpango wa muundo katika mwaka wa 1966, [2] na kuchapishwa kwa ushawishi mkubwa wa " Nenda kwa Taarifa Iliyotambuliwa " barua ya wazi mwaka 1968 na mwanasayansi wa kompyuta wa Kiholanzi Edsger W. Dijkstra , ambaye aliunda neno "programu iliyopangwa". [3]

Programu iliyojengwa hutumiwa mara kwa mara na upungufu unaoruhusu mipango ya wazi katika kesi fulani, kama vile utunzaji wa ubaguzi unaofanywa.

Yaliyomo

Mambo

Miundo ya kudhibiti

Kufuatilia kinadharia ya mpango, mipango yote inaonekana kama linajumuisha miundo ya udhibiti :

  • "Mlolongo"; maagizo yaliyotumwa au subroutines zilizofanyika kwa mlolongo.
  • "Uchaguzi"; Taarifa moja au idadi hufanyika kulingana na hali ya programu. Hii mara kwa mara huonyeshwa kwa maneno kama vile if..then..else..endif
  • "Iteration"; taarifa au kuzuia hutolewa mpaka mpango unapofikia hali fulani, au shughuli zimewekwa kwa kila kipengele cha mkusanyiko. Hii ni kawaida yaliyotolewa na maneno kama vile while , repeat , for au do..until . Mara nyingi inashauriwa kwamba kila kitanzi kinapaswa kuwa na hatua moja ya kuingia (na katika programu ya awali ya miundo, pia ni sehemu moja tu ya kuondoka, na lugha chache zinaimarisha hili).
  • "Urejesho"; taarifa inatekelezwa kwa kurudia wito wenyewe mpaka hali ya kukomesha inakabiliwa. Wakati huo huo katika mazoezi ya vitanzi vya iterative, vifungo vya mara kwa mara vinaweza kuwa na ufanisi zaidi wa hesabu, na hutekelezwa tofauti kama stack ya kukimbia.
Uwakilishi wa picha ya mifumo mitatu ya msingi kwa kutumia michoro NS (bluu) na chati za mtiririko (kijani).

Subroutines

Subroutines ; vitengo vinavyoweza kutumiwa kama vile taratibu, kazi, mbinu, au subprograms hutumiwa kuruhusu mlolongo kuletwa kwa kauli moja.

Vikwazo

Vitalu vinatumiwa kuwezesha makundi ya kauli ya kutibiwa ikiwa ni taarifa moja. Block-muundo lugha na syntax kwa enclosing miundo kwa njia fulani rasmi, kama vile ikiwa-taarifa kwenye mabano na if..fi kama katika Algol 68 , au sehemu posta mabano na BEGIN..END , kama katika PL / I , whitespace indentation kama katika Python - au braces curly {...} ya C na lugha nyingi baadaye .

Lugha zilizopangwa kwa programu

Inawezekana kufanya mipangilio ya muundo katika lugha yoyote ya programu, ingawa ni vyema kutumia kitu kama lugha ya programu ya utaratibu . Lugha zingine zilizotumiwa awali kwa programu zimejumuisha : ALGOL , Pascal , PL / I na Ada , lakini lugha mpya za programu za utaratibu tangu wakati huo zimejumuisha vipengele vya kuhamasisha programu zilizopangwa, na wakati mwingine kwa makusudi zimeacha vipengele - hasa GOTO - katika jitihada za kufanya programu zisizojengwa ngumu zaidi. Programu iliyojengwa (wakati mwingine inajulikana kama programu za kawaida) inasaidia muundo wa mantiki kwenye programu iliyoandikwa ili kuiwezesha ufanisi zaidi na rahisi kuelewa na kurekebisha.

Historia

Msingi wa sadharia

Theorem mpango wa muundo hutoa misingi ya kinadharia ya programu ya muundo. Inasema kuwa njia tatu za kuunganisha mipango-ugawaji, uteuzi, na iteration-zinatosha kueleza kazi yoyote inayofaa . Uchunguzi huu haukutokea kwa harakati ya programu iliyopangwa; miundo hii inatosha kuelezea mzunguko wa maelekezo ya kitengo cha usindikaji , pamoja na uendeshaji wa mashine ya Turing . Kwa hiyo, processor daima hutekeleza "mpango wa muundo" kwa maana hii, hata kama maelekezo ambayo inasoma kutoka kwa kumbukumbu si sehemu ya mpango ulioandaliwa. Hata hivyo, waandishi mara nyingi wanatoa mikopo kwa karatasi ya 1966 na Böhm na Jacopini, labda kwa sababu Dijkstra alitoa karatasi hii mwenyewe. [4] Theorem ya mpango haijashughulikia jinsi ya kuandika na kuchambua mpango uliojengwa vizuri. Masuala haya yalitibiwa wakati wa miaka ya 1960 na mapema miaka ya 1970, na michango kubwa ya Dijkstra , Robert W. Floyd , Tony Hoare , Ole-Johan Dahl , na David Gries .

Mjadala

PJ Plauger , mtangulizi wa mapema wa programu za muundo, alielezea majibu yake kwa theorem ya mpango wa muundo:

Sisi waongofu walisonga habari hii ya kuvutia chini ya namba ya wajumbe wa lugha isiyojadiliwa ambao waliendelea kusonga bits ya mantiki na kusema, 'Mimi betcha hauwezi kuunda hii.' Uthibitisho wa Böhm na Jacopini wala mafanikio yetu ya mara kwa mara kwa kuandika kanuni iliyosababisha kuwaleta karibu siku moja mapema kuliko walipokuwa tayari kujijulisha wenyewe. [5]

Donald Knuth alikubali kanuni kwamba mipango inapaswa kuandikwa kwa ukatili katika akili, lakini hakukubaliana (na bado hayakubaliani [ kinachohitajika ] ) na kukomesha taarifa ya GOTO. Katika karatasi yake ya 1974, "Mpangilio wa Maandalizi na Taarifa za Goto", [6] alitoa mifano ambapo aliamini kuwa kuruka moja kwa moja kunaongoza kwenye kanuni ya wazi na yenye ufanisi bila kutoa dhabihu. Knuth alipendekeza kikwazo kikubwa cha kimuundo: Ni lazima iwezekanavyo kuteka chati ya mtiririko wa mpango na matawi yote ya mbele upande wa kushoto, matawi yote ya nyuma ya kulia, na hakuna matawi yanayovuka. Wengi wa wale wenye ujuzi katika nadharia za usanifu na graph walitetea kuruhusu grafu tu za mtiririko wa reducible [ ifafanuliwa kama? ] . [ nani? ]

Wataalam wa programu waliopangwa walipata mshirika mkubwa katika miaka ya 1970 baada ya mtafiti wa IBM Harlan Mills akitumia ufafanuzi wake wa nadharia ya programu iliyopangwa kwa maendeleo ya mfumo wa indexing kwa faili la utafiti wa New York Times . Mradi huo ulikuwa mafanikio mazuri ya uhandisi, na mameneja katika makampuni mengine walitoa mfano wa kusaidia kupitisha programu zilizopangwa, ingawa Dijkstra alikosoa njia ambazo tafsiri ya Mills ilipotofautiana na kazi iliyochapishwa. [ citation inahitajika ]

Mwishoni mwa 1987 ilikuwa bado inawezekana kuinua swali la programu zilizopangwa katika gazeti la sayansi ya kompyuta. Frank Rubin alifanya hivyo mwaka huo na barua iliyo wazi yenye jina la "" GOTO inaonekana kuwa yenye madhara "inaonekana kuwa ya hatari". [7] Vikwazo vingi vilifuatiwa, ikiwa ni pamoja na jibu kutoka kwa Dijkstra ambalo lilikosoa kwa makini Rubin na maandamanaji waandishi wengine wakati walipomjibu.

matokeo

Mwishoni mwa karne ya 20 karibu wanasayansi wote wa kompyuta waliamini kuwa ni muhimu kujifunza na kutumia dhana ya programu iliyopangwa. Lugha za kiwango cha juu ambazo awali hazikuwepo miundo ya programu, kama FORTRAN , COBOL , na BASIC , sasa una nayo.

Ukosefu wa kawaida

Ingawa goto sasa imebadilishwa na muundo wa kuchaguliwa (ikiwa / basi / mwingine) na kurudia (wakati na kwa), lugha chache zimeundwa. Kupotoka kwa kawaida, kupatikana katika lugha nyingi, ni matumizi ya taarifa ya kurejea kwa kuondoka mapema kutoka kwenye sehemu ndogo. Hii husababisha pointi nyingi za kuondoka, badala ya hatua moja ya kuondoka inayotakiwa na programu iliyopangwa. Kuna majengo mengine ya kushughulikia kesi ambazo ziko katika programu halisi.

Mapema ya kutoka

Kupotoka kwa kawaida kutoka programu iliyowekwa ni mapema kutoka kwa kazi au kitanzi. Katika ngazi ya kazi, hii ni taarifa ya return . Katika ngazi ya matanzi, hii ni kauli ya break (kusitisha kitanzi) au continue kauli (kusitisha iteration sasa, endelea ijayo iteration). Katika programu zilizopangwa, hizi zinaweza kuingizwa kwa kuongeza matawi ya ziada au vipimo, lakini kwa kurudi kutoka kwenye msimbo wa nuru hii inaweza kuongeza utata mkubwa. C ni mfano wa kwanza na maarufu wa ujenzi huu. Lugha zingine za karibu pia zimeandika "mapumziko", ambayo inaruhusu kuvunja nje zaidi ya kitanzi cha ndani. Tofauti pia kuruhusu kuondoka mapema, lakini kuwa na matokeo zaidi, na hivyo ni kutibiwa chini.

Kuondoka mara nyingi kunaweza kutokea kwa sababu mbalimbali, mara nyingi ama kuwa subroutine haina kazi zaidi ya kufanya (iwapo inarudi thamani, imekamilisha hesabu), au imekutana na hali "za kipekee" zinazozuia kuendelea, na hivyo zinahitaji utunzaji wa kipekee.

Tatizo la kawaida katika kuondoka mapema ni kwamba maelezo ya usafi au ya mwisho hayakufanyika - kwa mfano, kumbukumbu iliyowekwa haipatikani, au mafaili ya wazi hayakufungwa, na kusababisha uvujaji kumbukumbu au uvujaji wa rasilimali . Hizi ni lazima zifanyike kwenye kila kurudi tovuti, ambayo ni ya brittle na inaweza kusababisha matokeo ya mende. Kwa mfano katika maendeleo ya baadaye, taarifa kurudi inaweza kupuuzwa na msanidi, na hatua ambayo inapaswa kuwa walifanya katika mwisho wa subroutine (kwa mfano, kufuatilia kauli) wanaweza kuwa walifanya katika matukio yote. Lugha bila taarifa ya kurudi, kama vile Standard Pascal hawana tatizo hili.

Lugha nyingi za kisasa hutoa usaidizi wa kiwango cha lugha ili kuzuia uvujaji huo; [8] tazama majadiliano ya kina katika usimamizi wa rasilimali . Kawaida hii inafanywa kupitia ulinzi wa unwind, ambayo inahakikisha kwamba kanuni fulani imethibitishwa kukimbia wakati utekelezaji inatoka kuzuia; hii ni njia mbadala ya kuwa na kuzuia kusafisha na goto . Hii hujulikana mara nyingi kama try...finally, na kuchukuliwa kuwa sehemu ya utunzaji wa ubaguzi . Kuna mbinu mbalimbali za kuingiza usimamizi wa rasilimali. Njia mbadala, inayopatikana katika C ++, ni Upatikanaji wa Rasilimali ni Uanzishaji , ambao hutumia kutolewa kwa kawaida stack (kushughulika kwa kutofautiana) wakati wa kazi ili kuwaita wasimamiziji kwa vigezo vya mitaa ili kupangilia rasilimali.

Kent Beck , Martin Fowler na waandishi wa ushirikiano wamesema katika vitabu vyao vya kurejesha ambavyo vifungo vingi vinaweza kuwa vigumu kuelewa kuliko aina fulani ya muundo wa flatter kwa kutumia vitu vingi vinavyotabiriwa na vifungu vya ulinzi . Kitabu chao cha mwaka 2009 kinasema kwa uwazi kwamba "sehemu moja ya kuondoka sio kanuni muhimu sana. Uwazi ni kanuni muhimu: Ikiwa mbinu ni wazi na sehemu moja ya kuondoka, tumia njia moja ya kuondoka, vinginevyo usiwe". Wao hutoa suluhisho la kitabu cha cookbook kwa kubadilisha kazi inayojumuisha hali ya maadili tu katika mlolongo wa taarifa za kulinda (au kutupa), ikifuatiwa na kizuizi kimoja kilichohifadhiwa, ambacho kina lengo la kuwa na msimbo wa kesi ya kawaida, wakati kauli zilizohifadhiwa ni wanapaswa kushughulika na wale wa kawaida (au kwa makosa). [9] Herb Sutter na Andrei Alexandrescu pia wanasema katika kitabu chao cha 2004 cha C ++ ambacho sehemu moja ya kuondoka ni mahitaji ya kizamani. [10]

Katika kitabu chake cha 2004, David Watt anaandika kwamba "mtiririko wa kuingia moja kwa moja wa udhibiti wa mara nyingi mara nyingi unapendekezwa". Kutumia mtazamo wa mfumo wa Tennent wa sequencer , Watt inaelezea kwa ufanisi mipangilio ya kudhibiti mtiririko inayopatikana katika lugha za kisasa za programu na jitihada za kueleza kwa nini aina fulani za sequencers zinafaa kwa wengine katika mazingira ya mtiririko wa udhibiti wa multi-exit. Watt anaandika kwamba gotos isiyozuiliwa (kuruka sequencer) ni mabaya kwa sababu marudio ya kuruka sio maelezo kwa msomaji wa mpango mpaka msomaji anapata na kuchunguza ile studio halisi au anwani ambayo ni lengo la kuruka. Kwa upande mwingine, Watt anasema kwamba nia ya dhana ya sequencer kurudi ni wazi kutoka kwa mazingira yake mwenyewe, bila ya kuchunguza yake ya marudio. Watt anaandika kuwa darasa la sequeners inayojulikana kama sequencerers , linalotafsiriwa kama "sequencer ambayo inakamilisha utekelezaji wa amri ya utaratibu au utaratibu", inajumuisha mapumziko yote kutoka kwa matanzi (ikiwa ni pamoja na mapumziko ya ngazi mbalimbali) na taarifa za kurudi. Watt pia anabainisha kuwa wakati wa kuruka sequencer (gotos) wamekuwa vikwazo vingine katika lugha kama C, ambako lengo linapaswa kuwa ndani ya kuzuia ndani au kuzuia nje ya nje, kizuizi peke yake haitoshi kufanya nia ya gotos katika C self -kutafuta na hivyo wanaweza bado kutoa " code ya tambi ". Watt pia huchunguza jinsi sequencers tofauti hutofautiana na wapiganaji wa kuruka na kuruka; hii inaelezwa katika sehemu inayofuata ya makala hii. [11]

Tofauti na hapo juu, Bertrand Meyer aliandika katika kitabu chake cha 2009 kwamba maagizo kama break na continue "ni goto ya zamani tu katika nguo za kondoo" na kushauriwa sana dhidi ya matumizi yao. [12]

Utunzaji wa uchapishaji

Kulingana na kosa la kuandika coding kutoka kwa maafa ya Ariane 501 , msanidi programu wa programu Jim Bonang anasema kuwa tofauti yoyote inayotupwa kutokana na kazi inakiuka dhana moja ya kuondoka, na inapendekeza kuwa tofauti zote za kiutaratibu zinapaswa kuzuiliwa. Katika noexcept C + +, hii imefanywa kwa kutangaza saini zote za kazi kama noexcept (tangu C ++ 11) au throw() . [13] Bonang inapendekeza kwamba kila C + + inayofaa ya kusafiri moja lazima iandikwa kwenye mistari ya:

bool myCheck1 () kutupa ()
{
  bool mafanikio = uongo ;

  jaribu 
  {
    // kufanya kitu ambacho kinaweza kutupa mbali
    ikiwa ( myCheck2 () == uongo ) 
    {
        kutupa SomeInternalException ();
    }

    // code nyingine kama ilivyo hapo juu
    mafanikio = ya kweli ;
  }

  catch (...)
  {
      // tofauti zote zilizopatikana na zinaingia
  }

  kurudi mafanikio ;
}

Peter Ritchie pia anaelezea kuwa, kwa kanuni, hata moja throw haki kabla ya return katika kazi hufanya ukiukwaji wa kanuni moja-exit, lakini anasema kwamba sheria za Dijkstra ziliandikwa kwa muda kabla ya utunzaji wa ubaguzi ulikuwa ni mtazamo katika lugha za programu, hivyo anapendekeza kuruhusu idadi yoyote ya pointi kutupa kwa kuongeza hatua moja kurudi. Anaelezea kuwa ufumbuzi ambao hufunga sehemu tofauti kwa ajili ya kujenga moja-nje huwa na kina cha juu cha kuunganisha na hivyo ni vigumu zaidi kuelewa, na hata kuwashtaki wale wanaotaka kutumia ufumbuzi huo kwa lugha za programu ambazo zinaunga mkono tofauti ya kushiriki katika ibada ya mizigo kufikiri . [14]

David Watt pia anachunguza ubaguzi wa kipekee katika mfumo wa sequencers (ililetwa katika makala hii katika sehemu ya awali juu ya kuondoka mapema.) Watt anabainisha kuwa hali isiyo ya kawaida (kwa ujumla mfano wa upungufu wa hesabu au kushindwa kwa pembejeo / kutolewa kama faili haikupatikana) ni aina ya kosa ambalo "hugunduliwa katika kitengo cha chini cha programu ya chini, lakini [ambayo] mhudumiaji ni kawaida zaidi katika kitengo cha programu cha juu". Kwa mfano, programu inaweza kuwa na wito kadhaa kusoma files, lakini hatua ya kufanya wakati faili haipatikani inategemea maana (madhumuni) ya faili katika swali kwa mpango na hivyo utaratibu wa utunzaji kwa hali hii isiyo ya kawaida haiwezi kuwa iko katika msimbo wa mfumo wa chini. Watts anafafanua kwamba kuanzisha bendera ya hali ya kupima kwa wito, kwa kuwa programu moja ya kuondoka au hata (multi-exit) ya kurudi sequencers ingeingia, hutababisha hali ambapo "msimbo wa maombi huelekea kuingizwa na majaribio ya bendera za hali" na kwamba "mtengenezaji anaweza kushika au kusahau ili kupima bendera ya hali. Kwa kweli, hali zisizo za kawaida zinazowakilishwa na bendera za hali ni kwa kupuuzwa bila malipo!" Anasema kuwa kinyume na kupima kwa hali ya bendera, tofauti zina tabia ya kutofautiana, na kusababisha programu kukomesha isipokuwa mpangilio anahusika kwa ubaguzi kwa namna fulani, labda kwa kuongeza kificho kwa kupuuza kwa hiari. Kulingana na hoja hizi, Watt anahitimisha kuwa safu za safu au salama za kutoroka (zilijadiliwa katika sehemu ya awali) hazistahili kama sequencer ya kujitolea na semantics kujadiliwa hapo juu. [15]

Kitabu cha kitabu cha Louden na Lambert kinasisitiza kuwa utunzaji wa ubaguzi hutofautiana na mipangilio ya mipangilio ya muundo kama vile vitanzi vya while kwa sababu uhamisho wa udhibiti "umewekwa kwa hatua tofauti katika programu kuliko ambapo uhamisho halisi unafanyika. hutokea, huenda hakuna kuwa na dalili ya kiambatanisho ambazo udhibiti utazingatiwa. " [16] kompyuta sayansi profesa Arvind Kumar Bansal pia inabainisha kuwa katika lugha ambayo kutekeleza ubaguzi utunzaji, hata kudhibiti miundo kama for , ambayo moja ya njia ya kutoka mali kutokana na kukosekana kwa tofauti, tena ni mbele ya tofauti, kwa sababu ubaguzi Unaweza kabla ya kuondoka mapema katika sehemu yoyote ya muundo wa kudhibiti; kwa mfano ikiwa init() inatupa ubaguzi for (init(); check(); increm()) , basi kiwango cha kawaida cha kuondoka baada ya hundi () si kufikiwa. [17] Akizungumzia tafiti nyingi kabla ya watu wengine (1999-2004) na matokeo yao wenyewe, Westley Weimer na George Necula waliandika kuwa tatizo kubwa na tofauti ni kwamba "huunda njia za udhibiti wa siri ambazo ni vigumu kwa waendeshaji kufikiri kuhusu" . [18] : 8:27

Umuhimu wa kupitisha msimbo kwa pointi moja ya kuondoka inaonekana katika mazingira ya kisasa ya programu yaliyolenga kwenye kompyuta sawa, kama vile OpenMP . Vile tofauti vinavyotengenezwa kutoka OpenMP, kama vile parallel do , usiruhusu kuondoka mapema ndani na nje ya ujenzi wa sambamba; kizuizi hiki kinajumuisha aina zote za kuondoka, kutoka kwa break ya break hadi C ++, lakini yote haya yanaruhusiwa ndani ya ujenzi wa sambamba ikiwa lengo la kuruka pia lina ndani yake. [19]

Kuingia mara nyingi

Zaidi mara chache, subprograms inaruhusu kuingia nyingi . Hii mara nyingi huingia tena kwenye coroutine (au jenereta / semicoroutine), ambapo subprogram inaleta udhibiti (na uwezekano wa thamani), lakini inaweza kurudi tena ambapo imesalia. Kuna idadi ya matumizi ya kawaida ya programu hizo, hasa kwa mito (hasa pembejeo / pato), mashine za hali, na concurrency. Kutoka kwa mtazamo wa utekelezaji wa kificho, kutoa kutoka kwa coroutine ni karibu na programu iliyopangwa kuliko kurudi kutoka kwenye sehemu ndogo, kama subprogram haijazimia kabisa, na itaendelea wakati iitwayo tena - sio kuondolewa mapema. Hata hivyo, coroutines inamaanisha kuwa subprograms nyingi zinafanya hali - badala ya kuwa na wito moja wa wito - na hivyo kuanzisha aina tofauti ya utata.

Ni nadra sana kwa subprograms kuruhusu kuingia kwa nafasi ya kiholela katika subprogram, kama katika kesi hii hali ya mpango (kama vile thamani variable) ni uninitialized au utata, na hii ni sawa na goto.

Mashine ya hali

Baadhi ya programu, hasa parsers na itifaki ya mawasiliano , na idadi ya majimbo zinazofuata kila mmoja kwa namna ambayo si rahisi kupunguzwa na miundo ya msingi, na baadhi programmers kutekeleza serikali mabadiliko na kuruka kwa hali mpya. Aina hii ya kubadilisha-hali mara nyingi hutumiwa katika kernel ya Linux. [ citation inahitajika ]

Hata hivyo, inawezekana kuunda mifumo hii kwa kufanya kila hali ya mabadiliko ya subprogram tofauti na kutumia variable ili kuonyesha hali ya kazi (tazama trampoline ). Vinginevyo, haya yanaweza kutekelezwa kupitia koroutines, ambayo hutoa kwa trampoline.

Angalia pia

  • DRAKON
  • Tathmini ndogo
  • Mchoro wa Nassi-Shneiderman
  • Chati ya muundo
  • Badilisha taarifa

Vidokezo

  1. ^ Clark, Leslie B. Wilson, Robert G.; Robert, Clark (2000). Comparative programming languages (3rd ed.). Harlow, England: Addison-Wesley. p. 20. ISBN 9780201710120 . Retrieved 25 November 2015 .
  2. ^ Bohm, Corrado; Giuseppe Jacopini (May 1966). "Flow Diagrams, Turing Machines and Languages with Only Two Formation Rules" (PDF) . Communications of the ACM . 9 (5): 366–371. doi : 10.1145/355592.365646 .
  3. ^ Dijkstra 1968 , "The unbridled use of the go to statement has as an immediate consequence that it becomes terribly hard to find a meaningful set of coordinates in which to describe the process progress. ... The go to statement as it stands is just too primitive, it is too much an invitation to make a mess of one's program."
  4. ^ Dijkstra, E. W. (March 1968). "Letters to the editor: go to statement considered harmful". Communications of the ACM . 11 (3): 147–148. doi : 10.1145/362929.362947 . ISSN 0001-0782 .
  5. ^ Plauger, P. J. (February 12, 1993). Programming on Purpose, Essays on Software Design (1 ed.). Prentice-Hall. p. 25. ISBN 978-0-13-721374-0 .
  6. ^ Donald Knuth - Structured programming with go to statements
  7. ^ Frank Rubin (March 1987). " " GOTO Considered Harmful" Considered Harmful" (PDF) . Communications of the ACM . 30 (3): 195–196. doi : 10.1145/214748.315722 . Archived from the original (PDF) on 2009-03-20.
  8. ^ Elder, Jackson & Liblit 2008 .
  9. ^ Jay Fields; Shane Harvie; Martin Fowler; Kent Beck (2009). Refactoring: Ruby Edition . Pearson Education. pp. 274–279. ISBN 978-0-321-60350-0 .
  10. ^ Herb Sutter; Andrei Alexandrescu (2004). C++ Coding Standards: 101 Rules, Guidelines, and Best Practices . Pearson Education. ISBN 978-0-13-265442-5 . "Example 4: Single entry, single exit ("SESE"). Historically, some coding standards have required that each function have exactly one exit, meaning one return statement. Such a requirement is obsolete in languages that support exceptions and destructors, where functions typically have numerous implicit exits.")
  11. ^ David Anthony Watt; William Findlay (2004). Programming language design concepts . John Wiley & Sons. pp. 215–221. ISBN 978-0-470-85320-7 .
  12. ^ Bertrand Meyer (2009). Touch of Class: Learning to Program Well with Objects and Contracts . Springer Science & Business Media. p. 189. ISBN 978-3-540-92144-8 .
  13. ^ http://pragprog.com/magazines/2012-04/the-pragmatic-defense
  14. ^ http://msmvps.com/blogs/peterritchie/archive/2008/03/07/single-entry-single-exit-should-it-still-be-applicable-in-object-oriented-languages.aspx
  15. ^ David Anthony Watt; William Findlay (2004). Programming language design concepts . John Wiley & Sons. pp. 221–222. ISBN 978-0-470-85320-7 .
  16. ^ Kenneth C. Louden; Kenneth A. Lambert (2011). Programming Languages: Principles and Practices (3 ed.). Cengage Learning. p. 423. ISBN 1-111-52941-8 .
  17. ^ Arvind Kumar Bansal (2013). Introduction to Programming Languages . CRC Press. p. 135. ISBN 978-1-4665-6514-2 .
  18. ^ Weimer, W & Necula, G.C. (2008). "Exceptional Situations and Program Reliability" (PDF) . ACM Transactions on Programming Languages and Systems, vol 30 (2) .
  19. ^ Rohit Chandra (2001). Parallel Programming in OpenMP . Morgan Kaufmann. p. 45. ISBN 978-1-55860-671-5 .

Marejeleo

Viungo vya nje

  • BPStruct - A tool to structure concurrent systems (programs, process models)
  • J. Darlinton; M. Ghanem; H. W. To (1993), "Structured Parallel Programming" , In Programming Models for Massively Parallel Computers. IEEE Computer Society Press. 1993