What Programming Language is Gini Built With?

ਪ੍ਰੋਵੋਲਿ ਸੈਕਿਓਰ. ਦੇ ਉਲਟ "monolithic blobs" of Bitcoin and other cryptocurrencies, Gini's systems are designed to be provably ਸੁਰੱਖਿਅਤ, 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 ਹਾਸਕੈਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ, ਜਿਸ ਵਿੱਚ ਕਈ ਵਿਲੱਖਣ ਤਕਨੀਕੀ ਲਾਭ ਹਨ ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਹੈਸਕੇਲ ਨਾਸਾ, ਲੌਕਹੀਡ ਮਾਰਟਿਨ, ਬੋਇੰਗ ਅਤੇ ਹੋਰ ਬਹੁਤ ਸਾਰੇ ਏਰੋਸਪੇਸ ਅਤੇ ਰੱਖਿਆ ਕੰਪਨੀਆਂ ਦੁਆਰਾ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਜੋ ਏਅਰਪਲੇਨਸ, ਸੈਟੇਲਾਈਟਸ, ਸਪੇਸ ਸ਼ਟਲਜ਼ ਅਤੇ ਹੋਰ ਮਿਸ਼ਨ-ਨਾਜ਼ੁਕ ਪ੍ਰਣਾਲੀਆਂ ਲਈ ਸੁਰੱਖਿਅਤ ਅਤੇ ਸੁਰੱਖਿਅਤ ਪ੍ਰਣਾਲੀ ਬਣਾਉਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ ਜੋ ਕਿ ਇੱਕ ਖਾਸ ਪੱਧਰ ਸੁਰੱਖਿਆ, ਸੁਰੱਖਿਆ ਅਤੇ ਭਰੋਸੇਯੋਗਤਾ.

ਉੱਚ-ਭਰੋਸੇਯੋਗਤਾ ਗੀਨੀ ਕੋਡ Since the core Gini components (Gini Settlement Layer and Gini Computation Layer) are produced with Haskell, which is classified as a "ਕਾਰਜਸ਼ੀਲ programming language," Gini's software source code is up to 80% more time- and cost-efficient than it would be if we used other ਜ਼ਰੂਰੀ (ਉਰਫ, ਪ੍ਰਕ੍ਰਿਆ ਸੰਬੰਧੀ  ਜਾਂ ਆਬਜੈਕਟ-ਮੁਖੀ) ਭਾਸ਼ਾਵਾਂ ਜਿਵੇਂ ਕਿ C ++, C #, ਜਾਵਾ ਅਤੇ ਹੋਰ ਬਹੁਤ ਸਾਰੀਆਂ ਭਾਸ਼ਾਵਾਂ. ਹਾਸਕੈਲ ਨੇ ਸਾੱਫਟਵੇਅਰ ਪਰੋਗਰਾਮ ਦੇ ਲਾਈਫ ਚੱਕਰ ਦੌਰਾਨ ਬੱਗਾਂ ਅਤੇ ਸੁਰੱਖਿਆ ਘੇਰਾਂ ਦੀ ਗਿਣਤੀ ਘਟਾ ਕੇ ਘਟਾ ਦਿੱਤੀ ਹੈ. ਹਾਸਕੈਲ ਦਾ ਨਤੀਜਾ ਬਹੁਤ ਸ਼ਾਨਦਾਰ ਅਤੇ ਸੰਪੂਰਨ ਕੋਡ ਹੁੰਦਾ ਹੈ, ਜਿਸਦੇ ਨਤੀਜੇ ਵਜੋਂ ਕਾਫ਼ੀ ਭਰੋਸੇਮੰਦ ਅਤੇ ਲਾਗਤ-ਪ੍ਰਭਾਵੀ ਸਿਸਟਮ ਹੁੰਦੇ ਹਨ. (ਇੱਥੇ ਕੁਝ ਚੰਗੇ ਤਕਨੀਕੀ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਹੈ Microsoft ਅਤੇ ਕੋਓਰਾ ਕਮਿਊਨਿਟੀ ਫੰਕਸ਼ਨਲ ਪਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਦੇ ਫਾਇਦਿਆਂ ਬਾਰੇ.)

ਹਾਸਕੈਲ ਬਾਰੇ ਕੁਝ ਹੋਰ ਤਕਨੀਕੀ ਬੁਲੇਟ ਪੁਆਇੰਟ:

Haskell is a "functional programming language," ਜਿਸਦਾ ਅਰਥ ਹੈ ਹੈਸੇਲ ਵਿਚ ਲੱਗਭਗ ਹਰ ਚੀਜ਼ 'ਤੇ ਅਧਾਰਤ ਹੈ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਾ. ਇਹ ਕੋਡ ਨੂੰ ਵਧੇਰੇ ਸੰਗਠਿਤ ਅਤੇ ਪੜ੍ਹਨ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਇਕੋ ਜਿਹੇ ਵਿਹਾਰ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਕੰਪਿਊਟਰ ਨੂੰ ਘੁਟਾਲਿਆਂ ਦੀ ਇੱਕ ਲੰਮੀ ਲੜੀ, ਡਾਂਟੇਨੇਸਟੇਲਾਈਟਡ ਕਮਾਂਡਜ਼ ਦੇਣ ਦੀ ਬਜਾਏ, ਇੱਕ ਡੂੰਘੀ ਅਤੇ ਵਧੇਰੇ ਅਨੁਭਵੀ ਢੰਗ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਬਾਰੇ ਕੋਡਰ ਨੂੰ ਸੋਚਣ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ. ਇਸਦਾ ਇਹ ਵੀ ਮਤਲਬ ਹੈ ਕਿ ਹੈਸੇਲ ਵਿੱਚ ਕੋਡਿੰਗ, ਜੋ ਕਿ ਡਾਟਾ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਵਰਨਣ ਕਰਨ ਤੇ ਕੇਂਦਰਤ ਹੈ ਹਨ ਉਨ੍ਹਾਂ ਨੂੰ ਜੋ ਚਾਹੀਦਾ ਹੈ ਉਸ ਨਾਲੋਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਕਰੋ. ਇਹ ਕੋਡਿੰਗ ਪ੍ਰਕਿਰਿਆ ਦੇ ਹਰੇਕ ਪਹਿਲੂ ਲਈ ਬਹੁਤ ਸਾਰੇ ਦਿਲਚਸਪ ਅਤੇ ਮਹੱਤਵਪੂਰਨ ਪ੍ਰਭਾਵ ਹਨ.

Everything in Haskell is "immutable," ਜਿਸਦਾ ਮਤਲਬ ਹੈ: ਇੱਕ ਵਾਰ ਜਦੋਂ ਕਿਸੇ ਵੈਲਯੂ ਨੂੰ ਦਿੱਤੇ ਗਏ ਵੇਰੀਏਬਲ, ਸਥਿਰ ਜਾਂ ਫੰਕਸ਼ਨ ਲਈ ਸੈਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਵੈਲਯੂ ਸੈਟ ਹੋ ਜਾਂਦੀ ਹੈ ਹਮੇਸ਼ਾ ਲਈ (ਜਾਂ ਜਦੋਂ ਤੱਕ ਪ੍ਰੋਗਰਾਮ ਚੱਲ ਰਿਹਾ ਹੈ). Immutability ਉਹ ਹੈ ਜੋ ਬਹੁਤ ਸਾਰੀਆਂ ਬੱਗਾਂ ਨੂੰ ਰੋਕਦੀ ਹੈ ਕਿਉਂਕਿ ਇਹ ਵੇਰੀਬਲਸ ਨੂੰ ਰੋਕਦੀ ਹੈ ਅਤੇ ਫੰਕਸ਼ਨ ਜੋ ਕੁਝ ਸਥਾਨਕ ਸਕੋਪ ਵਿੱਚ ਦੂਜੇ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਇੱਕ ਹੀ ਵੈਰੀਐਬਲ / ਫੰਕਸ਼ਨ ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਹੋਰ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਵਿਸ਼ਵ ਪੱਧਰ ਤੇ ਅਣਇੱਛਤ / ਅਚਾਨਕ ਸਾਈਡ-ਇਫੈਕਟ ਬਣਾਉਣ ਤੋਂ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ.

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 ਦੁਬਾਰਾ ਐਲਾਨ ਇੱਕ ਹੋਰ ਫੰਕਸ਼ਨ ਵਿੱਚ ਇੱਕ ਵੱਖਰੇ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਜੋ ਕਿ I / O ਓਪਰੇਸ਼ਨ ਕਰਦਾ ਹੈ, ਪਰ ਇਹ ਨਵਾਂ ਮੁੱਲ ਸਿਰਫ ਅੰਦਰ ਮੌਜੂਦ ਹੈ ਸਥਾਨਕ ਸਕੋਪ ਉਸ I / O ਫੰਕਸ਼ਨ ਦੇ. ਇਹ ਲਗਾਤਾਰ ਗਲੋਬਲ ਸਕੋਪ ਤੇ ਜਾਂ ਕਿਸੇ ਹੋਰ ਫੰਕਸ਼ਨ ਦੀ ਸਥਾਨਕ ਗੁੰਜਾਇਸ਼ ਦੇ ਅੰਦਰ ਮੁੱਲ ਨੂੰ ਨਹੀਂ ਬਦਲਦਾ.

Immacability ਰਿਐਕਟਰਿੰਗ ਕਰਦੀ ਹੈ Haskell ਕੋਡ ਅਸਲ ਵਿੱਚ ਤੇਜ਼ ਅਤੇ ਕੁਸ਼ਲ 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.

ਹਾਾਸੇਲ ਵਿੱਚ ਤਰਕਪੂਰਨ ਪਾਰਦਰਸ਼ਤਾ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਹਾਾਸੇਲ ਸਮੀਕਰਨ ਵਿੱਚ ਫੰਕਸ਼ਨ ਅਤੇ ਉਹਨਾਂ ਦੇ ਆਊਟਪੁਟ ਵੈਲਯੂ ਇੱਕਤਰ ਰੂਪ ਵਿੱਚ ਪ੍ਰੋਗ੍ਰਾਮ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਬਦਲਣ ਤੋਂ ਬਿਨਾਂ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ ਇਹ ਨਿਰਬਲਤਾ ਨਾਲ ਸਬੰਧਤ ਹੈ, ਪਰ ਤਰਕਪੂਰਨ ਪਾਰਦਰਸ਼ਿਤਾ ਇਸ ਤੱਥ ਦਾ ਹਵਾਲਾ ਦਿੰਦੀ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਇੱਕੋ ਇਨਪੁਟ ਦੇ ਨਤੀਜੇ ਇੱਕੋ ਹੀ ਨਤੀਜੇ ਦੇਣਗੇ, ਜੋ ਡੀਬੱਗਿੰਗ, ਸੁਰੱਖਿਆ ਆਡਿਟ, ਪੈਰਲਲਿਲਾਈਜਿੰਗ, ਇਕਸਾਰਤਾ ਅਤੇ ਕੋਡ ਆਪਟੀਮਾਈਜੇਸ਼ਨ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਬਹੁਤ ਉਪਯੋਗੀ ਸੰਪਤੀ ਹੈ. ਇਸ ਲਈ ਹਾਸਕੈਲ ਆਮ ਤੌਰ ਤੇ ਉੱਚ-ਵੋਲਯੂਮ, ਉੱਚ-ਥ੍ਰੂਪੁਟ, ਸਮਕਾਲੀਨ ਨੈਟਵਰਕ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਬਹੁਤ ਵਧੀਆ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ. ਇਸ ਦੇ ਉਲਟ, ਆਧੁਨਿਕ ਭਾਸ਼ਾ ਦੇ ਫੰਕਸ਼ਨ ਅਕਸਰ ਦੂਜੇ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਵੇਰੀਏਬਲ ਦੀ ਸਥਿਤੀ ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ, ਜੋ ਕਿਸੇ ਵੀ ਸਮੇਂ ਕਿਸੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਦੂਜੇ ਭਾਗਾਂ ਦੇ ਰਾਜ ਦੇ ਆਧਾਰ ਤੇ ਬਦਲ ਸਕਦੇ ਹਨ. ਇਸ ਨਾਲ ਬਹੁਤ ਸਾਰੇ ਜੋਖਮਾਂ ਅਤੇ ਅਨਿਸ਼ਚਿਤਤਾਵਾਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਗੈਰ-ਕਾਰਜਸ਼ੀਲ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਲਿਖੀਆਂ ਪ੍ਰੋਗਰਾਮਾਂ ਦੀ ਸੁਰੱਖਿਆ ਅਤੇ ਅਖੰਡਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਵਿੱਚ ਬਹੁਤ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦੀਆਂ ਹਨ.

In Haskell, we say "functions are first-class citizens." ਇਸਦਾ ਅਰਥ ਇਹ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਦੂਜੇ ਫੰਕਸ਼ਨਾਂ ਦੇ ਪੈਰਾਮੀਟਰ / ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਪਾਸ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ ਜਿਵੇਂ ਕਿ ਕੋਈ ਹੋਰ ਵੈਰੀਏਬਲ ਜਾਂ ਵੈਲਯੂ. ਇਸ ਨਾਲ ਸਾਫ਼, ਕੁਸ਼ਲ, ਭਰੋਸੇਮੰਦ ਅਤੇ ਸ਼ਾਨਦਾਰ ਕੋਡ ਲਿਖਣ ਲਈ ਬਹੁਤ ਸਾਰੀਆਂ ਰਚਨਾਤਮਕ ਸੰਭਾਵਨਾਵਾਂ ਖੁੱਲ੍ਹੀਆਂ ਹਨ, ਜੋ ਗੈਰ-ਕਾਰਜਸ਼ੀਲ ਭਾਸ਼ਾਵਾਂ ਦੀ ਦੁਹਰਾਏ ਨਹੀਂ ਜਾ ਸਕਦੀਆਂ.

ਇਨਕਲੇਮਟ ਟਾਈਪਕਲਾਸ ਇਨਫਰੈਂਸ ਐਂਡ ਕੰਪਾਇਲ ਟਾਈਮ ਅਰੀਮ ਡੀਟੈਚਸ਼ਨ. ਹਾਸਕੈਲ ਨੂੰ ਕਿਸੇ ਵੀ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਸਭ ਤੋਂ ਵਧੇਰੇ ਬੁੱਧੀਮਾਨ ਕਿਸਮ ਸ਼੍ਰੇਣੀ ਪ੍ਰਣਾਲੀ ਦੇ ਰੂਪ ਵਿੱਚ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ. ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਡਾਟਾ ਕਿਸਮਾਂ (ਜਿਵੇਂ ਕਿ, ਸਤਰ, ਪੂਰਨ ਅੰਕ, ਬੂਲੀਅਨਜ਼, ਸੂਚੀਆਂ, ਅਤੇ ਕਈ ਹੋਰ) ਆਪਣੇ-ਆਪ ਹੀ ਹੁੰਦੇ ਹਨ ਅਤੇ ਸਹੀ 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.

ਬਾਰ ਬਾਰ ਅਕਸਰ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਇਹ ਘੱਟ ਕੋਡ ਨਾਲ ਵਧੇਰੇ ਸ਼ਕਤੀਸ਼ਾਲੀ ਅਤੇ ਕੁਸ਼ਲ ਫੰਕਸ਼ਨ ਬਣਾਉਂਦਾ ਹੈ, ਪਰ ਨੇਸਟੇਡ ਰੀਕਵਰਵ ਫੰਕਸ਼ਨ ਹੈਸਲ ਨਿਊਜ਼ ਲਈ ਉਲਝਣਾਂ ਵਾਲਾ ਹੋ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ ਕੋਡ ਕੋਡ ਨੂੰ ਆਧੁਨਿਕ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਜ਼ਿਆਦਾ ਸਾਰਥਕ ਸਮਝਦਾ ਹੈ.

Code abstraction is a byproduct of Haskell's extremely intelligent compiler. ਹਾਸਕੈਲ ਕੰਪਾਈਲਰ ਇੰਟਵਿਊਜ਼ ਕਈ ਕਿਰਿਆਵਾਂ ਅਤੇ ਪ੍ਰਸੰਗਿਕ ਕਾਰਕ ਜੋ 70% ਤੱਕ ਦੇ ਦਿੱਤੇ ਗਏ ਪ੍ਰੋਗਰਾਮ ਦੇ ਵਿਹਾਰ ਨੂੰ ਤਿਆਰ ਕਰਨ ਲਈ ਲੋੜੀਂਦੇ ਕੁੱਲ ਕੋਡ ਨੂੰ ਘਟਾਉਂਦੇ ਹਨ (ਜਾਂ ਹੋਰ ਤਾਂ ਫੰਕਸ਼ਨ ਕੰਪੋਜੀਸ਼ਨ is used). This is one of the primary reasons why the Haskell-based Web server ("Warp") can be written 1,000 ਤੋਂ ਘੱਟ ਲਾਈਨਾਂ ਕੋਡ ਵਿੱਚ ਜਦਕਿ ਅਪਾਚੇ ਵੈੱਬ ਸਰਵਰ ਇਸ ਬਾਰੇ ਲੋੜੀਂਦਾ ਹੈ ਕੋਡ ਦੀ 1.5 ਮਿਲੀਅਨ ਲਾਈਨਜ਼. ਅਤੇ ਤਰਾਪੇ ਅਪਾਚੇ ਨਾਲੋਂ 100 ਗੁਣਾ ਤੇਜ਼ੀ ਨਾਲ ਵੱਧ ਹੈ ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਬੱਗ ਅਤੇ ਸੁਰੱਖਿਆ ਹੈਕ ਲਈ ਕਮਜ਼ੋਰ ਹੈ. (ਬੇਸ਼ਕ, ਸਾਰੇ ਬੈਨਮਾਰਕਸ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ ਕਿ ਹਰੇਕ ਸਿਸਟਮ ਕਿਵੇਂ ਸੰਰਚਿਤ ਹੈ, ਪਰ ਆਮ ਵਿੱਚ, 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" ਆਮ ਅਰਥਾਂ ਵਿਚ, ਪਰ ਇਸ ਵਿਚ ਸਥਿਰ ਅਤੇ ਬਹੁਤ ਸ਼ਕਤੀਸ਼ਾਲੀ ਰਿਕਾਰਸੀਸ਼ਨ ਅਤੇ ਪੈਟਰਨ-ਮੇਲਿੰਗ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ. ਇਹ ਲੂਪਸ ਅਤੇ ਮਿਊਟੇਬਲ ਵੇਰੀਏਬਲਾਂ ਲਈ / ਸਮੇਂ ਦੀ ਲੋੜ ਨੂੰ ਬਦਲਦੇ ਹਨ. ਵਾਸਤਵ ਵਿੱਚ, ਰੀਕਜਰਨ ਅਤੇ ਪੈਟਰਨ-ਮੇਲਿੰਗ ਇੱਕੋ ਜਿਹੇ ਕੰਮ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਬਹੁਤ ਜ਼ਿਆਦਾ ਕੁਸ਼ਲ ਟੂਲ ਹਨ, ਜਿਸ ਕਾਰਨ ਹੈਸੈਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ / ਜਦੋਂ ਲੂਪਸ ਲਈ ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦਾ.

ਹਾਸਕੈਲ ਆਲਸੀ ਹੈ. 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.)

ਸਾਰੰਸ਼ ਵਿੱਚ: 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 ਹਾਸਕੈਲ ਭਾਸ਼ਾ ਪੰਨਾ.

---

ਨੋਟਸ:

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 ਬਲੇਕ 2 ਹੈਸ਼ਿੰਗ ਫੰਕਸ਼ਨ ਅਤੇ ਆਰਗੋਨ 2 ਕੁੰਜੀ ਡੈਰੀਵੇਸ਼ਨ ਫੰਕਸ਼ਨ) ਨੂੰ C, C ++, ਅਤੇ ਜਾਵਾ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ ਅਤੇ ਸਾਨੂੰ ਕਦੇ-ਕਦੇ ਉਹਨਾਂ ਅਤੇ ਸਾਡੇ ਹਾਸਕਲ ਕੰਪੋਨੈਂਟ ਦੇ ਵਿਚਕਾਰ ਇੰਟਰਫੇਸ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ. ਹਾਲਾਂਕਿ, ਅਸੀਂ ਸੰਭਵ ਤੌਰ 'ਤੇ ਜਿੰਨੀ ਜਿੰਨੀ ਹਿੱਸੇ ਦੇ ਲਈ Haskell ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ; ਅਤੇ ਸਮੇਂ ਦੇ ਨਾਲ, ਜਦੋਂ ਅਸੀਂ ਵਿਸ਼ਵਾਸ਼ ਕਰਦੇ ਹਾਂ ਕਿ ਇਹ ਸਾਡੇ ਸਿਸਟਮ ਨੂੰ ਵਧੇਰੇ ਸੁਰੱਖਿਅਤ ਅਤੇ ਭਰੋਸੇਮੰਦ ਬਣਾਵੇਗਾ, ਅਸੀਂ Haskell- ਅਧਾਰਿਤ ਓਪਨ ਸੋਰਸ ਲਾਇਬਰੇਰੀਆਂ ਅਤੇ / ਜਾਂ ਸਾਡੇ ਆਪਣੇ Haskell- ਅਧਾਰਤ ਕੰਪੋਨੈਂਟ ਦੇ ਨਾਲ ਗੈਰ- Haskell ਓਪਨ ਸੋਰਸ ਲਾਇਬਰੇਰੀਆਂ ਨੂੰ ਬਦਲ ਦਿਆਂਗੇ.

3. ਅਸੀਂ ਆਧੁਿਨਕ ਤੌਰ ਤੇ ਇਸ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਨ ਤੋਂ ਬਾਅਦ ਸਾਰੇ Gini ਸਾਫਟਵੇਅਰ ਓਪਨ ਸੋਰਸ ਕਮਿਊਨਿਟੀ ਨੂੰ ਜਾਰੀ ਕੀਤੇ ਜਾਣਗੇ ਗਨੀ ਬਲਾਕਗਰਿੱਡ ਅਤੇ ਗਿਨੀ ਵਿਕੇਂਦਰੀਿਤ ਐਕਸਚੇਂਜ ਆਮ ਲੋਕਾਂ ਲਈ

4. ਹਾਸਕੈਲ ਵਿਚ ਆਲਸੀ ਵਿਸ਼ੇਸ਼ਤਾ ਲਈ ਦੋ ਅਪਵਾਦ ਹਨ: ਸਖਤ ਬਾਈਟਸਟੇਅਰਜ਼ ਅਤੇ ਲੇਜ਼ੀ ਬਾਈਟਸਟੇਰਿਸ. ਸਖ਼ਤ ਬਾਈਟਸਟੇਂਸ 8-ਬਿੱਟ (1-ਬਾਈਟ) ਡਾਟਾ ਵਿੰਕਾਂ ਦੇ ਤੌਰ ਤੇ ਡਾਟਾ ਦਰਸਾਉਂਦੇ ਹਨ ਆਲਸੀ ਨਹੀਂ ਹਨ, 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.

---