Legjobb válasz
A Swift 1, 2, 3 esetében határozottan „Nem”. . Egyébként továbbra sem vagyok túl pozitív.
Feltételezem, hogy a Rust célpiaca C / C ++ programozók.
A Rust legfontosabb jellemzője: rendkívüli biztonság rezsi nélkül . Eddig Swift itt bukik. A ref-típusok használata esetén a Swift mindig tartalmaz egyfajta rezsit mind térben, mind időben. Ez kötelező és elkerülhetetlen.
A rezsi azért fontos, mert csak a „biztonságot” sok nyelv biztosítja. Például C #. A véleményem szerint a Swift tényleges igazi versenytársa. A C # már biztosít bizonyos szintű biztonságot. És a piac bizonyos szegmenseiben már sikeresen felváltotta a C / C ++ -ot, de nem teljesen, mert rengeteg rezsit jelent. Térben és időben egyaránt. Bár a Swift fordító képes elkerülni az RC többletét, de ez az optimalizálástól függő szerencsén múlik. Néhány szerencsétlen helyzetben a rezsi óriási lesz.
És a biztonság szintje is más. Ugyanaz, hogy mindkét nyelv nem garantálhatja, hogy biztonságos kontextusban lógjon a mutató. De a Swift csak ennyit tud nyújtani, és ez nagyon gyenge garancia ahhoz képest, amit a Rust nyújt. Erőforrás szinten a Swift ref-típusok bármikor szivároghatnak, és mindig emberi ellátásra szorulnak. A fordító nem ismeri fel a ciklikus hivatkozásokat. A Swift emellett lehetővé teszi a változtatható memória korlátlan megosztását a szálak között (a nyelv natív egyidejűségének hiánya miatt), ami nem jelent biztonságot az adatfutamban.
Ezzel szemben a Rust egyedi tulajdonjoga teljes statikus garanciát jelent az erőforrások szivárgásának elkerülésére. Semmi adatverseny nem garantál statikusan.
Amit a Swift használata során éreztem az elmúlt években, az a nyelv, amely nem igazán biztonságos az erőforrás-kezelés és az adatverseny terén. A kötelező RC rezsi pedig valóban komoly gondot jelent a teljesítménykritikus kódban. A Swift az értéktípusok teljesítményét hirdeti, de valójában mindig használnia kell benne néhány ref-típust a halom biztonságos elosztásához. A Swift hirdeti a fordító intelligens RC választékát, de ez a szerencsén alapul, így összehasonlíthatatlanul garantáltan nulla Rust költség.
Miért számít a biztonság? Mert nem lehet eredményes egy aknamezőn. Ahhoz, hogy produktív legyél, csökkentened kell a törődőket. A Swiftben mindig gondot kell fordítanod a ciklusokra, az adatversenyre és a rezsire, csak azért, hogy ne ölj meg, mert senki nem törődik veled. A Rust-ban a fordító gondoskodhat erről és gondoskodik róla. Csak elfelejtette (sok) a biztonságot, és kövesse a fordítót, bármi is panaszkodjon rá, akkor biztonságban van. Csakúgy, mint a GC nyelvhasználók nem törődnek a lógó mutatókkal.
A determinizmus is számít. Az objektum élettartamának követésére ritkán van szükség, de néha nagyon fontos. A Swift RC “deinit” időzítést biztosít, de mivel megosztott tulajdonban van, a halál időzítése általában nagyon homályos. Az egyedi tulajdonjogok ilyen időzítése viszonylag egyértelműbb, mint az RC.
Az egyedi tulajdonjog a fenntartót is segíti a felelős tulajdonos megjegyzésével. Véleményem szerint az egyedi tulajdonosok kezelése sokkal könnyebb, mint a több tulajdonos kezelése. Valójában az, amit mindig a Swift-ben csinálok, csak az implicit egyedi tulajdonos megadása és a kézi követés valamilyen egyezmény alapján. Nem lenne jó, ha a fordító ezt megtenné helyetted?
A Swift 4 számos új funkció bevezetését tervezi, mint például az egyedi tulajdonjog, a szemantika mozgatása, a színész modell és a C ++ inter-op támogatás. De nem vagyok biztos benne, hogyan tudják garantálni a Rust biztonságosságát a jelenlegi nyelvi szemantika jellemzőivel. Tehát továbbra sem vagyok túl pozitív a Swift biztonsági szintjét illetően. A C ++ inter-op nagy értékesítési pont lehet. Egyébként szinte ez az egyetlen oka annak, hogy szerintem a Swift 4 potenciális versenytársa lehet a Rust for C / C ++ piacnak.
A Swiftnek is vannak profi. Ilyen például a saner (véleményem szerint) elnevezési szokás és világos szintaxis (véleményem szerint), az elkötelezett IDE, a világ leggazdagabb támogatójának garantált fejlődése és fenntarthatósága (de ez a támogatott platform politikai kérdését is bevezeti). Összességében jobb az UI / UX, de még mindig jobban vonzódik Rust biztonsága és fogalmi szépsége …
P.S. Valójában csak a Swift 2.x korai verziójában lehetett lógó mutatót készíteni, csak olyan biztonságos konstrukcióval, mint a “deinit” és a gyenge ref. De nem vagyok biztos ebben és a jövőben.
P.S. 2. Úgy tűnik, hogy befoltozták a kiskaput. A Swift 3-ban futásidejű kivételt kap, ha megpróbál gyenge referenciát adni a `deinit-ben.
Válasz
Nemrégiben olvastam a swift-3.x-ről, de Jó ideje Rust rajongó vagyok, és nagyon szeretném, ha Rust rendszernek sikert aratna.
A kérdésedre adott válasz feltételes igen lesz, miért? Ennek oka, hogy a gyors átfedésben van egy jelentős hely a rozsdával a natív alkalmazás programozása szempontjából.A nyelvek között éles ellentét van a tervezési filozófia és a rendszerek programozásában használt esetek (és néhány valós idejű felhasználási eset) tekintetében.
A Rust a C ++ filozófiákra tervezték, többnyire nagyon nagy teljesítményű számítástechnikát és őrülten optimalizálható fordítóprogramokat lehet készíteni (amellyel még nem láttam sok modern nyelvet versenyezni)
- „Nulla költség-absztrakciók”
- Ez Különösen akkor fontos, amikor kerneleket vagy alapvető segédprogramokat írsz, mert a lehető legnagyobb mértékben optimalizálni kell őket, hogy kijusson az utolsó teljesítmény.
- Gyorsan talán elvégezheted a legtöbb optimalizálást, de nem mindet, ott nyelvi akadálya az elérhető optimalizálás mértékének (például feltételezem, nyugodtan feltételezhetnénk, hogy a legtöbb referenciaszámolás gyors, de rozsdásodás esetén választhat az Rc és Arc típusok közül, ezért ne fizessen amit nem használ).
- „The Rust pointer model”
- Rust program Ezeket úgy tervezték, hogy tulajdonjog, kölcsönzés és szemantika mozgatásával kiküszöböljék a legtöbb összeomlás forrását a kódból, így statikusan ellenőrzi, hogy bármely erőforrásnak csak egy egyedi tulajdonosa van-e egy adott időpontban. Ez megkönnyíti a dolgokat az alábbiakban felsorolt két eset esetében is.
- Hogyan különítsük el a program összeomlásra képes részeit (nem biztonságosak)?
- Hogyan lehet biztonságos párhuzamosságot írni a kód írásakor
- A Swift ebben a tekintetben sokkal inkább hasonlít a C ++ -ra, mivel csak az erős (megosztott\_ptr), gyenge (gyenge\_ptr) és nem birtokolt mutatókat (behatoló\_ptr) tárja a programozó elé, és megadja nekik az irányítást, hogy (ab) használja őket kódjuk, tehát mindenképpen jobb vezérlés, mint a Java, de minden bizonnyal kisebb a biztonság.
- „Felsorolások”
- A rozsda gazdag listákkal rendelkezik, amelyek hasonlóak a Haskell-i ADT-khez (bár nem olyan erősek), de ennek ellenére engedélyezze a Finite State Machines (FSM) gyönyörű tervezését, ha belegondol a C-be, amely nagyon gyengén támogatja az FSM írását.
- A Swift a Java-hoz hasonló gyönyörű felsorolásokat is tartalmaz, amelyek szerintem sokkal erősebbek, mivel definiálhatjuk viselkedés enums számára.
- „Bezárások” – Ez az egyetlen jellemző, amely megkülönbözteti a modern nyelveket az archaikus nyelvektől. A Rust és a Swift egyaránt támogatja a lezárásokat, de a rozsdamodell lehetővé teszi, hogy a „zárt” változók tulajdonjogával foglalkozzon, és ezáltal biztosítja a biztonságot. Másrészt a Swift bezárások néhány meglepetést okozhatnak még tapasztalt programozóknak is.
- A Rust problémái
- Nagyon egyszerű adatstruktúrák, mint például a Duplán összekapcsolt listák, nem létezhetnek rozsdában, csak azért, mert a tulajdonosi szemantika (kénytelenek vagyunk használni az Rc / Arc alkalmazást ehhez az egyszerű adatstruktúrához) ez idegesít néhány embert.
- A programozási tapasztalatok szerint, ha van egy jellemző egy népszerű nyelven, az emberek hajlamosak lesznek bántalmazzák őket, a Rustban a nem biztonságos blokkok mindenképpen visszaélésekre hajlamosak azok számára, akik nem hajlandók harcolni a kölcsönellenőr ellen, ami sajnos nagy százalékot jelent.
- A standard könyvtár megváltoztathatatlansága, ha nem triviális kódot kell Rust-ban írni, rendelkeznünk kell olyan adattípusokkal, mint a Cell / RefCell, technikailag használható hátsó ajtóként a nyelv által biztosított erős biztonsággal szemben. Azt mondva, hogy a könyvtár nagyon sok biztonsági primitívet nyújt ezen adattípusok használata közben, így nem lőhetjük magunkat.
- Végül úgy tűnik, hogy Rust elismeri, hogy bár a C ++ -nál biztonságosabb, a gyűlölt C ++ funkciókat is be kell építeni annak érdekében, hogy lehetővé tegyük az örökbefogadást, és lehetővé tegyük az emberek számára, hogy nem triviális kódot írjanak. Ez szomorú, de sajnos az igazság is.
- A Swift problémái
- Az ARC mindenütt elterjedt használata – ami sérti, hogy „nem fizet azért, amit nem use ”filozófia a C ++ – ban (a gyors 5.x-szel foglalkozhat (lásd: [gyors-evolúció] RFC: Megőrzési ciklusok megelőzése (memória-tulajdonosi modell) )
- A nagyon könnyen használható aszinkron primitívek hiánya, az élő aszinkron / várakozás / koroutinok (ami az olyan nyelvek eladási pontja, mint a go), gyors lehet az 5.x.
- Néha „osztály ”Deklarációk feleslegesen rákényszeríthetnek referenciatípusok használatára, ahol valójában előnyösebb lehet egy értéktípus (struct).
- A Rust tulajdonságai technikailag (a legtöbb esetben) jobb megoldás 3 különböző gyors entitásra (kiterjesztések, protokollok) és öröklés)
Tehát úgy gondolom, hogy mindenképpen van egy rés a gyors elfoglaltságra, azok az emberek, akik jó C ++ programozók, gyorsan eljuthatnak a Swift / Rust felé. De azt hiszem, hogy a Swift nagyobb tapadást kap val vel alkalmazásfejlesztők és Rust a System programozókkal. A saját fülkeik továbbra is fennállnak a jelentős átfedések ellenére.