Isang programang gumagana nang tama

1. Ang trabaho ng isang programmer

Kadalasan ang mga baguhang programmer ay nag-iisip ng gawain ng isang programmer na ganap na naiiba kaysa sa kung paano ito iniisip ng mga may karanasan na programmer .

Ang mga nagsisimula ay madalas na nagsasabi ng isang bagay tulad ng "Gumagana ang programa, ano pa ang kailangan mo?" Alam ng isang bihasang programmer na ang "gumagana nang tama" ay isa lamang sa mga kinakailangan para sa isang programa , at hindi ito ang pinakamahalagang bagay !

Pagbabasa ng code

Ang pinakamahalagang bagay ay ang program code ay naiintindihan ng ibang programmer . Ito ay mas mahalaga kaysa sa isang wastong gumaganang programa. Higit pa.

Kung mayroon kang isang programa na hindi gumagana nang tama, maaari mo itong ayusin. Ngunit kung mayroon kang isang programa na ang code ay hindi maintindihan, wala kang magagawa dito.

Kunin lamang ang anumang pinagsama-samang programa, tulad ng notepad, at baguhin ang kulay ng background nito sa pula. Mayroon kang gumaganang programa, ngunit wala kang nauunawaan na source code: imposibleng gumawa ng mga pagbabago sa isang program na tulad nito.

Ang isang halimbawa ng textbook ay noong inalis ng mga developer ng Microsoft ang larong Pinball mula sa Windows dahil hindi nila ito mai-port sa 64-bit na arkitektura. At mayroon pa silang source code. Hindi lang nila maintindihan kung paano gumagana ang code .

Accounting para sa bawat kaso ng paggamit

Ang pangalawang pinakamahalagang kinakailangan para sa isang programa ay ang pagsasaalang-alang sa bawat senaryo. Kadalasan, ang mga bagay ay medyo mas kumplikado kaysa sa tila.

Paano nakikita ng isang baguhang programmer ang pagpapadala ng mga mensaheng SMS:

Paano ito nakikita ng isang propesyonal na programmer:

Ang senaryo na "gumagana nang tama" ay karaniwang isa lamang na posible. At iyan ang dahilan kung bakit maraming mga baguhan ang nagrereklamo tungkol sa validator ng gawain ng CodeGym: isang senaryo lamang sa 10 mga gawa, at sa palagay ng newbie programmer ay sapat na iyon.

2. Mga hindi normal na sitwasyon

Maaaring lumitaw ang mga abnormal na sitwasyon sa pagpapatupad ng anumang programa.

Halimbawa, nagpasya kang mag-save ng file ngunit walang espasyo sa disk. O sinusubukan ng program na magsulat ng data sa memorya, ngunit mababa ang magagamit na memorya. O nagda-download ka ng larawan mula sa Internet, ngunit nawala ang koneksyon sa proseso ng pag-download.

Para sa bawat abnormal na sitwasyon, ang programmer (ang may-akda ng programa) ay dapat na a) asahan ito, b) magpasya kung paano ito dapat panghawakan ng programa , at c) magsulat ng isang solusyon na mas malapit hangga't maaari sa nais.

Iyon ang dahilan kung bakit ang mga programa ay may napakasimpleng pag-uugali sa loob ng mahabang panahon: kung may naganap na error sa programa, ang program ay tinapos. At iyon ay isang magandang diskarte.

Sabihin nating gusto mong i-save ang isang dokumento sa disk, sa panahon ng proseso ng pag-save, natuklasan mong walang sapat na espasyo sa disk. Aling pag-uugali ang pinaka gusto mo:

• Natapos ang programa
• Ang programa ay patuloy na tumatakbo, ngunit hindi nai-save ang file.

Maaaring isipin ng isang baguhan na programmer na ang pangalawang opsyon ay mas mahusay, dahil tumatakbo pa rin ang programa. Ngunit sa katotohanan ay hindi ganoon.

Isipin na nag-type ka ng isang dokumento sa Word sa loob ng 3 oras, ngunit dalawang minuto sa iyong proseso ng pagsulat ay naging malinaw na ang programa ay hindi mai-save ang dokumento sa disk. Mas mabuti bang mawalan ng dalawang minuto sa trabaho o tatlong oras?

Kung hindi magawa ng programa ang kailangan, mas mabuting isara na lang ito kaysa patuloy na magkunwaring okay ang lahat. Ang pinakamagandang bagay na magagawa ng isang program kapag nakatagpo ito ng kabiguan na hindi nito kayang ayusin nang mag-isa ay ang agad na iulat ang problema sa user.

3. Background tungkol sa mga exception

Ang mga programa ay hindi lamang ang mga nakakaharap sa mga hindi normal na sitwasyon. Nagaganap din ang mga ito sa loob ng mga programa — sa mga pamamaraan. Halimbawa:

• Nais ng isang pamamaraan na magsulat ng isang file sa disk, ngunit walang espasyo.
• Nais ng isang pamamaraan na tumawag sa isang function sa isang variable, ngunit ang variable ay katumbas ng null.
• Ang paghahati sa pamamagitan ng 0 ay nangyayari sa isang pamamaraan.

Sa kasong ito, posibleng itama ng paraan ng pagtawag ang sitwasyon (magsagawa ng alternatibong senaryo) kung alam nito kung anong uri ng problema ang nangyari sa tinatawag na pamamaraan.

Kung sinusubukan naming i-save ang isang file sa disk at mayroon nang ganoong file, maaari lang naming hilingin sa user na kumpirmahin na dapat naming i-overwrite ang file. Kung walang available na espasyo sa disk, maaari kaming magpakita ng mensahe sa user at hilingin sa user na pumili ng ibang disk. Ngunit kung ang programa ay naubusan ng memorya, ito ay mag-crash.

Noong unang panahon, pinag-isipan ng mga programmer ang tanong na ito at nakaisip sila ng sumusunod na solusyon: lahat ng pamamaraan/function ay dapat magbalik ng error code na nagpapahiwatig ng resulta ng kanilang pagpapatupad. Kung gumana nang perpekto ang isang function, ibinalik nito ang 0 . Kung hindi, nagbalik ito ng error code (hindi zero).

Sa ganitong diskarte sa mga error, pagkatapos ng halos bawat function na tawag, ang mga programmer ay kailangang magdagdag ng isang tseke upang makita kung ang function ay natapos na may isang error. Lumipad ang code sa laki at naging ganito ang hitsura:

File file = new File("ca:\\note.txt");
file.writeLine("Text");
file.close();

File file = new File("ca:\\note.txt");
int status = file.writeLine("Text");
if (status == 1)
{
   ...
}
else if (status == 2)
{
   ...
}
status = file.close();
if (status == 3)
{
   ...
}

Higit pa rito, kadalasan ang isang function na natuklasan na may naganap na error ay hindi alam kung ano ang gagawin dito: kailangang ibalik ng tumatawag ang error, at ibinalik ito ng tumatawag sa tumatawag nito, at iba pa.

Sa isang malaking programa, ang isang hanay ng dose-dosenang mga function na tawag ay karaniwan: kung minsan ay makakahanap ka pa ng lalim ng tawag ng daan-daang mga function. At ngayon kailangan mong ipasa ang error code mula sa pinakaibaba hanggang sa pinakatuktok. At kung sa isang lugar sa kahabaan ng paraan ang ilang function ay hindi hawakan ang exit code, mawawala ang error.

Ang isa pang kawalan ng diskarteng ito ay kung ang mga function ay nagbalik ng isang error code, hindi na nila maibabalik ang mga resulta ng kanilang sariling trabaho. Ang resulta ng mga kalkulasyon ay kailangang maipasa sa pamamagitan ng mga parameter ng sanggunian. Ito ay naging mas mahirap ang code at higit pang nadagdagan ang bilang ng mga error.