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 . Tatlong linggo lang ang nakalipas ay inilunsad namin upang matulungan ang aming mga user na isama ang Wolfram Language sa kanilang malakihang mga proyekto ng software. Ngayon ay naglulunsad kami , upang makapagbigay ng pinag-ugnay na platform para sa mga function na ginawa upang palawigin ang wikang Wolfram, at nagbukas din kami ng isang repository ng mga function para sa sinumang maaaring mag-ambag sa pagbuo ng aming produkto ng software.
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 . Sa mga tradisyunal na programming language, ang pagdaragdag ng makabuluhang bagong functionality ay karaniwang nagsasangkot ng paglikha ng buong karagdagang mga library na maaaring gumana o hindi kapag ginamit nang magkasama. Gayunpaman, sa Wikang Wolfram , na posibleng makabuluhang palawakin ang functionality nito sa pamamagitan lamang ng pagdaragdag ng mga bagong function na agad na isinama sa holistic na istruktura ng buong wika.
Halimbawa, naglalaman na ang Wolfram function repository nakabalangkas sa 26 na pampakay na kategorya:
Gayundin higit sa , na binuo sa wikang Wolfram, ang bawat function mula sa repository ay may pahina ng dokumentasyon na may detalyadong paglalarawan ng mga ito at mga halimbawa ng trabaho:
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 Hindi mo kailangan, halimbawa, na mag-set up ng "library sa pagpoproseso ng imahe" - dahil nagpatupad na kami ng pare-pareho at maingat na algorithmic na paraan sa Wolfram Language , na maaaring agad na maproseso ng iba't ibang mga graphical na pag-andar ng wika:
Sana sa suporta , na lumalaki at lumalawak (batay sa Wolfram Language) sa nakalipas na ilang dekada. Ang Wolfram function repository ay magbibigay-daan para sa nakikinita na hinaharap na makabuluhang palawakin ang hanay ng (posibleng potensyal na makabuluhan, dalubhasa sa iba't ibang larangan ng agham at teknolohiya) na mga function na magagamit sa wika. Kaya, nagiging posible na gamitin ang parehong nilalaman ng wika (mga built-in na function nito) at , na ipinapatupad batay sa wika. (Dapat tandaan dito na ang Wikang Wolfram ay mayroon nang higit sa ).
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 natatanging tampok ng diskarteng ito ay kapag nag-drill down ka sa functionality sa antas ng user, walang mga potensyal na hindi pagkakapare-pareho dahil ang diskarte ay binuo sa ibabaw ng pare-parehong istraktura ng Wolfram Language - at bawat function ay awtomatikong gagana nang tama - eksakto tulad ng sinadya. dapat.
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 . Binibigyang-daan ka ng mga built-in na awtomatikong function na suriin ang mga bagong function na idinagdag sa repository upang matiyak ang kanilang pagsasama sa wika. Ang aming kumpanya ay tumataya sa malawak na hanay ng mga user na maaaring isama ang kanilang mga function sa wika, sa halip na sa mahusay na kumplikado ng mga bagong function - at bagama't may proseso ng pagsusuri, hindi namin igiit ang anumang bagay tulad o mahigpit na pamantayan para sa pagkakumpleto at pagiging maaasahan ng mga bagong feature ng user, kumpara sa mas mahigpit na pagsubok ng mga feature na binuo sa pangunahing wika na ginagamit namin.
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 sa orihinal na database. Marami sa kanila ay batay sa code na personal kong binuo sa loob ng mahabang panahon. At inabot lang ako ng ilang minuto para itulak sila sa repository. Ngayong nasa repository na sila, maaari ko na sa wakas - kaagad at anumang oras - gamitin ang mga function na ito kung kinakailangan, nang hindi na kailangang mag-alala tungkol sa paghahanap ng mga file, pag-download ng mga pakete, atbp.
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 , nilikha para sa Mathematica noong 1991 batay sa CD-ROM, atbp.). Siyempre, ang diskarte na iminungkahi para sa pagpapatupad batay sa Wolfram function repository ay isang mas malakas at maaasahang tool para sa pagpapatupad ng mga gawain sa itaas.
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 . At sa gayon, ang esensya ng diskarte sa pagpapatupad ng Wolfram function repository ay ang paggamit ng isang pinag-isang diskarte sa pagprograma at pagbuo ng mga bagong function na sunud-sunod na idinagdag at umaangkop sa balangkas ng wika upang ito ay umunlad at magkakasamang umunlad.
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 na kinabibilangan ng ). Ang pinakahuling ginagawa ng diskarteng ito na ang Wolfram feature repository ay maaaring gumanap nang maayos ay ang istrukturang katangian ng Wolfram Language, kasama ang malaking bilang ng mga karagdagang at iba't ibang mga aklatan na binuo na sa wika. Halimbawa, kung mayroon kang function na nagpoproseso ng mga larawan, o O At o ilang iba pa - ang kanilang pare-parehong simbolikong representasyon ay umiiral na sa wika, at salamat dito, ang iyong function ay agad na naging tugma sa iba pang mga function sa wika.
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: , inilunsad noong 2007 at ngayon ay tumatakbo online online na may higit sa 12000 user-interactive na mga demo. SA mayroong higit sa 600 handa na mga database na maaaring gamitin sa Wolfram Language, at ay pinupunan ng mga bagong neural network halos bawat linggo (mayroon nang 118 sa kanila ngayon) at agad silang konektado sa pamamagitan ng function sa Wikang Wolfram.
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 ), Maaari ka lamang dumaan sa mga tab ng pangunahing menu nang sunud-sunod: File > New > RepositoryItem > Function Repository Item at makakakuha ka ng "" (programmatically sa loob ng workbench. Maaari mo ring gamitin ang analogue function - ):
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 , na nagpapaliwanag kung ano ang gagawin, at isang button na Tools, na nagbibigay ng mga tool para sa pag-format ng dokumentasyon ng iyong function.
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 , para maging available ito sa iyo kapag nakakonekta ka sa cloud. Maaari mo ring pampublikong i-host (i-deploy) ang feature sa pamamagitan ng iyong cloud account. Wala ito sa central Wolfram feature repository, ngunit makakapagbigay ka sa isang tao ng URL na magbibigay-daan sa kanila na makuha ang iyong feature mula sa iyong account. (Sa hinaharap, susuportahan din namin ang mga central repository sa buong kumpanya namin.)
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 at iba pa)
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 maaaring makatanggap ng mga file sa isang partikular na format at lumikha ng mail sa isang partikular na paraan. lumilikha ng mga chart na may ilang partikular na kulay at label lang, atbp.
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. , hangga't nakikita mong angkop. Bilang karagdagan, patuloy na sinusubukan ng system na gawing proseso ng pag-verify ang mga halimbawa ng dokumentasyong ibinibigay mo (at kung minsan ay maaari itong maging masinsinang mapagkukunan, halimbawa, para sa isang function na ang resulta ay nakasalalay sa mga random na numero o oras ng araw).
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 , na madaling mauunawaan ng mga user kung nakita nila ito sa isang piraso ng code, maaari na itong maidagdag. Kung hindi, malamang na mas mainam na idagdag na lamang ang code sa iyong programa sa tuwing kailangan mong gamitin ito.
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 , gamitin . Ngunit paano kung gusto mong magpakilala ng mga bagong uri ng mga bagay para sa iyong mga kalkulasyon?
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 . Sa ilang mga paghihigpit (lalo na para sa mga function na ), ang isang function repository ay nagpapahintulot sa iyo na kumatawan lamang ng isang function at tukuyin ang mga halaga para dito. (Upang itaas ang inaasahan ng pagkakapare-pareho kapag lumilikha ng isang bagong pangunahing disenyo na ganap na isinama sa buong Wolfram Language ay karaniwang isang napakahalagang pamamaraan na hindi maaaring makamit sa pamamagitan lamang ng pagtaas ng gastos ng proyekto at isang bagay na ginagawa ng aming kumpanya bilang bahagi ng mga proyekto para sa pangmatagalang pag-unlad ng wika, ang gawaing ito ay hindi isang layunin na itinakda bilang bahagi ng pagbuo ng repositoryo).
Kaya, ano ang maaaring nasa function code sa isang function repository? , siyempre (kahit na kung hindi ito kumakatawan para sa at ang pagganap ng mismong programa, bilang isang computing environment) pati na rin ang anumang function mula sa function repository. Gayunpaman, mayroong iba pang mga pag-andar: ang isang function sa isang imbakan ng function ay maaaring tumawag sa isang API, o sa O . Siyempre, may ilang mga panganib na nauugnay dito. Dahil sa ang katunayan na walang mga garantiya na ang API ay hindi magbabago, at ang pag-andar sa tindahan ng pag-andar ay hihinto sa paggana. Upang makatulong na matukoy ang mga isyu tulad nito, mayroong isang tala sa pahina ng dokumentasyon (sa seksyong Mga Kinakailangan) para sa anumang tampok na umaasa sa higit pa sa built-in na Wolfram Language functionality. (Siyempre, pagdating sa totoong data, maaaring magkaroon ng mga problema kahit na sa pagpapaandar na ito - dahil ang totoong data sa mundo ay patuloy na nagbabago, at kung minsan kahit ang mga kahulugan at istraktura nito ay nagbabago.)
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 o sa Wolfram language code.)
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 partikular na computer system, at cloud storage ay maaaring magdulot ng karagdagang mga isyu sa seguridad).
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, access sa kanila. (Kung ang iyong organisasyon ay may , pagkatapos ay malapit na itong makapag-host ng sarili nitong imbakan ng pribadong tampok, na maaaring pangasiwaan mula sa loob ng iyong organisasyon at itakda kung pipilitin o hindi na tingnan ang mga view ng mga user ng third-party.)
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: ""At"" Kung nag-a-attach ka ng tala (hal., sabihin sa akin ang tungkol sa mga bug), maaari mong lagyan ng check ang kahon na nagsasabing gusto mong ibahagi ang iyong mensahe at impormasyon sa pakikipag-ugnayan sa may-akda ng tampok.
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 . (Ang "function blob" ay talagang nag-iimbak ng higit pang impormasyon sa pag-bersyon, at plano naming gawin itong mas naa-access sa aming mga user sa hinaharap.)
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 . At ito ay napaka-maginhawa kung sumulat ka ng code o mga script nang direkta para sa Wolfram Engine, halimbawa, gamit ang (lalo na dapat tandaan na ang imbakan ng function ay ganap na katugma sa ).
Paano ito gumagana?
Sa loob ng mga function sa Wolfram repository ito ay posible gamit ang eksaktong pareho mga base, tulad ng sa (imbak ng data, , atbp.), tulad ng lahat ng iba pang mapagkukunan ng Wolfram system, sa huli batay sa pag-andar .
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 ). (At kung gumagamit ka ng text-based na IDE o program, maaari ka ring tahasang lumikha )
Ang lokal na pag-deploy ng isang function mula sa isang repository sa iyong computer ay isinasagawa gamit ang command para sa isang mapagkukunang bagay upang i-save ito bilang sa iyong file system. Ang deployment sa isang cloud account ay ginagawa gamit ang command para sa isang resource object, at isang pampublikong cloud deployment ay . Sa lahat ng pagkakataon ginamit din para irehistro ang pangalan ng resource function, kaya magtatrabaho.
Kung iki-click mo ang button na Isumite para sa isang Function Repository, ano ang mangyayari sa ilalim nito tinatawag sa isang bagay na mapagkukunan. (At kung gumagamit ka ng text input interface, maaari ka ring tumawag direkta.)
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 at sa halip ay gamitin ito bilang pangalan upang makipag-ugnayan sa iyong mga view.
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 . Ngunit kapag naaprubahan na ang iyong feature, aabisuhan ka (sa pamamagitan ng email) at ipo-post ang iyong feature sa Wolfram feature repository.
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 ay kung ano talaga ang gagamitin ng mga user kapag nagtatrabaho sa function.
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 . (Syempre, , ay nasa imbakan ng function.)
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 bilang isang functional na BLOB sa halip na isang raw na karakter sa panloob na konteksto.
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, o ) ay magagamit para sa mga built-in na function, gayundin para sa mga kung saan mayroon nang mga built-in na simbolo. Ngunit kung minsan ang isang bagong tampok ay maaaring mangailangan ng mga bagong opsyon. Upang mapanatili ang modularity, ang mga parameter na ito ay kailangang mga simbolo na tinukoy sa isang natatanging panloob na konteksto (o isang bagay tulad ng buong resource function, iyon ay, ang kanilang mga sarili). Para sa pagiging simple, pinapayagan ka ng imbakan ng function na tukuyin ang mga bagong opsyon sa mga kahulugan ng string. At para sa kaginhawahan ng gumagamit, ang mga kahulugang ito (ipagpalagay na ginamit nila ΠΈ ) ay pinoproseso din upang kapag gumagamit ng mga function, ang mga parameter ay maaaring tukuyin hindi lamang bilang mga string, kundi pati na rin bilang mga pandaigdigang simbolo na may parehong mga pangalan.
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 , pagkatapos ay maaari kang lumikha ng mga kumbinasyon ng mga function na ito na kailangan mo, mga halimbawa (hindi ko naintindihan) at magdagdag ng isang bagong function sa repository batay sa mga nai-post na mas maaga. (o dati o dati - ang parehong salita ay malamya)
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 (at ang mga file ng kahulugan ay maaaring may kasamang mga keyword, atbp.). Para sa mga built-in na function sa Wolfram Language, mayroong lahat ng uri ng cross-reference sa dokumentasyon upang makatulong na "i-advertise" ang mga function. Ang mga function sa isang function repository ay maaaring sumangguni sa mga built-in na function. Ngunit paano ang kabaligtaran? Para magawa ito, mag-eeksperimento tayo sa iba't ibang disenyo para ilantad ang mga function ng repository sa mga pahina ng dokumentasyon para sa mga built-in na function.
Para sa mga built-in na function sa Wolfram Language mayroong tinatawag na detection layer na ibinigay ng , na nagbibigay ng mga organisadong listahan ng mga feature na nauugnay sa mga partikular na lugar. Palaging mahirap na maayos na balansehin ang mga man page, at habang lumalaki ang wikang Wolfram, madalas na kailangang ganap na muling ayusin ang mga man page. Napakadaling ilagay ang mga function mula sa isang repositoryo sa malawak na kategorya, at kahit na patuloy na hatiin ang mga kategoryang iyon, ngunit mas mahalaga ang maayos na pagkakaayos ng mga pahina ng sangguniang wika. Hindi pa malinaw kung paano pinakamahusay na gawin ang mga ito para sa buong base ng kaalaman sa function. Halimbawa, sa imbakan ng tampok, sinuman ay maaaring mag-post ng isang web page na naglalaman ng kanilang "mga pinili" mula sa imbakan:
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 . At isa sa mga aral na natutunan mula sa karanasang ito ay ang pagkamit ng mga pamantayan ng kalidad at pagkakapare-pareho na pinagtutuunan natin ng pansin sa lahat ng bagay na binuo sa wikang Wolfram ay nangangailangan ng maraming trabaho, na kadalasang mas mahirap kaysa sa unang pagsisikap sa pagpapatupad ng ideya. Gayunpaman, ang isang function sa base ng kaalaman sa function ay maaaring magsilbi bilang isang napaka-kapaki-pakinabang na patunay ng konsepto para sa isang function sa hinaharap na maaaring mabuo sa wakas sa wikang Wolfram.
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