Hello, Habr! Ipinakita ko sa iyong pansin ang isang pagsasalin ng post ni Stephen Wolfram
Mga kinakailangan para sa pagkakapare-pareho ng wikang Wolfram
Ngayon nakatayo kami sa threshold ng mahusay na mga tagumpay kasama ang programming language
Ang Wolfram Function Repository ay isang bagay na ginawang posible sa pamamagitan ng kakaibang katangian ng Wolfram Language hindi lamang bilang isang programming language, kundi bilang isang
Halimbawa, naglalaman na ang Wolfram function repository
Gayundin higit sa
Upang makarating sa pahina, kopyahin ang bagay sa itaas (function na BLOB), i-paste ito sa linya ng pag-input at pagkatapos ay patakbuhin ang function - ito ay naka-built na sa wikang Wolfram at sinusuportahan bilang default simula sa
Dapat pansinin dito na kapag nagpoproseso
Sana sa suporta
Ang mga function mula sa repository ay maaaring maglaman ng maliliit o malalaking piraso ng code na nakasulat sa Wolfram Language. Halimbawa, maaaring ito ay mga tawag
Ang istraktura ng shell at programming ng Wolfram Feature Repository ay idinisenyo upang ang lahat ay makapag-ambag sa karaniwang dahilan sa pinakasimple at maginhawang paraan para sa kanila - sa katunayan, lamang
Mayroong maraming mga trade-off at mga detalye sa diskarteng ito, ngunit ang aming layunin ay i-optimize ang Wolfram feature repository para sa karanasan ng user at upang matiyak na ang mga bagong feature ng user ay makabuluhang nakakatulong sa pagbuo ng wika. Habang lumalaki tayo, wala akong duda na kakailanganin nating mag-imbento ng mga bagong pamamaraan para sa pagproseso at pagpapatunay ng mga function na binuo sa repositoryo, hindi bababa sa para sa pag-aayos ng malaking bilang ng mga function at paghahanap ng mga kailangan ng mga user. Gayunpaman, nakapagpapatibay na ang landas na aming pinili ay isang magandang simula. ako mismo
Pagtaas ng kahusayan habang binabawasan ang mga gastos
Bago pa man ang Internet, may mga paraan upang ibahagi ang Wolfram Language code (ang aming unang pangunahing sentralisadong proyekto ay
Sa loob ng mahigit 30 taon, masigasig na nagtrabaho ang aming kumpanya upang mapanatili ang integridad ng istruktura ng wikang Wolfram, at ito ay kritikal sa pagtiyak na ang wikang Wolfram ay hindi lamang nagiging isang programming language, kundi isang
Ang iba't ibang mga proseso ng computational ay nangyayari sa istraktura ng pagpapatupad ng bawat function. Dapat tandaan dito na kinakailangan na ang function ay may malinaw at pare-parehong hitsura at visual na kakayahang mabasa para sa gumagamit. Sa kontekstong ito, ang mga built-in na function ng Wolfram Language ay ipinakita na may higit sa 6000 sunud-sunod na mga halimbawa kung paano maayos na magprogram ng mga function (ito ang aming
Ang paglikha ng isang repositoryo na talagang gumagana nang maayos ay isang kawili-wiling gawain sa meta-programming. Halimbawa, ang labis na mga paghihigpit sa programa ay hindi magpapahintulot sa pagkuha ng kinakailangang pag-iisa at pagiging pandaigdigan ng algorithm. Tulad ng hindi sapat na bilang ng mga functional na paghihigpit, hindi mo magagawang ipatupad ang isang sapat na tamang pagkakasunod-sunod ng pagpapatupad ng algorithm. Ilang mga nakaraang halimbawa ng pagpapatupad ng kompromiso ng mga pamamaraang ito, na ipinatupad ng aming kumpanya, ay gumana nang maayos - ito ay:
Ang lahat ng mga halimbawa sa itaas ay may pangunahing tampok - ang mga bagay at function na nakolekta sa proyekto ay may napakataas na antas ng pag-istruktura at pamamahagi ng mga proseso. Siyempre, ang detalye ng istraktura ng kung ano ang isang demo o isang neural network o iba pa ay maaaring mag-iba nang malaki, ngunit ang pangunahing istraktura para sa anumang kasalukuyang repositoryo ay palaging nananatiling pareho. Kaya ano ang iyong opinyon, mahal na gumagamit, tungkol sa paggawa ng ganoong repositoryo na nagdaragdag ng mga extension sa wikang Wolfram? Ang Wolfram Language ay idinisenyo upang maging lubhang nababaluktot, kaya maaari itong palawigin at baguhin sa anumang paraan. Napakahalaga ng sitwasyong ito para sa kakayahang mabilis na lumikha ng iba't ibang malalaking proyekto ng software sa Wolfram Language. Dapat pansinin dito na habang tumataas ang flexibility ng wika, hindi maiiwasang tataas ang halaga ng mga proyektong ipinapatupad sa naturang wika. Ito ay dahil sa ang katunayan na ang gumagamit ay gumagamit ng ganoong wika, mas nakatuon ang pag-andar na natatanggap niya, ngunit hindi namin dapat kalimutan na ang diskarte na ito ay maaari ding magkaroon ng mga negatibong panig sa mga tuntunin ng kawalan ng kakayahan upang matiyak ang pare-parehong pagkakapare-pareho ng mga module ng programa.
Mayroong karaniwang problema sa mga aklatan sa tradisyonal na mga wika ng programming - kung gumamit ka ng isang library, halimbawa, gagana nang tama ang code, ngunit kung susubukan mong gumamit ng maraming aklatan, walang garantiya na makikipag-ugnayan sila nang tama sa isa't isa . Gayundin, sa mga tradisyunal na programming language - hindi tulad ng isang ganap na computing language - walang paraan upang magarantiya ang pagkakaroon ng pare-parehong built-in na representasyon para sa anumang mga function o uri ng data maliban sa kanilang mga pangunahing istruktura. Ngunit, sa katunayan, ang problema ay mas malaki kaysa sa tila sa unang sulyap: kung ang isa ay nagtatayo ng isang malakihang patayo ng pag-andar, kung wala ang malaking gastos ng sentralisadong proyekto ng programming na inilalagay namin sa wikang Wolfram, imposibleng makamit ang pagkakapare-pareho. Samakatuwid, mahalaga na ang lahat ng mga module ng software ay palaging gumagana nang tama.
Kaya ang ideya sa likod ng imbakan ng tampok na Wolfram ay upang maiwasan ang problemang nakabalangkas sa itaas sa pamamagitan lamang ng pagdaragdag ng mga extension sa wika sa medyo maliliit na piraso ng code sa pamamagitan ng mga indibidwal na tampok na mas madaling bumuo bilang magkakaugnay na mga module. Iyon ay sinabi, may mga tampok sa programming na hindi maaaring gawing maginhawa gamit ang mga indibidwal na function (at ang aming kumpanya ay nagpaplano na maglabas ng isang na-optimize na algorithm ng programming sa malapit na hinaharap upang makatulong na ipatupad ang mga malalaking pakete ng software). Gayunpaman, batay sa mga function na naka-built na sa Wolfram Language, maraming mga posibilidad sa programming na ipinatupad batay sa mga indibidwal na function. Ang ideya dito ay na may medyo maliit na pagsisikap sa programming posible na lumikha ng isang bilang ng mga bago at napaka-kapaki-pakinabang na mga pag-andar na magbibigay ng sapat na pagkakaugnay-ugnay sa disenyo, sila ay maayos na magkakaugnay sa bawat isa, at gayundin, bilang karagdagan dito, sila ay magiging madali at malawak na magagamit sa wika sa hinaharap.
Ang diskarte na ito ay, siyempre, isang kompromiso. Kung ang isang mas malaking pakete ay ipinatupad, ang isang buong bagong mundo ng pag-andar ay maaaring isipin na magiging napakalakas at kapaki-pakinabang. Kung may pangangailangan na makakuha ng bagong functionality na akma sa lahat ng iba pa, ngunit hindi ka handang gumastos ng maraming pagsisikap sa pagbuo ng proyekto, ito, sa kasamaang-palad, ay maaaring humantong sa isang pagbawas sa saklaw ng iyong proyekto. Ang ideya sa likod ng imbakan ng tampok na Wolfram ay upang magbigay ng functionality sa isang tiyak na bahagi ng isang proyekto; ang diskarte na ito ay magdaragdag ng malakas na pag-andar habang ginagawang mas madali ang pagpapanatili ng mahusay na pagkakapare-pareho sa isang proyekto ng programming.
Tumulong sa pagdaragdag ng mga custom na function sa repository ng function
Nagsumikap nang husto ang aming team para gawing madali para sa mga user na mag-ambag sa mga feature ng repository ng Wolfram. Sa desktop (nasa
Mayroong dalawang pangunahing hakbang na kakailanganin mong gawin: una, aktwal na isulat ang code para sa iyong function at, pangalawa, isulat ang dokumentasyon na naglalarawan kung paano dapat gumana ang iyong function.
I-click ang button na "Buksan ang Sample" sa itaas para makakita ng halimbawa ng kailangan mong gawin:
Sa pangkalahatan, sinusubukan mong lumikha ng isang bagay na katulad ng isang built-in na function sa Wolfram Language. Maliban na maaari itong gumawa ng isang bagay na mas tiyak kaysa sa isang built-in na function. Kasabay nito, ang mga inaasahan tungkol sa pagiging kumpleto at pagiging maaasahan nito ay magiging mas mababa.
Kailangan mong bigyan ang iyong function ng isang pangalan na sumusunod sa mga alituntunin sa pagpapangalan ng function ng Wolfram Language. Bilang karagdagan, kakailanganin mong bumuo ng dokumentasyon para sa iyong function, katulad ng mga built-in na function ng wika. Pag-uusapan ko ito nang mas detalyado mamaya. Sa ngayon, pansinin lamang na sa hilera ng mga pindutan sa tuktok ng file ng kahulugan ng notebook ay mayroong isang pindutan
Kapag sigurado kang napunan nang maayos ang lahat at handa ka na, i-click ang "Check" button. Ito ay ganap na normal na hindi mo pa naiisip ang lahat ng mga detalye. Kaya ang function na "Check" ay awtomatikong tatakbo at gagawa ng maraming estilo at consistency checks. Kadalasan, ipo-prompt ka kaagad nito na kumpirmahin at tanggapin ang mga pagwawasto (Halimbawa: "Ang linyang ito ay dapat magtapos sa isang tutuldok," at ipo-prompt ka nitong maglagay ng tutuldok). Minsan hihilingin niya sa iyo na idagdag o baguhin ang isang bagay sa iyong sarili. Patuloy kaming magdaragdag ng mga bagong feature sa awtomatikong functionality ng Check button, ngunit ang layunin nito ay tiyaking lahat ng isusumite mo sa feature repository ay malapit nang sumusunod sa pinakamaraming istilong alituntunin hangga't maaari.
Kaya, pagkatapos patakbuhin ang "Check", maaari mong gamitin ang "Preview". Lumilikha ang "Preview" ng preview ng pahina ng dokumentasyong tinukoy mo para sa iyong function. Maaari ka ring gumawa ng preview para sa isang file na ginawa sa iyong computer o para sa isang file na matatagpuan sa cloud storage. Kung, sa ilang kadahilanan, hindi ka nasisiyahan sa nakikita mo sa preview, bumalik lang at gawin ang mga kinakailangang pagwawasto, at pagkatapos ay i-click muli ang pindutan ng Preview.
Ngayon ay handa ka nang itulak ang iyong function sa repositoryo. Ang Deploy button ay nagbibigay sa iyo ng apat na opsyon:
Ang mahalagang bagay sa hakbang na ito ay maaari mong isumite ang iyong function sa Wolfram function repository upang ito ay available sa sinuman. Kasabay nito, maaari mo ring ilagay ang iyong function para sa limitadong bilang ng mga user. Halimbawa, maaari kang lumikha ng isang function na lokal na naka-host sa iyong computer upang ito ay magagamit kapag ginamit mo ang partikular na computer na iyon. O maaari mo itong i-post sa iyong
Kaya sabihin nating gusto mong aktwal na isumite ang iyong function sa Wolfram function knowledge base. Upang gawin ito, i-click mo ang pindutang "Isumite" sa repositoryo. Kaya ano ang nangyayari sa sandaling ito? Ang iyong aplikasyon ay agad na nakapila para sa pagsusuri at pag-apruba ng aming nakatuong pangkat ng mga curator.
Habang umuusad ang iyong aplikasyon sa proseso ng pag-apruba (na karaniwang tumatagal ng ilang araw), makakatanggap ka ng mga komunikasyon tungkol sa katayuan nito at posibleng mga mungkahi para sa paggamit sa hinaharap. Ngunit kapag naaprubahan na ang iyong feature, agad itong maipa-publish sa Wolfram Feature Repository at magiging available para magamit ng sinuman. (At ito ay lilitaw sa
Ano ang dapat na nasa imbakan?
Dapat tandaan na ang aming kumpanya ay may napakataas na pamantayan para sa pagkakumpleto, pagiging maaasahan at pangkalahatang kalidad, at sa 6000+ na mga function na na-buo na namin sa wikang Wolfram sa nakalipas na 30+ taon, lahat ay nakakatugon sa mga kinakailangan sa itaas. Ang layunin ng Wolfram Function Repository ay gamitin ang lahat ng istruktura at functionality na mayroon na sa Wolfram Language upang magdagdag ng mas maraming mas magaan na function (iyon ay, mas mataas na performance function) hangga't maaari.
Siyempre, ang mga function sa Wolfram function repository ay dapat sumunod sa mga prinsipyo ng disenyo ng Wolfram Language - upang ganap silang makipag-ugnayan sa iba pang mga function at mga inaasahan ng mga user kung paano dapat gumana nang maayos ang function. Gayunpaman, ang mga pag-andar ay hindi kailangang maging pantay na pagkakumpleto o pagiging maaasahan.
Sa mga built-in na function ng Wolfram language, nagsusumikap kami na gawing pangkalahatan ang mga function ng programming hangga't maaari. Iyon ay sinabi, kapag sa Wolfram function repository walang mali sa pagkakaroon ng isang function sa loob nito na simpleng humahawak ng ilang napaka-espesipiko ngunit kapaki-pakinabang na kaso. Halimbawa, ang function
Ang isa pang puntong nauugnay sa mga built-in na function ay ginagawa ng aming kumpanya ang lahat ng pagsusumikap na pangasiwaan ang lahat ng hindi tipikal na mga kaso, upang wastong pangasiwaan ang maling input, at iba pa. Sa isang imbakan ng function, ganap na normal na mayroong isang espesyal na function na humahawak sa mga pangunahing kaso ng paglutas ng isang problema at binabalewala ang lahat ng iba pa.
Ang malinaw na punto ay mas mahusay na magkaroon ng mga pag-andar na higit na nagagawa at nagagawa ito nang mas mahusay, ngunit ang pag-optimize para sa isang imbakan ng pag-andar - bilang kabaligtaran sa mga built-in na pag-andar ng wikang Wolfram - ay dapat magkaroon ng higit pang mga pag-andar na kasama ng higit pang mga pag-andar kaysa sa pag-aaral. ang mga proseso ng pagpapatupad ng bawat partikular na function.
Ngayon tingnan natin ang isang halimbawa ng mga function ng pagsubok sa isang repositoryo. Ang mga inaasahan sa pagkakapare-pareho para sa mga naturang function ay natural na mas mababa kaysa sa mga built-in na function ng wika. Ito ay totoo lalo na sa mga kaso kung saan ang mga function ay nakasalalay sa mga panlabas na mapagkukunan tulad ng mga API, mahalagang patuloy na magsagawa ng mga pare-parehong pagsubok, na awtomatikong nangyayari sa loob ng mga algorithm ng pag-verify. Sa nb file, maaari mong tahasang tukuyin ang mga kahulugan (sa seksyong Karagdagang Impormasyon) at tukuyin ang maraming pagsubok gaya ng tinukoy ng alinman sa input at output string o buong character na mga bagay na may uri.
Bilang resulta, ang imbakan ng function ay magkakaroon ng ilang kumplikadong pagpapatupad. Ang ilan ay magiging isang solong linya lamang ng code, ang iba ay maaaring may kasamang libu-libo o sampu-sampung libong linya, malamang na gumagamit ng maraming mga function ng helper. Kailan ito nagkakahalaga ng pagdaragdag ng isang function na nangangailangan ng napakakaunting code upang tukuyin? Talaga, kung para sa isang function mayroong
Ang pangunahing layunin ng isang function repository (tulad ng ipinahihiwatig ng pangalan nito) ay upang ipakilala ang mga bagong feature sa wika. Kung gusto mong magdagdag ng bagong data o
May dalawang paraan talaga. Baka gusto mong magpakilala ng bagong uri ng bagay na gagamitin sa mga bagong function sa repository ng function. At sa kasong ito, maaari mo lamang isulat ang simbolikong representasyon nito at gamitin ito kapag nag-input o nag-output ng mga function sa isang function repository.
Ngunit paano kung gusto mong kumatawan sa isang bagay at pagkatapos ay tukuyin, sa pamamagitan ng mga umiiral na function sa Wolfram Language, na gusto mong gamitin ito? Ang Wikang Wolfram ay palaging may magaan na mekanismo para dito, na tinatawag
Kaya, ano ang maaaring nasa function code sa isang function repository?
Dapat bang isulat ang lahat ng code para sa Wolfram feature repository sa Wolfram? Tiyak, ang code sa loob ng panlabas na API ay hindi dapat isulat sa wikang Wolfram, na hindi man lang gumagawa ng code ng wika. Sa katunayan, kung makakita ka ng function sa halos anumang panlabas na wika o library, maaari kang lumikha ng wrapper na nagbibigay-daan sa iyong gamitin ito sa Wolfram function repository. (Karaniwan ay dapat mong gamitin ang mga built-in na function para dito
Kaya ano ang punto ng paggawa nito? Sa pangkalahatan, pinapayagan ka nitong gamitin ang buong pinagsama-samang Wolfram Language system at ang buong pinag-isang hanay ng mga kakayahan ng software. Kung makuha mo ang batayang pagpapatupad mula sa isang panlabas na aklatan o wika, maaari mong gamitin ang mayamang simbolikong istruktura ng Wikang Wolfram upang lumikha ng isang maginhawang top-level na function na nagbibigay-daan sa mga user na madaling gumamit ng anumang functionality na naipatupad na. Hindi bababa sa, ito ay dapat na magagawa sa isang perpektong mundo kung saan ang lahat ng mga bloke ng pagbuo ng pag-load ng mga aklatan atbp ay umiiral, kung saan ang mga ito ay awtomatikong pangasiwaan ng Wolfram Language. (Dapat tandaan na sa pagsasanay ay maaaring may mga problema sa
Sa pamamagitan ng paraan, kapag una mong tiningnan ang mga tipikal na panlabas na aklatan, kadalasan ay mukhang masyadong kumplikado ang mga ito upang saklawin sa ilang mga function, ngunit sa maraming mga kaso, ang karamihan sa pagiging kumplikado ay nagmumula sa paglikha ng imprastraktura na kailangan para sa library at lahat ng mga function upang suportahan ito. Gayunpaman, kapag ginagamit ang Wolfram Language, ang imprastraktura ay karaniwang naka-built na sa mga package, kaya hindi na kailangang ilantad ang lahat ng mga function ng suporta na ito nang detalyado, ngunit lumikha lamang ng mga function para sa "pinakamataas" na mga function na partikular sa application sa library. .
"Ecosystem" ng base ng kaalaman
Kung nagsulat ka ng mga function na regular mong ginagamit, isumite ang mga ito sa Wolfram Function Repository! Kung ang isang bagay ay hindi lumabas mula dito (pag-unlad ng wika), pagkatapos ay magiging mas maginhawa para sa iyo na gamitin ang mga pag-andar para sa personal na paggamit. Gayunpaman, makatuwirang ipagpalagay na kung regular mong ginagamit ang mga pag-andar, marahil ay makikita rin ng ibang mga gumagamit na kapaki-pakinabang ang mga ito.
Naturally, maaari mong makita ang iyong sarili sa isang sitwasyon kung saan hindi mo magagawa - o ayaw - ibahagi ang iyong mga function o sa kaganapan ng pagkakaroon ng access sa mga mapagkukunan ng pribadong impormasyon. Kahit na sa ganitong mga kaso, maaari mo lamang i-deploy ang mga function sa iyong sariling cloud account,
Ang mga function na isinumite mo sa Wolfram function repository ay hindi kailangang maging perpekto; kailangan lang nilang maging kapaki-pakinabang. Ito ay medyo katulad ng seksyong "Mga Error" sa klasikong dokumentasyon ng Unix - sa "Seksyon ng Mga Kahulugan" mayroong seksyong "Mga Tala ng May-akda" kung saan maaari mong ilarawan ang mga limitasyon, problema, atbp. na alam mo na tungkol sa iyong function. Bukod pa rito, kapag isinumite mo ang iyong feature sa repository, maaari kang magdagdag ng mga tala sa pagsusumite na babasahin ng isang dedikadong pangkat ng mga curator.
Kapag na-publish na ang isang feature, palaging may dalawang link ang page nito sa ibaba: "
Minsan gusto mo lang gumamit ng mga function mula sa Wolfram function repository, tulad ng mga built-in na function, nang hindi tinitingnan ang kanilang code. Gayunpaman, kung gusto mong tingnan ang loob, palaging mayroong pindutan ng Notepad sa itaas. Mag-click dito at makakakuha ka ng sarili mong kopya ng orihinal na notebook ng kahulugan na isinumite sa imbakan ng tampok. Minsan maaari mo lamang itong gamitin bilang isang halimbawa para sa iyong mga pangangailangan. Kasabay nito, maaari ka ring bumuo ng iyong sariling pagbabago ng function na ito. Maaaring gusto mong i-post ang mga function na nahanap mo mula sa repository sa iyong computer o sa iyong aphid cloud storage account, marahil gusto mong isumite ang mga ito sa base ng kaalaman ng function, marahil bilang isang pinahusay, pinalawak na bersyon ng orihinal na function.
Sa hinaharap, plano naming suportahan ang Git-style forking para sa mga feature repository, ngunit sa ngayon ay sinusubukan naming panatilihing simple ito, at palagi lang kaming may isang tinatanggap na bersyon ng bawat feature na binuo sa wika. Mas madalas kaysa sa hindi (maliban kung ang mga developer ay sumuko sa pagpapanatili ng mga tampok na kanilang binuo at tumugon sa mga pagsusumite ng user), ang orihinal na may-akda ng tampok ay kinokontrol ang mga update dito at nagsusumite ng mga bagong bersyon, na pagkatapos ay susuriin at, kung pumasa sila sa proseso ng pagsusuri , na inilathala sa wika.
Isaalang-alang natin ang tanong kung paano gumagana ang "bersyon" ng mga binuo na function. Sa ngayon, kapag gumamit ka ng function mula sa function repository, permanenteng maiimbak ang kahulugan nito sa iyong computer (o sa iyong cloud account kung ginagamit mo ang cloud). Kung ang isang bagong bersyon ng isang tampok ay magagamit, sa susunod na oras na gamitin mo ito makakatanggap ka ng isang mensahe na nag-aabiso sa iyo tungkol dito. At kung gusto mong i-update ang function sa isang bagong bersyon, magagawa mo ito gamit ang command
Isa sa mga magagandang bagay tungkol sa Wolfram Function Repository ay ang anumang programa ng Wolfram Language, kahit saan ay maaaring gumamit ng mga function mula dito. Kung ang isang programa ay lilitaw sa isang notepad, madalas na maginhawang i-format ang mga function ng repository bilang madaling basahin na mga function na "function binary object" (marahil ay may naaangkop na set ng bersyon).
Maaari mong palaging ma-access ang anumang function sa repository ng function gamit ang text
Paano ito gumagana?
Sa loob ng mga function sa Wolfram repository ito ay posible gamit ang eksaktong pareho
Isaalang-alang
Sa loob ay makikita mo ang ilang impormasyon gamit ang function
Paano gumagana ang pag-set up ng resource function? Ang pinakasimpleng isa ay isang purong lokal na kaso. Narito ang isang halimbawa na kumukuha ng isang function (sa kasong ito ay isang purong function lamang) at tinutukoy ito bilang isang resource function para sa isang naibigay na session ng programa:
Kapag nagawa mo na ang kahulugan, maaari mong gamitin ang resource function:
Tandaan na mayroong itim na icon sa blob ng function na ito . Nangangahulugan ito na ang BLOB function ay tumutukoy sa in-memory resource function na tinukoy para sa kasalukuyang session. Ang isang tampok na mapagkukunan na permanenteng naka-imbak sa iyong computer o cloud account ay may kulay abong icon . At mayroong isang orange na icon para sa isang opisyal na tampok na mapagkukunan sa Wolfram Feature Repository .
Kaya ano ang mangyayari kapag ginamit mo ang Expand menu sa Definition Notebook? Una, ito ay tumatagal ng lahat ng mga kahulugan sa notepad at mula sa kanila ay lumilikha ng isang simbolikong
Ang lokal na pag-deploy ng isang function mula sa isang repository sa iyong computer ay isinasagawa gamit ang command
Kung iki-click mo ang button na Isumite para sa isang Function Repository, ano ang mangyayari sa ilalim nito
Bilang default, ang mga pagsusumite ay ginawa sa ilalim ng pangalang nauugnay sa iyong Wolfram ID. Ngunit kung nagsusumite ka ng aplikasyon sa ngalan ng isang development team o organisasyon, magagawa mo
Pagkatapos mong maisumite ang alinman sa iyong mga function sa base ng kaalaman sa function, ito ay ipi-queue para sa pagsusuri. Kung nakatanggap ka ng mga komento bilang tugon, kadalasan ay nasa anyo ng isang text file ang mga ito na may karagdagang "comment cell" na idinagdag. Maaari mong palaging suriin ang katayuan ng iyong aplikasyon sa pamamagitan ng pagbisita
Ang ilang mga subtleties sa trabaho
Sa unang sulyap, tila maaari ka lamang kumuha ng isang notebook ng kahulugan at ilagay ito sa verbatim sa isang imbakan ng function, gayunpaman, mayroon talagang maraming mga subtleties na kasangkot - at ang paghawak sa mga ito ay nangangailangan ng paggawa ng medyo kumplikadong meta-programming, paghawak ng simbolikong pagproseso bilang ang code na tumutukoy sa function , at ang Notepad mismo ay tinukoy. Karamihan sa mga ito ay nangyayari sa loob, sa likod ng mga eksena, ngunit maaari itong magkaroon ng ilang mga implikasyon na nagkakahalaga ng pag-unawa kung mag-aambag ka sa feature na knowledge base.
Unang agarang subtlety: Kapag pinunan mo ang Definition Notebook, maaari kang sumangguni sa iyong function kahit saan gamit ang isang pangalan tulad ng MyFunction, na mukhang isang regular na pangalan para sa isang function sa Wolfram Language, ngunit para sa dokumentasyon ng repository ng function ay pinapalitan ito
Ang pangalawang subtlety: kapag gumawa ka ng resource function mula sa Definition Notebook, lahat ng dependency na kasangkot sa function definition ay dapat makuha at tahasang isama. Gayunpaman, upang matiyak na ang mga kahulugan ay mananatiling modular, kailangan mong ilagay ang lahat sa isang kakaiba
Karaniwang hindi ka makakakita ng anumang bakas ng code na ginamit upang i-configure ang namespace na ito. Ngunit kung sa ilang kadahilanan ay tumawag ka ng isang hindi naisakatuparan na simbolo sa loob ng iyong function, makikita mo na ang simbolo na ito ay nasa panloob na konteksto ng function. Gayunpaman, kapag pinoproseso ang Definition Notepad, hindi bababa sa simbolo na naaayon sa mismong function ay
Ang function repository ay para sa pagtukoy ng mga bagong function. At ang mga function na ito ay maaaring may mga pagpipilian. Kadalasan ang mga parameter na ito (halimbawa,
Ginagawa lang ng karamihan sa mga function ang dapat nilang gawin sa tuwing tatawagin sila, ngunit kailangang masimulan ang ilang function bago sila tumakbo sa isang partikular na session - at para malutas ang problemang ito, mayroong seksyong "Initialization" sa seksyong Definition.
Ang mga function mula sa isang repository ay maaaring gumamit ng iba pang mga function na nasa repository na; upang mag-set up ng mga kahulugan para sa isang function na repository na may kasamang dalawa (o higit pa) na mga function na nagre-refer sa isa't isa, dapat mong i-deploy ang mga ito sa iyong session ng programa upang maaari mong reference tulad ng sa kanila
Mga prospect ng pag-unlad. Ano ang dapat mangyari kapag ang repositoryo ay talagang malaki?
Ngayon lang namin ilulunsad ang Wolfram Feature Repository, ngunit sa paglipas ng panahon inaasahan namin na ang laki at functionality nito ay maaaring tumaas nang husto, at habang lumalaki ito sa pag-unlad magkakaroon ng iba't ibang mga problema na inaasahan na naming maaaring lumitaw.
Ang unang problema ay may kinalaman sa mga pangalan ng function at kanilang pagiging natatangi. Ang imbakan ng function ay idinisenyo sa paraang, tulad ng mga built-in na function sa Wolfram Language, maaari kang sumangguni sa anumang ibinigay na function sa pamamagitan lamang ng pagtukoy sa pangalan nito. Ngunit hindi maiiwasang nangangahulugan ito na ang mga pangalan ng function ay dapat na natatangi sa buong mundo sa buong repository, upang, halimbawa, maaari lamang magkaroon ng isa
Ito ay maaaring mukhang isang malaking problema sa simula, ngunit ito ay nagkakahalaga ng pag-unawa na ito ay karaniwang ang parehong problema tulad ng para sa mga bagay tulad ng mga domain sa internet o mga social media handle. At ang katotohanan ay kailangan lang ng system na magkaroon ng isang registrar - at ito ay isa sa mga tungkulin na gagawin ng aming kumpanya para sa Wolfram function knowledge base. (Para sa mga pribadong bersyon ng isang repository, ang kanilang mga registrar ay maaaring mga administrator.) Siyempre, ang isang Internet domain ay maaaring mairehistro nang walang anumang bagay dito, ngunit sa isang function na repository, ang isang function na pangalan ay maaari lamang irehistro kung mayroong isang aktwal na kahulugan ng ang function.
Bahagi ng aming tungkulin sa pamamahala sa Wolfram function knowledge base ay upang matiyak na ang pangalan na pinili para sa isang function ay lohikal na ibinigay sa kahulugan ng function at na ito ay sumusunod sa Wolfram Language pagpapangalan conventions. Mayroon kaming mahigit 30 taong karanasan sa pagbibigay ng pangalan sa mga built-in na function sa Wolfram Language, at dadalhin din ng aming team ng mga curator ang karanasang iyon sa function repository. Siyempre, palaging may mga pagbubukod. Halimbawa, maaaring mukhang mas mainam na magkaroon ng isang maikling pangalan para sa ilang function, ngunit mas mainam na "ipagtanggol" ang isang mas mahaba, mas tiyak na pangalan dahil mas malamang na makatagpo ka ng isang taong gustong gumawa ng katulad na pangalan ng function sa hinaharap .
(Dapat tandaan dito na ang pagdaragdag lamang ng ilang tag ng miyembro upang i-disambiguate ang mga function ay hindi magkakaroon ng nilalayong epekto. Dahil maliban kung igiit mo na ang isang tag ay palaging nakatalaga, kakailanganin mong tukuyin ang isang default na tag para sa anumang ibinigay na function, at maglaan din ng may-akda mga tag, na muling mangangailangan ng pandaigdigang koordinasyon.)
Habang lumalaki ang base ng kaalaman ng mga function ng Wolfram, isa sa mga problemang malamang na lumabas ay ang pagkatuklas ng mga function, kung saan ibinibigay ng system
Para sa mga built-in na function sa Wolfram Language mayroong tinatawag na detection layer na ibinigay ng
Ang Wolfram function repository ay naka-configure bilang isang persistent function repository, kung saan ang anumang function dito ay palaging gagana. Siyempre, maaaring maging available ang mga bagong bersyon ng mga feature, at inaasahan naming magiging lipas na ang ilang feature sa paglipas ng panahon. Ang mga function ay gagana kung sila ay ginagamit sa mga programa, ngunit ang kanilang mga pahina ng dokumentasyon ay magli-link sa bago, mas advanced na mga function.
Ang Wolfram Feature Repository ay idinisenyo upang matulungan kang mabilis na tumuklas ng mga bagong feature at matuto ng mga bagong paraan upang magamit ang wikang Wolfram. Lubos kaming umaasa na ang ilan sa mga na-explore sa feature na repository ay magiging makabuluhan sa kalaunan upang maging mga built-in na bahagi ng pangunahing Wolfram Language. Sa nakalipas na dekada, nagkaroon kami ng katulad na hanay
Ang pinakamahalagang bagay dito ay ang isang function sa isang function repository ay isang bagay na magagamit ng bawat user sa ngayon. Posible na ang isang tampok na katutubong wika ay maaaring maging mas mahusay at mas gumaganap, ngunit ang isang tampok na repositoryo ay magbibigay-daan sa mga user na magkaroon ng access sa lahat ng mga bagong tampok kaagad. At, higit sa lahat, pinapayagan ng konseptong ito ang lahat na magdagdag ng anumang mga bagong feature na gusto nila.
Mas maaga sa kasaysayan ng wikang Wolfram, ang ideyang ito ay hindi gagana nang kasinghusay nito, ngunit sa yugtong ito ay napakaraming pagsisikap na inilagay sa wika, at napakalalim na pag-unawa sa mga prinsipyo ng disenyo ng wika, na ngayon ay tila napaka posible para sa isang malaking komunidad ng mga user na magdagdag ng mga feature na magpapanatili ng pagkakapare-pareho ng disenyo upang maging kapaki-pakinabang ang mga ito sa isang malawak na hanay ng mga user.
Mayroong hindi kapani-paniwalang diwa ng talento(?) sa komunidad ng gumagamit ng Wolfram Language. (Siyempre, kasama sa komunidad na ito ang maraming nangungunang R&D na tao sa iba't ibang larangan.) Umaasa ako na ang Wolfram Feature Repository ay magbibigay ng epektibong plataporma para sa pag-unlock at pagpapalaganap ng diwa ng talento na ito. Magkasama lamang tayo makakalikha ng isang bagay na makabuluhang magpapalawak sa lugar kung saan maaaring ilapat ang paradigm sa computing ng wika ng Wolfram.
Sa mahigit 30 taon, malayo na ang narating namin sa wikang Wolfram. Ngayon sama-sama, pumunta pa tayo. Lubos kong hinihikayat ang lahat ng iginagalang na gumagamit ng wikang Wolfram sa buong mundo na gamitin ang functional repository bilang isang platform para dito, pati na rin ang bagong proyekto ng software tulad ng Libreng Wolfram Engine para sa Mga Developer.
Pinagmulan: www.habr.com