Coffee break #83. Anong mga katangian ng karakter ang nagpapakilala sa mga natatanging programmer. Simple Programming Guide: Functions and Methods

Anong mga katangian ng karakter ang nakikilala sa mga natatanging programmer?

Pinagmulan: Hackernoon Ano ang naghihiwalay sa mga mahuhusay na programmer sa mga mahuhusay? Natuklasan ko ang dalawang katangian ng karakter na ibinabahagi ng mahusay na mga programmer: sila ay pare-pareho at paulit-ulit. Ang mga katangiang ito sa kanilang sarili ay hindi mga palatandaan ng henyo, at kung ninanais, sinuman ay maaaring bumuo ng mga katangiang ito at pagkatapos ay ilapat ang mga ito sa kanilang trabaho.

1. Maging pare-pareho

Ang mga mahuhusay na programmer ay hindi nagprograma paminsan-minsan. Sa halip, mayroon silang isang tiyak na iskedyul upang mapabuti ang kanilang kaalaman at kasanayan sa kanilang libreng oras: bago o pagkatapos ng trabaho at sa katapusan ng linggo. Halimbawa, ang isang programmer na kilala ko ay gumugugol ng unang dalawang oras ng kanyang araw—anim na araw sa isang linggo—sa mga personal na proyekto o mga gawain sa pag-aaral. Hindi ibig sabihin na ang mga ganitong tao ay nagsusulat ng code sa buong orasan. Sila, tulad nating lahat, ay may oras para sa kanilang mga personal na buhay, mga obligasyon at mga interes. Ngunit pare-pareho sila: naging ugali na nila ang programming. Paano ka magiging pare-pareho? Ito ang sinisikap na makamit ng marami sa atin. Nalaman ko na may ilang paraan para gawin ito. Una, tukuyin ang bilang ng mga oras bawat linggo na maaari mong gastusin sa programming. Ang numerong ito ay ang iyong lingguhang “program mileage.” Bilang isang dating runner ng distansya, tumakbo ako ng isang tiyak na bilang ng mga milya bawat linggo. Ito ang aking lingguhang pagtakbo. Ngayon ay mayroon na akong karanasan sa programming: ito ang bilang ng mga oras na ginugugol ko sa programming bawat linggo. Karamihan sa mga tao ay nagpapabaya sa yugtong ito. Dumiretso sila sa proyektong gusto nilang tapusin o sa paksang gusto nilang pag-aralan, nang hindi iniisip kung paano sila makakahanap ng oras para gawin ito. Bilang resulta, nagtatrabaho sila sa gabi o 16 na oras sa isang araw. May problema sa diskarteng ito: hindi ito sustainable sa mahabang panahon. Ang pagpapahusay sa iyong mga kasanayan bilang isang programmer ay hindi isang bagay na ginagawa mo sa loob ng isang abalang linggo o dalawa. Sa halip, kailangan mong patuloy na magtrabaho dito sa loob ng mahabang panahon. Ito ang dahilan kung bakit napakahalagang tukuyin ang iyong karanasan sa programming. Upang gawin ito, isaalang-alang ang paggamit ng tala ng oras upang makita kung saan at paano mo ginugugol ang iyong oras. Kumuha ng isang piraso ng papel at isulat ang lahat ng iyong ginagawa araw-araw at kung gaano katagal mo ito ginagawa, kabilang ang pagsuri sa social media o email sa loob ng limang minuto. Gagawin nitong mas madali para sa iyo na makahanap ng mga bukas na slot sa iyong iskedyul. Maaari ka ring makakuha ng kaunting dagdag na oras para sa gawaing bahay o manood ng TV. Pagkatapos ay maaari kang lumikha ng isang plano sa pagsasanay sa programming na kailangan mong panindigan. Ang isang plano sa pagsasanay ay isa sa mga pinaka-epektibong paraan upang maging pare-pareho. Pinapayagan ka nitong ipamahagi ang lahat ng mga detalye nang maaga. Ang kailangan mo lang gawin ay isagawa ang planong ito bawat araw. Ang aking mga plano sa pagsasanay sa pagtakbo ay nakabalangkas kung gaano karaming milya ang kailangan kong tumakbo bawat araw at kung gaano kabilis ang kailangan kong patakbuhin ang mga ito. Ngayon ay gumagawa ako ng mga programming workout plan na nagsisilbi sa parehong layunin: sinasabi nila sa akin kung ano ang kailangan kong gawin bawat araw. Sa pagtatapos ng araw, binuksan ko ang Evernote sa aking computer at gumawa ng iskedyul para sa susunod na araw. Narito ang isang halimbawa: Sinusunod ko ang prosesong ito sa buong araw ng aking trabaho: Itinakda ko ang dami ng oras na gugugulin ko sa isang gawain at kung ano ang gusto kong magawa sa oras na iyon. Gumagawa din ako ng buwanang plano sa pagsasanay. Dito, kasama ko ang tatlong bagay na gusto kong matupad, matutunan, o kumpletuhin sa darating na buwan. Gumagawa ako noon ng quarterly plans. Ngunit pagkatapos ay natuklasan ko na masyadong maraming maaaring magbago sa loob ng tatlong buwan. Ang buwanang plano ay nagbibigay ng sapat na oras upang gumawa ng mahahalagang hakbang sa iyong pagsasanay.

2. Maging matiyaga

Ang pangalawang katangian ng mahusay na programmer ay ang pagtitiyaga. Ginagawa nila ang lahat ng mga opsyon para sa paglutas ng problema at hanapin ang sagot. Mukhang ito ang sikreto. Ang mga mahuhusay na programmer na nakilala ko ay may kakaibang kakayahan na sirain ang mga problema at makabuo ng iba't ibang solusyon o solusyon sa isang mahirap na sitwasyon. Sa madaling salita, mayroon silang sistema para sa paglutas ng mga problema. Wala akong sistema ng solusyon noong high school. Sa tuwing bibigyan ako ng problema sa klase sa matematika, diretso akong sumisid dito nang buong bilis. Pagkatapos ay ipinagpatuloy kong gawin ito noong nagsimula akong magprograma. Walang plano. Walang sistema. Walang oras para mag-isip. Walang pagsusuri. Hindi nakakagulat, sa parehong mga kaso ay iniikot ko ang aking mga gulong nang hindi kinakailangan at patuloy na tumatakbo sa mga hadlang. Mayroon na akong sistema sa paglutas ng problema na tumutulong sa akin na masira ang isang problema upang makahanap ng iba't ibang mga opsyon. Halimbawa, ang unang hakbang sa aking proseso sa paglutas ng problema ay ang sabihin ang problema. Ito ang una. Kapag naiintindihan ko na ang problema, nakatuon ako sa bawat isa sa mga sumusunod na hakbang.

• Pagsusuri ng data ng input at inaasahang resulta.
• Paglikha ng isang algorithm ng pagkilos.
• Pagsusulat ng pseudocode.
• Paglutas ng isang pinasimpleng bersyon ng problema.

Sana makuha mo ang ideya. Maaaring hindi madali ang mga yugto, ngunit mapapamahalaan ang mga ito. Sa pamamagitan ng paglutas ng isang mahirap na problema, nagiging mas mabuting tao tayo. Nagtatanim din ito ng kumpiyansa. Kapag nalutas na natin ang isang mahirap na problema, handa na tayo para sa mga bago.

3. Saloobin sa mga problema?

Sa landas tungo sa pagiging mas mahuhusay na programmer, may iba pa tayong dapat isaalang-alang: saloobin. Dapat ay mayroon kang bagong diskarte sa mga problema at kalabuan. Isang araw nagtanong ako sa isang senior developer ng ilang mga tanong tungkol sa isang problemang hindi ako natigil. Ako ay tuliro at bigo. Noong una, naguguluhan din ang developer. Pero nagulat ako sa sagot niya. "Wow, iyan ay isang cool na problema," sabi niya. Ang kanyang interes ay napukaw ng mga detalyeng natuklasan niya. Hindi ibig sabihin na ang mahuhusay na programmer ay hindi rin natigil sa ilang problema. Naipit sila. Ngunit ang pagkakaiba ay nasa ugali. Ang aral na natutunan ko sa araw na iyon ay ito: ang mabubuting programmer ay hindi natatakot na makipagsapalaran sa hindi alam. Naiintindihan nila na tiyak na may bago silang matututunan sa pamamagitan ng pag-aaral ng problemang ito. Marami tayong matututuhan sa pamamagitan ng pag-aaral ng iba pang programmer. Ngunit sa huli ang responsibilidad ay nasa atin: kailangan nating magtrabaho araw-araw at kumilos.

Simple Programming Guide: Functions and Methods

Source: DZone Ano ang gumagawa ng isang magandang function o pamamaraan? Nangangailangan ito ng kumbinasyon ng mga salik, na ang bawat isa ay mahalaga. Tingnan natin ang apat sa pinakamahalaga.

Makahulugang pangalan

Ang mga function ay dapat may mga pangalan na naglalarawan sa kanilang layunin o functionality. Kapag ang isang function ay may makabuluhang pangalan, madaling basahin at maunawaan ang layunin nito. Halimbawa, kung ang layunin ng function ay maghanap ng customer sa pamamagitan ng ID, ang magandang pangalan ay findCustomerById(id: String) . Ang isa pang pagpipilian ay maaaring findCustomer(id: String) . Dito, ang signature ng function ay nagpapahiwatig na ang mamimili ay matatagpuan sa pamamagitan ng kanyang ID. Ang salitang "hanapin" ay nagpapahiwatig din na ang mamimili ay maaaring matagpuan o hindi. Kung ang pangalan ng function ay binago sa getCustomer(id: String) pagkatapos ay ang kahulugan nito ay nagbabago dahil ito ngayon ay nagpapahiwatig ng walang rollback; maaaring matagpuan ang kliyente o nabigo ang pag-andar at posibleng maghagis ng eksepsiyon. Ang parehong mga pangalan ay wastong pangalan para sa isang function, ngunit may iba't ibang kahulugan, kaya dapat na iba rin ang mga pagpapatupad ng mga ito.

Kaunting mga parameter hangga't maaari

Gusto kong sundin ang panuntunan ng tatlo. Nangangahulugan ito na ang function ay dapat magkaroon ng tatlo o mas kaunting mga parameter. Kapag ang isang function ay nangangailangan ng higit sa tatlong parameter, dapat itong muling isulat at ang mga parameter ay ilagay sa isang data holder, tulad ng klase nito, klase ng data, JavaScript object, at iba pa. Ito ay isang madaling paraan upang bawasan ang bilang ng mga parameter at ayusin ang data sa loob ng isang application. Kunin natin halimbawa ang isang function na may magkatulad na pag-uugali ngunit magkaibang mga lagda:

fun addCustomer(
  firstname: String,
  lastname: String,
  streetAddress: String,
  city: String,
  zipCode: String
)

Narito ang isa pang pagpipilian:

data class Address(
  val street: String,
  val city: String,
  val zipCode: String,
  val streetNumber: String
)

data class Customer(
  val firstname: String,
  val lastname: String,
  val address: Address
)

fun addCustomer(customer: Customer)

Ginagawa ng function ang inaasahan

Dapat gawin ng isang function kung ano ang inaasahan dito. Wala na, walang kulang. Kung ang function ay pinangalanang findAddress(latitude, longitude) pagkatapos ay dapat nitong mahanap ang address sa ibinigay na mga coordinate, o, kung ang address ay hindi mako-convert sa mga coordinate, ibalik ang Wala , null , Empty o anuman ang naaangkop na uri para sa ibinigay na wika . Ang function ay hindi dapat gumawa ng anumang bagay, tulad ng paghahanap ng mga kalapit na address o bumuo ng mga talaan ng coordinate. Maaaring may mga side effect ang isang function gaya ng pag-log o analytics, ngunit hindi ito nakikita ng input at output.

Maaaring masuri ang function

Dapat na idinisenyo ang mga tampok upang masuri ang mga ito. Sa nakaraang halimbawa ng code, tinukoy ko ang addCustomer function , ngunit hindi ko tinukoy ang anumang uri ng pagbabalik, kaya kaduda-dudang ang testability nito. Siyempre maaari itong masuri gamit ang mga pangungutya o espiya depende sa kung ano ang panloob na pagpapatupad, maaari itong makamit sa pamamagitan lamang ng pagbibigay ng uri ng pagbabalik:

fun addCustomer(customer: Customer): Customer

Gamit ang signature ng function na ito, maibabalik natin ang idinagdag na entity ng kliyente sa tinatawag na component. Maaari din nating suriin kung ginagawa ng function ang dapat nitong gawin sa object ng kliyente na ito (iyon ay, italaga ito ng isang natatanging identifier).