Jaký programovací jazyk je Gini vybudován?

Jsi tady:
<Zpět

Prokazatelně bezpečný. Na rozdíl od "monolithic blobs" of Bitcoin and other cryptocurrencies, Gini's systems are designed to be prokazatelně bezpečný, which means it will be possible to employ mathematical analysis of Gini's systems to provide quantifiable assurances that the software source code can perform as expected within specific statistical thresholds of security and reliability. This is possible primarily because Gini's systems and architecture are created with the Programovací jazyk Haskell, který má mnoho jedinečných technických výhod. To je důvod, proč Haskell používá NASA, Lockheed Martin, Boeing a mnoho dalších leteckých a obranných společností, které musí vytvářet bezpečné a bezpečné systémy pro letadla, satelity, raketoplán a další kritické systémy, které musí provádět na výjimečné úrovni bezpečnosti, bezpečnosti a spolehlivosti.

Gini kód s vysokou spolehlivostí. Since the core Gini components (Gini Settlement Layer and Gini Computation Layer) are produced with Haskell, which is classified as a "funkční programming language," Gini's software source code is up to 80% more time- and cost-efficient than it would be if we used other rozkazovací způsob (aka, procesní  nebo objektově orientovaný) jazyky jako C ++, C #, Java a většina ostatních jazyků. Haskell dramaticky snižuje počet chyb a bezpečnostních děr v celém životním cyklu softwarového programu. Haskell také vede k mnohem elegantnějšímu a udržitelnějšímu kódu, který vede k podstatně spolehlivějším a nákladově efektivnějším systémům. (Zde je několik dobrých technických přehledů z Microsoft a Quora Community o výhodách funkčních programovacích jazyků.)

Několik dalších technických bodů o Haskell:

Haskell is a "functional programming language," což znamená prakticky vše, na čem je založen Haskell definice funkcí. To dělá kód organizovanější a čitelnější a nutí kodér, aby přemýšlel o řešení problémů hlouběji a intuitivněji, spíše než poskytnout počítači dlouhou řadu nudných, dekontextualizovaných příkazů pro dosažení stejného chování. To také znamená, že kódování v jazyce Haskell je zaměřeno na popis jakých dat / funkcí jsou mnohem víc, než by měli dělat. To má mnoho zajímavých a významných důsledků pro každý aspekt procesu kódování.

Everything in Haskell is "immutable," což znamená: Jakmile je nastavena hodnota pro danou proměnnou, konstantu nebo funkci, je tato hodnota nastavena navždy (nebo pokud je program spuštěn). Imutability je to, co zabraňuje mnoha chybám, protože brání proměnným a které jsou změněny v nějakém místním rozsahu od vytváření neúmyslných / neočekávaných vedlejších účinků globálně v jiných funkcích, které závisí na stejné proměnné / funkci v průběhu celého programu.

In fact, Haskell technically doesn't have "variables"; it has "constants" (values) and "functions" (which are also treated as values) that never change. The only way to update a constant/function in Haskell is to define a new constant/function. However, the scope of a constant matters. For example, a constant declared at the global level can be prohlásil znovu jako jinou hodnotu v rámci jiné funkce, která zpracovává I / O operace, ale tato nová hodnota pouze existuje v rámci místního rozsahu funkce I / O. Nezmění hodnotu konstanty v globálním rozsahu ani v rámci lokální oblasti jakékoliv jiné funkce.

Zmocnitelnost činí refaktorování Haskellovým kódem velmi rychlý a účinný because there's no possibility for unexpected gotchas (i.e., side-effects and state changes) that might cause a program to crash or create unexpected security vulnerabilities. In Haskell, the value of functions, variables, and constants can't be changed during run-time after they've already been declared, which simplifies source code analysis during the refactoring process. This eliminates one of the most tedious parts of refactoring and optimizing code: function performance profiling. Thus, it's much easier to maintain, update, and continuously improve all our Haskell-based Gini systems over time.

Haskell má referenční průhlednost, což znamená, že funkce v výrazech Haskell a jejich výstupní hodnoty mohou být použity zaměnitelně bez změny chování programu. To souvisí s neměnností, referenční průhlednost se však vztahuje na skutečnost, že funkce budou mít vždy stejný výsledek vzhledem ke stejnému vstupu, což je velmi užitečná vlastnost, pokud jde o ladění, bezpečnostní audity, paralelizace, souběžnost a optimalizaci kódu. To je důvod, proč Haskell typicky funguje výjimečně dobře ve velkých objemech, s vysokou propustností, souběžné síťové aplikace. Naproti tomu funkce v imperativních jazycích často závisí na stavu dalších funkcí a proměnných, které se mohou kdykoli měnit v závislosti na stavu ostatních součástí programu. To vytváří řadu rizik a nejistot, které ztěžují zabezpečení a integritu programů psaných v nefunkčních jazycích.

In Haskell, we say "functions are first-class citizens." To znamená, že funkce mohou být předávány jako parametr / argument jiným funkcím jako každá jiná proměnná nebo hodnota. Tím se otevírá obrovské množství tvůrčích možností k psaní čistého, efektivního, spolehlivého a elegantního kódu, jehož nefunkční jazyky se nemohou replikovat.

Inteligentní analýza typů tříd a detekce chyb kompilace. Haskell je obecně považován za systém s nejinteligentnějším typem třídy libovolného programovacího jazyka. To znamená, že datové typy (např. Řetězce, celá čísla, booleany, seznamy a mnoho dalších) jsou automaticky a správně detected by Haskell's type system and intelligently inferred from how the functions interact with the values that are passed between functions. For this reason, many computer scientists say, "In Haskell, if it compiles, it's correct." This may seem like a boring, arcane concept, but it's actually one of the most significant reasons why programs built with Haskell are so reliable and secure.

In fact, typeclass errors and associated bugs frequently cause software programs to crash when they're written in other languages because the compilers and interpreters for those other languages often allow disparate data types to interact with one another, which can cause unexpected results. For example, if a function passes a string type (e.g., "four") to another function, but the receiving function is expecting an integer type (e.g., 4), the receiving function will choke because it doesn't know what "four" actually means. This type of scenario causes many programs to crash, but Haskell completely prevents these crashes by catching type errors or intelligently inferring typeclass membership for a given value before a program is even deployed to a live environment.

Rekurze se často používá. To vytváří výkonnější a efektivnější funkce s méně kódem, avšak vnořené rekurzivní funkce mohou být pro začátečníky Haskella matoucí, protože kód má tendenci být abstraktnější než kód v imperativních jazycích.

Code abstraction is a byproduct of Haskell's extremely intelligent compiler. Kompilátor Haskell intuuje mnoho akcí a kontextových faktorů, které snižují celkový kód potřebný pro vytvoření daného chování programu až o 70% (nebo dokonce více, pokud složení funkce is used). This is one of the primary reasons why the Haskell-based Web server ("Warp") can be written v méně než 1000 řádcích kódu zatímco Apache Web Server vyžaduje asi 1,5 milionu řádků kódu. A Warp je více než 100x rychlejší než Apache a je mnohem méně náchylná k mnoha chybám a bezpečnostním hackům. (Samozřejmě, že všechny měřítka závisí na tom, jak je každý systém nakonfigurován, ale obecně, Warp's per-CPU HTTP request processing is at least two orders of magnitude faster than a similarly powered server running Apache without any load-balancing and caching techniques.)

Haskell has no "for" or "while" loops or "variables" v běžném slova smyslu, ale má konstanty a velmi silné rekurze a rysy odpovídajících rysů. Ty nahrazují potřebu smyček / proměnných proměnných za přenos. Rekurze a porovnávání vzorků jsou ve skutečnosti mnohem efektivnějšími nástroji pro splnění stejných úkolů, a proto programovací jazyk Haskell nezahrnuje pro / za smyčky.

Haskell je líný. Being lazy is not always a virtue, but in this case, it means that Haskell always consumes the least amount of resources (CPU, memory, and thus, electricity) possible. Specifically, Haskell doesn't force a computer to execute more CPU cycles or consume more memory than is needed at the moment of each function's execution. For example, in Haskell we can define an infinite list of data objects at any time, but a Haskell program will not traverse the entire list because that would quickly consume all system resources and cause it to crash. Instead, a Haskell function will only traverse an infinite list until it finds the value it's looking for based on the efficient pattern-matching functions that Haskell provides. (See note 4 for a special exception to Haskell's laziness.)

Celkem: Haskell's approach to system resource management and its intelligent typeclass system alone eliminate many (50-70%) of all the bugs and security vulnerabilities that typically plague code written in other programming languages. Haskell's virtuous lazy processing prevents many stack and heap buffer overflows and corresponding system crashes caused by unintended infinite loops, which are often caused by poorly designed code in non-functional programming languages. Haskell's succinct syntax and well-organized functional design philosophy enforce good coding habits, which also eliminates many bugs.

Haskell provides many other benefits, but the benefits listed above are several of the most significant reasons why we chose to build Gini's systems with Haskell. To learn a lot more about Haskell, visit the Haskellova jazyková stránka.


Poznámky:

1. Some of Gini's early prototypes and test systems are built with Java, C++, and Python, but those are just for our R&D and proof-of-concept systems. The 1.0+ versions of all Gini systems will always be built with Haskell (for PC-based systems) and standard Web-based languages (e.g., browser-agnostic Javascript, HTML, and CSS delivered on the Haskell-based Yesod/Warp Web framework) for all Web-based Gini systems. Mobile apps for Gini are built in Haskell and cross-compiled into each mobile platform's native language (e.g., Objective-C for iOS and Java for Android).

2. Some open source software libraries that are integrated into Gini's systems (including certain well-known cryptography packages like the Blake2 hašovací funkce a Argon2 klíčová derivační funkce) jsou napsány v jazycích C, C ++ a Java a občas potřebujeme vytvářet rozhraní mezi nimi a našimi komponentami Haskell. Snažíme se však používat Haskell pro co nejvíce Gini komponent; a časem nahradíme knihovny open-source, které nejsou založeny na Haskell, s otevřenými knihovnami založenými na Haskell a / nebo našimi vlastními komponentami založenými na Haskell, kdykoli se domníváme, že by naše systémy byly bezpečnější a spolehlivější.

3. Veškerý software Gini bude vydán komunitě s otevřeným zdrojovým kódem po oficiálním spuštění Gini BlockGrid a Gini decentralizovaná burza pro širokou veřejnost.

4. Existují dvě výjimky z líné funkce v Haskell: Strict Bytestrings a Lazy Bytestrings. Strict Bytestrings představují data jako 8-bitové (1-bajtové) data nejsou líní, but they're used in special cases where large data files must be processed more efficiently than the typical lazy processing. In contrast, Lazy Bytestrings represent data as 64K-byte data chunks, the first of which is processed immediately like Strict Bytestrings, but all subsequent 64K-byte data chunks within a given file (or data stream) are processed lazily, i.e., processing is deferred until the data is actually needed for a given function.


Did You Like This Resource?


Gini is doing important work that no other organization is willing or able to do. Please support us by joining the Gini Newsletter below to be alerted about important Gini news and events and follow Gini na Twitteru.



Warning: sprintf(): Too few arguments in /home/customer/www/ginifoundation.org/public_html/wp-content/plugins/popup-maker/classes/Upsell.php on line 76