Paano mo kino-compile ang data sa Xcode?

Sa mundo Mula sa pag-develop ng app, itinatag ng Xcode ang sarili bilang isang mahalagang tool para sa mga programmer ng iOS at macOS. Gamit ang set ng tampok nito at malakas na IDE (Integrated Development Environment), pinapayagan ng Xcode ang mga developer lumikha ng mga aplikasyon mataas na kalidad at mahusay. Ang isa sa mga pangunahing elemento ng prosesong ito ay ang pagsasama-sama ng data. Sa artikulong ito, tutuklasin namin nang detalyado kung paano pinagsama-sama ang data sa Xcode, tinitingnan ang iba't ibang mga hakbang at pangunahing konsepto na kasangkot sa pangunahing prosesong ito. Mula sa pag-set up ng mga proyekto hanggang sa pagpapatakbo ng build, matutuklasan natin kung paano kinokolekta ng Xcode ang impormasyon at ginagawa itong isang magagamit na panghuling produkto. Panatilihin ang pagbabasa upang malaman lahat ng kailangan mong malaman tungkol sa pag-compile ng data sa Xcode at kung paano masulit ang mahalagang tool na ito para sa pagbuo ng app.

1. Panimula sa data compilation sa Xcode

2. Ang proseso ng pagbuo sa Xcode: isang pangkalahatang-ideya

Ang proseso ng compilation sa Xcode ay mahalaga para sa pagbuo ng mga application sa iOS. Kapag pinagsama-sama namin ang aming source code sa Xcode, nagsasagawa ang program ng isang serye ng mga hakbang upang i-convert ang aming code sa isang executable na maaaring patakbuhin sa isang iOS device. Nasa ibaba ang isang pangkalahatang-ideya ng prosesong ito at ang mga hakbang na kasangkot.

1. Paghahanda ng Proyekto: Bago simulan ang pagbuo, mahalagang tiyakin na ang aming proyekto ay na-configure nang tama sa Xcode. Kabilang dito ang pagtatakda ng mga kinakailangang setting gaya ng package ID, development mode, at ang minimum na sinusuportahang bersyon ng iOS. Dapat din nating i-verify na ang lahat ng kinakailangang file ay kasama sa proyekto.

2. Source code compilation: Kapag naihanda na ang proyekto, maaari na nating simulan ang source code compilation. Ginagamit ng Xcode ang Clang compiler para i-convert ang source code na nakasulat sa Objective-C, Swift, o iba pang sinusuportahang wika sa executable bytecode. Sa prosesong ito, magsasagawa ang compiler ng iba't ibang syntax at semantic na pagsusuri upang matiyak na walang mga error sa code.

3. Pag-uugnay at pag-iimpake: Pagkatapos ng compilation, ili-link ng Xcode ang iba't ibang object file na nabuo sa panahon ng compilation. Kabilang dito ang pagsasama-sama ng lahat ng kinakailangang function at reference sa iisang executable file. Ang executable ay pagkatapos ay naka-package sa isang .ipa file na maaaring i-install sa isang iOS device.

Sa buod, ang proseso ng pagbuo sa Xcode ay nagsasangkot ng paghahanda ng proyekto, pag-compile ng source code, at pag-link at pag-iimpake ng nagresultang executable. Mahalagang sundin nang maayos ang mga hakbang na ito upang matiyak ang tamang paggana ng application sa mga iOS device. Tandaan na regular na suriin kung may error at mga mensahe ng babala na maaaring lumabas sa panahon ng pagbuo, dahil maaaring magpahiwatig ito ng mga problema sa source code o configuration ng proyekto.

3. Pagtatakda ng mga opsyon sa pagbuo sa Xcode

Isa sa mga bentahe ng Xcode ay ang kakayahang umangkop nito upang ayusin ang mga opsyon sa compilation at i-optimize ang pagganap ng aming mga application. Sa seksyong ito, matututunan mo kung paano gawin ang configuration na ito mahusay.

1. Buksan ang iyong proyekto sa Xcode at piliin ang target ng application. Kapag tapos na ito, pumunta sa tab na "Build Settings". Dito makikita mo ang isang listahan ng mga pagpipilian sa pagbuo na maaari mong ayusin ayon sa iyong mga pangangailangan.

2. Upang paganahin ang mga partikular na opsyon sa pagbuo, gamitin ang mga tamang flag sa seksyong "Iba pang C Flag" o "Iba pang Swift Flag." Halimbawa, kung gusto mong paganahin ang pag-optimize ng laki ng code, idagdag ang flag na "-Os". Kung mas gusto mong paganahin ang pag-debug ng code, gamitin ang flag na "-DDEBUG".

3. Bukod pa rito, maaari mo ring i-customize ang mga opsyon sa pag-optimize para sa iba't ibang mga pagsasaayos. Halimbawa, kung gusto mong maglapat ng mga partikular na pag-optimize para sa configuration ng paglunsad, piliin ang kaukulang target at itakda ang naaangkop na mga opsyon sa tab na "Build Settings." Tandaan na ang mga opsyon sa pag-optimize ay maaaring makaapekto sa oras ng pagbuo at pagganap ng application, kaya gamitin ang mga ito nang may pag-iingat.

4. Pag-compile at pag-optimize ng data sa Xcode

Sa seksyong ito, matututunan mo kung paano isagawa ang mahusay na paraan. Ang pag-compile at pag-optimize ng data ay isang mahalagang proseso sa pagbuo ng software, dahil nagbibigay-daan ito sa amin na pahusayin ang pagganap ng aming mga application.

Upang magsimula, tiyaking mayroon kang pinakabagong bersyon ng Xcode na naka-install sa iyong device. Kapag nabuksan mo na ang Xcode, piliin ang proyektong iyong ginagawa. Pagkatapos, pumunta sa tab na "Mga Setting ng Bumuo" at tiyaking itinakda mo nang naaangkop ang mga opsyon sa pagbuo.

Tulad ng para sa pag-optimize ng data, ipinapayong gumamit ng mga profile ng pagganap ng Xcode upang matukoy ang mga potensyal na bottleneck sa iyong code. Gamit ang tool na ito, magagawa mong suriin ang paggamit ng CPU, memory at iba pang mapagkukunan ng device habang tumatakbo ang iyong application. Bukod pa rito, binibigyan ka rin ng Xcode ng kakayahang paganahin ang pag-optimize sa antas ng compiler, na maaaring makabuluhang mapabuti ang runtime ng iyong code.

Tandaan na nangangailangan ito ng pagsasanay at karanasan. Huwag mag-atubiling kumunsulta sa mga online na tutorial at mga halimbawa upang maging pamilyar sa mga pinakamahusay na kasanayan at tool na magagamit. Sa wastong pagtutok sa pagkolekta at pag-optimize ng data, magagawa mong bumuo ng mas mahusay na mga application at pagbutihin ang karanasan ng iyong mga user!

5. Mga karaniwang error sa proseso ng compilation ng data sa Xcode

Kapag nag-compile ng data sa Xcode, karaniwan na ang mga pagkakamali na maaaring makahadlang sa proseso. Gayunpaman, mahalagang malaman ang pinakakaraniwang mga error at kung paano ayusin ang mga ito upang matiyak ang matagumpay na pagbuo nang hindi nag-aaksaya ng hindi kinakailangang oras at pagsisikap.

Ang isa sa mga pinakakaraniwang pagkakamali sa proseso ng pagsasama-sama ng data sa Xcode ay ang pagkalimot na mag-import ng mga aklatan o mga balangkas na kinakailangan para sa proyekto. Upang ayusin ang isyung ito, mahalagang maingat na suriin ang lahat ng mga dependency ng proyekto at tiyaking na-import nang tama ang mga kinakailangang file. Ang paggamit ng tampok na autocomplete ng Xcode sa search bar ay maaaring maging malaking tulong sa paghahanap ng mga kinakailangang aklatan.

Ang isa pang karaniwang error ay ang mga path ng file ay hindi naitakda nang tama. Mahalagang i-verify na ang ganap o kamag-anak na mga landas ng file ay nakasulat nang tama sa code. Bilang karagdagan, ipinapayong gumamit ng mga variable o macro para sa mga ruta, na magpapadali sa kanilang pagbabago kung kinakailangan. Ang pagrepaso sa mga gumaganang direktoryo at mga folder ng paghahanap sa mga setting ng proyekto ay kapaki-pakinabang din para sa pag-detect at pagwawasto ng mga error sa mga path ng file.

6. Pag-debug ng mga error sa pagbuo sa Xcode

Ito ay isang pangunahing bahagi ng proseso ng pagbuo ng aplikasyon. Kapag nakatagpo kami ng error sa pagbuo, mahalagang malaman kung paano tukuyin ang problema at ayusin ito nang mabilis at mahusay. Sa seksyong ito, tutuklasin namin ang iba't ibang mga diskarte at tool na makakatulong sa iyong pag-debug ng mga error sa Xcode.

1. Kilalanin ang error: ang unang bagay na dapat mong gawin ay kilalanin ang error. Upang gawin ito, ipapakita sa iyo ng Xcode ang mensahe ng error sa window ng output. Mahalagang basahin nang mabuti ang mensaheng ito, dahil magbibigay ito sa iyo ng clue kung saan ang problema. Suriin din ang linya ng code na binanggit sa mensahe dahil maaaring makatulong ito sa paghahanap ng error.

2. Gumamit ng mga tool sa pag-debug: Ang Xcode ay may ilang mga tool sa pag-debug na makakatulong sa iyong makilala at ayusin ang mga error sa compilation. Maaari mong gamitin ang Xcode debugger upang suriin ang daloy ng pagpapatupad ng iyong programa, suriin ang halaga ng mga variable, at marami pang iba. Maaari mo ring gamitin ang static analyzer ng Xcode upang mahanap ang mga karaniwang error sa programming, tulad ng mga hindi nakatalagang object reference o hindi nagamit na mga variable.

7. Pinakamahuhusay na kagawian para sa pag-compile ng data sa Xcode

Sa seksyong ito, tutuklasin natin ang ilan sa mga . Kapag nagtatrabaho sa isang proyekto sa Xcode, napakahalaga na ayusin at maipon ang data nang tama upang matiyak ang mahusay at matagumpay na pag-unlad.

Isa sa mahahalagang unang hakbang ay ang pag-unawa at paggamit ng mga naaangkop na istruktura ng data. Nag-aalok ang Xcode ng iba't ibang istruktura ng data, tulad ng mga array, diksyunaryo, at set, na maaaring umangkop sa iba't ibang uri at pangangailangan ng data. Mahalagang piliin ang tamang istruktura ng data batay sa mga kinakailangan ng proyekto at maunawaan kung paano ito gamitin epektibo.

Bukod pa rito, ipinapayong gumamit ng pare-pareho at makabuluhang mga kasanayan sa appointment. Kapag pinangalanan ang mga variable at pamamaraan, mahalagang gumamit ng malinaw at mapaglarawang mga pangalan na nagpapakita ng kanilang layunin at functionality. Gagawin nitong mas madaling mapanatili at maunawaan ang code, para sa iyo at para sa mga developer sa hinaharap na nagtatrabaho sa proyekto.

Ang isa pang magandang kasanayan ay ang paggamit ng naaangkop na mga komento upang idokumento ang iyong code. Ang mga komento ay teksto na idinagdag sa source code upang ipaliwanag ang operasyon at layunin nito. Ang pagsasama ng mga kapaki-pakinabang at malinaw na komento sa iyong code ay makakatulong sa iyong matandaan kung paano ito gumagana at ipaalam ang iyong mga intensyon sa ibang mga developer. Ito ay lalong kapaki-pakinabang sa mga collaborative na proyekto o kapag kailangan mong i-rework ang code pagkaraan ng ilang sandali.

8. Paano gamitin ang build command sa Xcode

Ang isa sa mga pangunahing tampok ng Xcode ay ang kakayahang mag-compile at magpatakbo ng code nang mahusay. Sa artikulong ito, ipapaliwanag namin hakbang-hakbang upang i-optimize ang pagganap ng iyong proyekto.

1. Piliin ang iyong proyekto: Buksan ang Xcode at piliin ang proyektong gusto mong gawin. Tiyaking nasa naaangkop na tab ka (halimbawa, kung gumagawa ka ng isang proyekto sa iOS, tiyaking nasa tab na iOS ka).

2. Piliin ang build scheme: Sa menu bar, pumunta sa Product -> Scheme -> Edit Scheme. Dito maaari mong piliin ang scheme ng compilation na gusto mong gamitin. Kung hindi ka pa nakakagawa noon, magagawa mo ito sa pamamagitan ng pag-tap sa "+" na button sa kaliwang sulok sa ibaba.

3. I-configure ang mga build command: Kapag napili mo na ang build scheme, pumunta sa tab na “Build Phase”. Dito maaari mong idagdag ang mga build command na gusto mong gamitin. Maaari kang magdagdag ng mga bagong command sa pamamagitan ng pag-click sa button na "+" sa kaliwang sulok sa ibaba.

Tandaan na binibigyang-daan ka ng mga build command na i-customize ang proseso ng build ng iyong proyekto ayon sa iyong mga pangangailangan. Mag-eksperimento sa iba't ibang command at alamin kung paano i-optimize ang performance ng iyong application sa Xcode!

9. Paggalugad ng mga advanced na opsyon sa pagbuo sa Xcode

Kapag napag-aralan mo na ang mga pangunahing opsyon sa pagbuo sa Xcode, maaari mong simulan ang paggalugad sa mga advanced na opsyon upang makakuha ng higit na kontrol sa proseso ng pagbuo. Sa seksyong ito, ipapakita namin sa iyo ang ilan sa mga opsyong ito at kung paano mo magagamit ang mga ito upang i-optimize ang iyong workflow.

Isa sa mga pinakakapaki-pakinabang na advanced na opsyon ay ang kakayahang mag-customize ng mga flag ng build. Ang mga flag ay mga opsyon na ipinapasa sa compiler sa panahon ng proseso ng compilation at nagbibigay-daan sa mga partikular na pagsasaayos na gawin sa code. Halimbawa, maaari mong gamitin ang flag na "-O3" upang ilapat ang mataas na antas ng pag-optimize sa code, na magreresulta sa mas mabilis na pagganap. Maaari mong idagdag ang mga flag na ito sa seksyong "Bumuo ng Mga Setting" ng iyong proyekto sa Xcode.

Ang isa pang mahalagang advanced na opsyon ay ang kakayahang gumamit ng mga preprocessor sa iyong code. Nagbibigay-daan sa iyo ang mga preprocessor na magsagawa ng mga kondisyong aksyon sa source code bago ito ma-compile. Halimbawa, maaari kang gumamit ng mga preprocessor upang isama ang ilang partikular na seksyon ng code sa debug mode lamang o upang baguhin ang mga function ng isang library depende sa target na platform. Maaari mong i-activate ang preprocessor sa seksyong "Build Settings" at gamitin ang naaangkop na syntax upang maisagawa ang mga gustong aksyon.

10. Bumuo at Pagganap sa Xcode: Mga Tip at Trick

Upang ma-optimize ang compilation at performance sa Xcode, inirerekomendang sundin ang isang serye ng mga tip at trick na makakatulong na mapabilis ang proseso ng pagbuo at mapabuti ang kahusayan ng code. Nasa ibaba ang ilang rekomendasyon para masulit ang tool ng Apple:

1. Gamitin ang incremental compilation system: Ang Xcode ay may opsyon na tinatawag na "Incremental Builds" na nagbibigay-daan sa iyong i-compile lang ang mga file na binago mula noong huling compilation. Lubos nitong binabawasan ang oras ng pagtatayo, lalo na sa malalaking proyekto. Upang i-activate ang opsyong ito, pumunta sa mga kagustuhan sa Xcode at piliin ang "Build System" at pagkatapos ay piliin ang "Incremental Builds".

2. I-optimize ang code: Mahalagang suriin at i-optimize ang code upang mapabuti ang pagganap. Kasama sa ilang magagandang kagawian ang pag-iwas sa labis na paggamit ng mga mamahaling function call, paggamit ng mahusay na mga istruktura ng data, at pag-iwas sa hindi kinakailangang pagdoble ng code. Inirerekomenda rin na gumamit ng mga profile ng instrumentation ng Xcode upang matukoy ang mga bottleneck sa pagganap at gumawa ng mga pagpapabuti.

11. Pag-compile ng data sa Xcode para sa iba't ibang platform at device

Ang pag-compile ng data sa Xcode ay isang pangunahing gawain upang matiyak na ang aming mga application ay maaaring gumana nang tama sa iba't ibang mga platform at device. Nasa ibaba ang mga hakbang na kinakailangan upang maisagawa ang prosesong ito:

1. Paggawa ng bagong build scheme: Mahalagang gumawa ng ibang scheme para sa bawat target na platform o device. Magbibigay-daan ito sa amin na i-configure ang mga partikular na opsyon sa pagbuo para sa bawat isa.
2. Pagpili ng Build Target: Sa Xcode, maaari naming piliin ang gustong build target mula sa tuktok na navigation bar. Dito maaari naming piliin ang platform at ang aparato kung saan nais naming i-compile ang aming data.
3. Pag-configure ng mga opsyon sa build: kapag napili na ang build target, dapat nating i-configure ang mga kaukulang opsyon. Kasama sa mga opsyong ito ang bersyon ng sistema ng pagpapatakbo, mga configuration ng debug, at uri ng build (debug o release).

Bukod pa rito, ipinapayong sundin ang ilang magagandang kasanayan upang matiyak ang kalidad ng pagsasama-sama ng data sa Xcode:

• Magsagawa ng mga pagsusulit sa iba't ibang mga aparato: mahalagang subukan ang aplikasyon sa iba't ibang device upang i-verify ang tamang operasyon at hitsura nito. Magbibigay-daan ito sa amin na matukoy ang mga potensyal na isyu sa compatibility at gumawa ng mga kinakailangang pagsasaayos.
• I-optimize ang code: Maipapayo na suriin ang code at i-optimize ito upang mapabuti ang kahusayan at pagganap ng application. Kabilang dito ang pag-alis ng hindi kinakailangang code, paggamit ng pinakamahuhusay na kasanayan sa pag-coding, at pag-iwas sa mga redundancies.
• Gumamit ng mga static na tool sa pagsusuri: may mga tool tulad ng "Analyzer" sa Xcode na nagbibigay-daan sa amin na makakita ng mga posibleng error at kahinaan sa aming code. Ang mga tool na ito ay lubhang kapaki-pakinabang upang magarantiya ang seguridad at katatagan ng application.

12. Paggamit ng mga panlabas na framework at library sa proseso ng compilation sa Xcode

Ang paggamit ng mga panlabas na balangkas at aklatan sa proseso ng compilation sa Xcode ay maaaring maging pangunahing gawain para sa mga developer. Ang mga panlabas na tool na ito ay nag-aalok ng karagdagang functionality na ginagawang mas mabilis at mas madali ang pagbuo ng mga application. Nasa ibaba ang mga hakbang na kinakailangan upang maisagawa ang prosesong ito.

1. I-download ang framework o ang gustong panlabas na library mula sa opisyal na website ng developer. Mahalagang tiyaking pipiliin mo ang tamang bersyon, na tugma sa bersyon ng Xcode na iyong ginagamit.

2. Kapag na-download na, ang framework o library ay dapat na kasama sa proyekto ng Xcode. Upang gawin ito, i-drag ang na-download na file mula sa lokasyon nito sa file system patungo sa kaliwang sidebar ng Xcode, kung saan matatagpuan ang mga file ng proyekto.

3. Kapag naidagdag na ang balangkas o aklatan, kailangang ayusin ang mga pagsasaayos ng compilation upang magamit ito ng proyekto. Upang gawin ito, dapat mong piliin ang proyekto sa kaliwang sidebar ng Xcode, pagkatapos ay piliin ang target ng application at pumunta sa tab na "Build Phases". Sa seksyong ito makikita mo ang mga opsyon para magdagdag ng mga panlabas na framework at library.

Mahalagang sundin nang mabuti ang mga hakbang na ito upang matiyak na ang proyekto ay na-configure nang tama at maaaring gumamit ng mga panlabas na framework at library. Ito ay magbibigay-daan sa iyo upang lubos na mapakinabangan ang karagdagang pag-andar at pagbutihin ang proseso ng pagbuo sa Xcode. [END

13. Mga tool sa pagsubaybay at pagsusuri ng error sa compilation ng data sa Xcode

Upang mapanatili ang mataas na antas ng kalidad sa compilation ng data sa Xcode, mahalagang gumamit ng mga tool sa pagsubaybay at pagsusuri ng error. Tutulungan ka ng mga tool na ito na matukoy at maayos ang mga error sa code nang mahusay. Sa artikulong ito, ipapakilala namin sa iyo ang ilan sa mga pinakakapaki-pakinabang na tool at kung paano gamitin ang mga ito sa iyong workflow.

Ang isa sa mga pinakasikat na tool para sa pagsusuri ng error sa Xcode ay Static Analyzer. Ang tool na ito ay nagsasagawa ng static na pagsusuri ng code na naghahanap ng mga potensyal na problema, tulad ng mga pagtagas ng memorya, hindi nasimulan na mga variable, o mga maling function na tawag. Awtomatikong tumatakbo ang Static Analyzer sa tuwing bubuo ka ng iyong proyekto, at makikita mo ang mga resulta sa tab na "Mga Isyu" sa loob ng Xcode.

Isa pang kapaki-pakinabang na kagamitan ay Pang-debug, na nagbibigay-daan sa iyong pag-aralan ang daloy ng pagpapatupad ng iyong code at maghanap ng mga error sa runtime. Maaari kang gumamit ng mga breakpoint upang ihinto ang pagpapatupad sa ilang partikular na linya ng code at i-parse ang mga value ng mga ito. Bilang karagdagan, maaari mong gamitin ang debugger upang suriin ang mga variable sa iba't ibang mga punto ng pagpapatupad at hanapin ang pinagmulan ng isang error.

14. Pagsubok at QA sa proseso ng pagbuo sa Xcode

Sa anumang proseso ng pagbuo ng software, ang pagsubok at kontrol sa kalidad ay mahalaga upang matiyak ang paggana at pagiging maaasahan ng huling produkto. Sa kaso ng pagbuo sa Xcode, mayroong iba't ibang mga diskarte at tool na makakatulong sa mga developer na magsagawa ng epektibong pagsubok at kalidad ng kasiguruhan sa buong proseso ng pagbuo.

Ang isa sa mga pangunahing tool na inaalok ng Xcode para sa pagsubok ay ang iOS Simulator, na nagbibigay-daan sa iyong patakbuhin at subukan ang application sa isang virtual na kapaligiran bago ito dalhin sa mga totoong device. Nakakatulong ito na makita ang mga potensyal na isyu sa pagganap o hindi pagkakatugma bago ilabas ang app sa merkado. Higit pa rito, ang iOS Simulator Mayroon itong mga tool sa pag-debug na nagbibigay-daan sa iyong matukoy at malutas ang mga error nang mas mahusay.

Ang isa pang napaka-kapaki-pakinabang na tool para sa pagsubok at QA sa Xcode ay Pagsubok sa UI. Binibigyang-daan ka ng tool na ito na i-automate ang mga pagsubok sa user interface, na ginagawang mas madaling makita ang mga problema sa visual o pakikipag-ugnayan ng user. Ang mga developer ay maaaring lumikha ng mga pagsubok na kaso na gayahin ang mga aksyon ng user, tulad ng pag-tap sa mga button o pag-swipe ng mga screen, at i-verify na ang application ay kumikilos nang tama. Bukod sa, Pagsubok sa UI nag-aalok ng mga detalyadong ulat sa mga nakitang pagkakamali, na tumutulong sa mga developer na ayusin ang mga problema nang mabilis.

Sa konklusyon, nag-aalok ang Xcode ng malawak na hanay ng mga tool at pamamaraan para sa pagsasama-sama ng data. Mula sa pagkolekta ng static na impormasyon hanggang sa pag-debug ng code sa runtime, ang pinagsama-samang development environment na ito ay namumukod-tangi para sa kahusayan at kadalian ng paggamit nito. Sa pamamagitan ng pagsasamantala sa maramihang mga pagpipilian sa pagbuo na magagamit sa Xcode, maaaring i-optimize at pagbutihin ng mga developer ang pagganap ng kanilang mga application. Bukod pa rito, ang pagsasama ng Xcode sa mga tool sa pag-debug at mga profile ng pagganap ay nagbibigay ng malalim na insight sa kung paano kumikilos ang data sa panahon ng compilation. Sa Xcode, ang mga developer ay may kumpletong hanay ng mga mapagkukunan sa kanilang pagtatapon upang matiyak ang kalidad at kahusayan ng kanilang mga proyekto. Sa makapangyarihang tool na ito, nagiging mas tuluy-tuloy at kontroladong proseso ang pagsasama-sama ng data. Sa madaling salita, ang Xcode ay ipinakita bilang perpektong kaalyado para sa mga nais mag-compile ng data nang epektibo at mahusay.