Codage Blockchain: les nombreuses langues dont vous avez besoin!

Dans ce guide, nous passerons en revue certains des codages les plus importants de Blockchain. Et si vous débutez, consultez nos cours complets sur la blockchain.

La technologie blockchain est incroyablement fascinante. Il n’est pas exagéré de penser à un avenir qui sera entièrement construit sur lui. Alors, que devez-vous apprendre pour commencer à développer sur la blockchain? Quelles langues vous donneront l’avantage? Commençons par le codage blockchain!

Problèmes de programmation de la blockchain

Avant de commencer, examinons certains des défis auxquels un développeur de blockchain est confronté. Créer et maintenir une blockchain publique n’est pas facile pour un certain nombre de raisons.

(Avant de continuer, un grand merci à David Schwartz pour son discours d’ouverture concernant l’utilisation du C ++ dans le développement de logiciels blockchain dans CPPCON 2016.)

Codage blockchain

Défi n ° 1 de la difficulté de codage de la blockchain: sécurité

Blockchains, comme David Schwartz dit-il, devrait être des forteresses. Premièrement, le code est public et ouvert à tous. Tout le monde peut consulter le code et rechercher des bogues et des vulnérabilités. Cependant, contrairement à d’autres ressources de code ouvert, l’inconvénient de trouver des vulnérabilités sur le code de la blockchain est énorme. N’importe quel programmeur peut pirater et s’en tirer avec potentiellement des millions et des millions de dollars. En raison de ces problèmes de sécurité légitimes, le développement sur la blockchain est généralement très lent.

Défi n ° 2 de la difficulté de codage blockchain: gestion des ressources

Il est important de suivre le rythme du réseau. Vous ne pouvez pas prendre trop de retard et ne pas répondre à toutes les demandes du réseau. Vous devez être bien équipé pour gérer les requêtes distantes et locales.

Défi de difficulté de codage blockchain n ° 3: performances

La blockchain doit toujours fonctionner à ses capacités les plus élevées possibles, mais pour cela, le langage choisi doit être extrêmement polyvalent. Le fait est qu’il y a certaines tâches dans la blockchain qui sont parallélisables alors que certaines tâches ne peuvent pas être effectuées en parallèle.

Un bon exemple de tâche «parallélisable» est la vérification de signature numérique. Tout ce dont vous avez besoin pour la vérification de la signature est la clé, la transaction et la signature. Avec seulement trois données, vous pouvez effectuer des vérifications de manière parallélisée.

Cependant, toutes les fonctions d’une blockchain ne doivent pas être effectuées de cette façon. Pensez à l’exécution des transactions elle-même. Plusieurs transactions ne peuvent pas être exécutées en parallèle; il doit être fait un par un pour éviter les erreurs comme les doubles dépenses. Certains langages sont bons pour les opérations parallèles tandis que certains sont bons pour les opérations non parallèles.

Former pour devenir un développeur Blockchain

Commencez votre essai gratuit aujourd’hui!

Défi n ° 4 de difficulté de codage de la blockchain: isolement

Qu’est-ce qu’un comportement déterministe?

• Si A + B = C, quelles que soient les circonstances, A + B sera toujours égal à C. C’est ce qu’on appelle un comportement déterministe.
• Les fonctions de hachage sont déterministes, ce qui signifie que le hachage de A sera toujours H (A).

Ainsi, dans le développement de la blockchain, toutes les opérations de transaction doivent être déterministes. Vous ne pouvez pas avoir une transaction qui se comporte d’une manière puis se comporte d’une autre manière le lendemain. De même, vous ne pouvez pas avoir de contrats intelligents qui fonctionnent de deux manières différentes sur deux machines différentes.

La seule solution à cela est l’isolement. Fondamentalement, vous isolez vos contrats et transactions intelligents des éléments non déterministes.

Nous avons donc discuté des principaux problèmes auxquels les développeurs de blockchain sont confrontés. Voyons enfin quelques-uns des langages que les développeurs peuvent utiliser pour coder sur la blockchain.

Langage de codage blockchain n ° 1: C++

Tout d’abord et avant tout, commençons par le grand-père de tous, le persistant C++. C ++ a été créé par Bjarne Stroustrup en tant qu’extension du langage C. Le langage a été conçu pour avoir la flexibilité et l’efficacité du C mais avec quelques différences majeures. La plus grande différence entre C et C ++ est que tandis que C est orienté processus, C ++ est orienté objet.

Cela signifie que, en C ++, les données et les fonctions sont regroupées dans un petit paquet soigné appelé «objets», ce qui signifie qu’une fois qu’un objet est créé, il peut facilement être appelé et réutilisé dans d’autres programmes, ce qui réduit considérablement le temps de codage.

Examinons le programme C ++ le plus simple au monde. Le programme «Hello World»:

#comprendre

principale()

{

cout << "Bonjour le monde!";

return 0;

}

Ce code imprimera “Hello World!”

Alors, pourquoi les gens utilisent-ils encore C ++ pour le codage? Il existe sûrement des langages beaucoup plus glamour maintenant, pourquoi les gens insistent-ils encore pour revenir au C ++? Pourquoi la blockchain Bitcoin est-elle codée sur C++?

Eh bien, en l’occurrence, C ++ a certaines fonctionnalités qui le rendent très attrayant. (Criez à Peter Wiulle et David Schwartz pour l’explication suivante).

Caractéristique n ° 1: Contrôle de la mémoire

Rappelez-vous ce que nous avons dit plus tôt sur les défis du développement de la blockchain? Non seulement les blockchains devraient être des forteresses sécurisées, mais elles devraient également avoir une gestion efficace des ressources. Une blockchain est censée interagir avec de nombreux points de terminaison non approuvés tout en offrant un service rapide à tous les nœuds.

Ce service rapide et rapide est essentiel pour le succès d’une crypto-monnaie comme le bitcoin. Rappelez-vous, ils sont tous basés sur le principe du «consensus», tous les nœuds du réseau doivent accepter et rejeter exactement les mêmes blocs, sinon il pourrait y avoir une fourchette dans la chaîne.

Afin de satisfaire toutes ces demandes et de fonctionner au plus haut niveau, vous avez besoin d’un contrôle strict et complet sur l’utilisation du processeur et de la mémoire. C ++ donne cela à ses utilisateurs.

Caractéristique n ° 2: filetage

Comme nous l’avons vu précédemment, l’un des principaux défis de la programmation blockchain est l’intégration de tâches qui se parallélisent bien et les tâches qui ne se parallélisent pas. La plupart des langages se spécialisent dans un seul, cependant, la capacité de threading de C ++ est suffisante pour gérer les tâches parallèles et non parallèles. Un thread est un ensemble d’instructions qui peuvent être exécutées simultanément. Non seulement le C ++ permet de superbes installations multithreading avec une communication inter-thread efficace, mais il optimise également les performances mono-thread.

Fonctionnalité n ° 3: Déplacer la sémantique

L’un des aspects les plus intéressants du C ++ est la sémantique des déplacements. La sémantique de déplacement fournit un moyen pour le contenu d’être déplacé entre les objets plutôt que d’être entièrement copié. Voyons les différences entre la sémantique de copie et la sémantique de déplacement. (Les données suivantes sont tirées de la réponse de Peter Alexander dans “Stackoverflow”).

Copier la sémantique:

• assert (b == c);
• a = b;
• assert (a == b && b == c);

Alors que se passe-t-il ici? La valeur de b entre dans a et b reste inchangée à la fin de tout.

Maintenant, considérez ceci.

Déplacer la sémantique:

• assert (b = = c);
• déplacer (a, b);
• assert (a = = c);

Que se passe-t-il ici?

Pouvez-vous voir la différence entre les deux blocs de codes?

Lorsque nous utilisons la sémantique de déplacement, la valeur de «b» n’a pas besoin d’être inchangée. C’est la différence entre la sémantique de copie et la sémantique de déplacement. Le plus grand avantage de la sémantique de déplacement est que vous ne pouvez obtenir des copies de certaines données que lorsque vous en avez besoin, ce qui réduit considérablement la redondance dans le code et augmente considérablement les performances. Donc, comme vous pouvez le voir, cette gestion de la mémoire efficace et ces hautes performances sont toutes deux souhaitables pour la blockchain.

Caractéristique n ° 4: Polymorphisme au moment de la compilation

Qu’est-ce que le polymorphisme?

Rappelez-vous quand nous avons appelé C ++ un «langage de programmation orientée objet (POO)»? Le polymorphisme est une propriété POO. En utilisant le polymorphisme, vous utilisez une fonction particulière de plusieurs manières. En C ++, le polymorphisme peut être utilisé de deux manières:

• Polymorphisme à la compilation.
• Polymorphisme d’exécution.

Ici, nous nous concentrerons uniquement sur le polymorphisme à la compilation. Le C ++ implémente le polymorphisme à la compilation de deux manières:

• Surcharge de fonction.
• Surcharge de l’opérateur.

Surcharge de fonction:

La surcharge de fonctions se produit lorsque vous avez de nombreuses fonctions du même nom mais avec des paramètres différents.

Considérez ce programme:

#comprendre

en utilisant l’espace de noms std;

Classe A

{

void func (int x) // la première instance de la fonction ne prend qu’une seule valeur entière

{

cout<<X<<endl;

}

void func (double x) // la deuxième instance de la fonction ne prend qu’une seule valeur double

{

cout<<X<<endl;

}

void func (int x, int y) // la troisième instance de la fonction prend deux valeurs entières

{

cout<<x = y<<endl;

}

}

int main()

{

Un obj1 // faisant un objet de la classe A

// maintenant nous allons appeler les fonctions

obj1.func (2);

obj1.func (2,65);

obj1.func (2,5);

return 0;

}

Maintenant, lorsque vous exécutez cette fonction, la sortie sera:

• 2
• 2,65
• 7

Donc, comme vous pouvez le voir, la même fonction func () a été utilisée de 3 manières différentes.

Surcharge de l’opérateur:

En C ++, le même opérateur peut avoir plus d’une signification.

• Par exemple. «+» Peut être utilisé à la fois pour l’addition mathématique et pour la concaténation.
• La concaténation signifie essentiellement prendre deux chaînes et les combiner en une seule.
• Donc 3 + 4 = 7.

ET

• Block + geeks = Blockgeeks.
• Le même opérateur a effectué deux fonctions différentes, il s’agit d’une surcharge de l’opérateur.

Le polymorphisme à la compilation aide beaucoup au développement de la blockchain. Il aide à répartir les responsabilités séparément dans diverses fonctions et, à son tour, à améliorer les performances de l’ensemble du système.

Caractéristique n ° 5: Isolation de code

C ++ a des fonctionnalités d’espace de noms qui peuvent être importées d’un programme à un autre. L’espace de noms aide à éviter les collisions de noms. De plus, comme C ++ a des classes, il peut agir comme des frontières entre diverses API et aider à faire une séparation claire.

Une classe en C ++ est un type défini par l’utilisateur ou une structure de données déclarée avec une classe de mots-clés qui a des données et des fonctions comme membres. Vous pouvez accéder aux fonctions déclarées dans la classe en déclarant des objets de cette classe particulière.

Caractéristique n ° 6: Maturité

La langue est à la fois mature et régulièrement mise à jour. Il existe au moins 3 compilateurs solides, comme le dit David Schwartz, et les nouvelles fonctionnalités visent à résoudre de vrais problèmes. Des débogueurs et des outils analytiques de toutes sortes sont disponibles pour tout, du profilage des performances à la détection automatique des problèmes de toutes sortes. Cela signifie que la langue se développe constamment pour intégrer des fonctionnalités plus récentes et meilleures.

En raison des fonctionnalités ci-dessus, Satoshi Nakamoto a choisi C ++ comme langue de base du code source Bitcoin.

Langage de codage Blockchain # 2: Javascript

Ensuite, nous avons Javascript.

Avec HTML et CSS, c’est l’une des trois technologies de base dans la production de contenu World Wide Web. Javascript est généralement utilisé pour créer des pages Web hautement interactives. Nous allons donc maintenant voir comment créer une blockchain très simple en utilisant Javascript. Grand merci à savjee.be pour le contenu de cette section.

Supposons que nous voulions créer une simple blockchain en Javascript. Avant de le faire, il y a certaines choses que nous devons aborder.

Qu’est-ce qu’une blockchain et comment fonctionne-t-elle exactement… au niveau du code?

Une blockchain est essentiellement une chaîne de blocs contenant des données. Il s’agit essentiellement d’une liste chaînée glorifiée. Cependant, qu’est-ce qui le rend si spécial? Une blockchain est immuable. Cela signifie qu’une fois qu’une donnée entre dans un bloc, elle ne peut jamais être modifiée. Comment une blockchain atteint-elle l’immuabilité? C’est à cause d’un mécanisme simple mais ingénieux appelé «hachage». Consultez le diagramme ci-dessous:

Courtoisie d’image: article moyen de Lauri Hartikka

Chaque bloc est connecté au bloc précédent via un pointeur de hachage qui contient le hachage du bloc précédent. Alors, comment cela rend la chaîne immuable?

L’une des propriétés les plus fascinantes des fonctions de hachage cryptographiques est que si vous modifiez même un peu l’entrée, cela peut grandement affecter le hachage de sortie. Par exemple. Regarde ça:

Le simple fait de changer le premier «T» des majuscules aux minuscules a radicalement changé le hachage de sortie.

Alors, comment cela affecte-t-il la blockchain?

Chaque bloc est connecté au précédent via le pointeur de hachage. Donc, si quelqu’un devait falsifier les données dans un bloc, cela changerait radicalement le hachage et, par conséquent, finirait par affecter toute la chaîne (car tous les blocs sont liés). Cela gèlerait la chaîne, ce qui est impossible et les blocs resteraient donc inchangés.

Alors, comment faire un bloc? En quoi consiste un simple bloc? Dans notre simple crypto-monnaie que nous allons créer (appelons-la “BlockGeeksCoin”), chaque bloc aura les informations suivantes:

• Index: Pour connaître le numéro de bloc.
• Horodatage: pour connaître l’heure de création.
• Données: les données à l’intérieur du bloc.
• Hash précédent: le hachage du bloc précédent.
• Hash: le hachage du bloc actuel.

Avant de continuer. Vous devez comprendre certains termes que nous allons utiliser dans notre programme:

• ce: Le mot-clé «this» est appelé à l’intérieur d’une fonction et vous permet d’accéder aux valeurs à l’intérieur d’un objet spécifique qui appelle cette fonction particulière.
• Constructeur: Un constructeur est une fonction spéciale qui peut aider à créer et initialiser un objet dans une classe. Chaque classe est limitée à un seul constructeur.

Maintenant que c’est fait, commençons à faire notre blocage.

Créer le bloc

const SHA256 = exiger ("crypto-js / sha256");

Bloc de classe

{

constructeur (index, horodatage, données, previousHash = ”)

{

this.index = index;

this.previousHash = previousHash;

this.timestamp = horodatage;

this.data = données;

this.hash = this.calculateHash ();

}

calculerHash ()

{

return SHA256 (this.index + this.previousHash + this.timestamp + JSON.stringify (this.data)). toString ();

}

}

Analyse de code

Ok, donc ce droit ici est hors bloc. Donc, dans la première ligne du code, nous avons appelé la bibliothèque crypto-js car la fonction de hachage sha256 n’est pas disponible en JavaScript.

Ensuite, nous avons appelé un constructeur à l’intérieur de la classe pour appeler des objets qui auront certaines valeurs. Ce qui attire probablement votre attention, c’est la fonction CalculateHash (). Voyons ce qu’il fait exactement.

Dans un bloc, nous prenons tout le contenu et le hachons pour obtenir le hachage de ce bloc particulier. Nous utilisons la fonction JSON.stringify pour transformer les données du bloc en chaîne pour le hacher.

Ok, donc nous avons le bloc prêt et prêt à partir. Maintenant, connectons les blocs ensemble dans une blockchain.

Créer la blockchain

Blockchain de classe

{

// Section 1 Création d’un bloc Genesis

constructeur()

{

this.chain = [this.createGenesisBlock ()];

}

createGenesisBlock ()

{

retourner un nouveau bloc (0, "01/01/2017", "Bloc Genesis", "0");

}

// section 2 ajout de nouveaux blocs

getLatestBlock ()

{

return this.chain [this.chain.length – 1];

}

addBlock (newBlock) {

newBlock.previousHash = this.getLatestBlock (). hash;

newBlock.hash = newBlock.calculateHash ();

this.chain.push (newBlock);

}

// section 3 validation de la chaîne

isChainValid ()

{

pour (soit i = 1; i < this.chain.length; i ++)

{

const currentBlock = this.chain [i];

const previousBlock = this.chain [i – 1];

if (currentBlock.hash! == currentBlock.calculateHash ()) {

retourner faux;

}

if (currentBlock.previousHash! == previousBlock.hash)

{

retourner faux;

}

}

retourne vrai;

}

}

Analyse de code

Ok, donc beaucoup de choses se passent dans la chaîne ci-dessus, décomposons-les en sections.

Section 1: Le bloc Genesis

Quel est le bloc de genèse?

Le bloc de genèse est le premier bloc de la blockchain, et la raison pour laquelle il est spécial est que, bien que chaque bloc pointe vers le bloc précédent, le bloc de genèse ne pointe vers rien. Ainsi, dès qu’une nouvelle chaîne est créée, le bloc de genèse est immédiatement appelé. En outre, vous pouvez voir une fonction «createGenesisBlock ()» dans laquelle nous avons donné les données du bloc manuellement:

createGenesisBlock ()

{

renvoie un nouveau bloc (0, «01/01/2017», «Bloc Genesis», «0»);

}

Maintenant que nous avons construit le bloc de genèse, construisons le reste de la chaîne.

Section 2: Ajout des blocs

Tout d’abord, nous aurons besoin de savoir quel est actuellement le dernier bloc de la blockchain. Pour cela, nous utilisons la fonction getLatestBlock ().

getLatestBlock ()

{

return this.chain [this.chain.length – 1];

}

Maintenant que nous avons déterminé le dernier bloc, voyons comment nous allons ajouter de nouveaux blocs.

addBlock (newBlock) {

newBlock.previousHash = this.getLatestBlock (). hash;

newBlock.hash = newBlock.calculateHash ();

this.chain.push (newBlock);

}

Alors, que se passe-t-il ici? Comment ajoutons-nous les blocs? Comment vérifions-nous si le bloc donné est valide ou non?

Souvenez-vous du contenu d’un bloc?

Un bloc a le hachage du bloc précédent à droite?

Donc, ce que nous allons faire ici est simple. Comparez la valeur de hachage previousHash du nouveau bloc avec la valeur de hachage du dernier bloc.

Courtoisie d’image: article moyen de Lauri Hartikka

Si ces deux valeurs correspondent, cela signifie que le nouveau bloc est légitime et qu’il est ajouté à la blockchain.

Section 3: Validation de la chaîne

Maintenant, nous devons vérifier que personne n’a joué avec notre blockchain et que tout est stable.

Nous utilisons la boucle «for» pour passer du bloc 1 au dernier bloc. Le bloc Genesis est le bloc 0.

pour (soit i = 1; i < this.chain.length; i ++)

{

const currentBlock = this.chain [i];

const previousBlock = this.chain [i – 1];

Dans cette partie du code, nous définissons deux termes, bloc actuel et bloc précédent. Et maintenant, nous allons simplement trouver le hachage de ces deux valeurs.

if (currentBlock.hash! == currentBlock.calculateHash ()) {

retourner faux;

}

if (currentBlock.previousHash! == previousBlock.hash)

{

retourner faux;

}

}

retourne vrai;

}

Si le “previousHash” du bloc courant n’est pas égal au “Hash” du bloc précédent, alors cette fonction retournera False, sinon elle retournera True.

Utiliser la blockchain

Maintenant, nous allons enfin utiliser la blockchain pour créer notre BlockGeeksCoin.

• laissez BlockGeeksCoin = new Blockchain ();
• BlockGeeksCoin.addBlock (nouveau bloc (1, «20/07/2017», {montant: 4}));
• BlockGeeksCoin.addBlock (nouveau bloc (2, «20/07/2017», {montant: 8}));

Et c’est tout!

Alors que s’est-il passé ici?

Nous avons créé une nouvelle crypto-monnaie basée sur la blockchain et l’avons nommée BlockGeeksCoin. En invoquant ce nouvel objet, j’ai activé le constructeur, qui à son tour a créé le bloc Genesis automatiquement.

Nous avons simplement ajouté deux blocs supplémentaires et leur avons donné des données.

C’est aussi simple que ça.

(Merci savjee.be pour l’explication étonnante et simple.)

Langage de codage blockchain n ° 3: Python

Guido van Rossum, un programmeur néerlandais, a créé Python en 1991. Python est basé sur une philosophie simple: la simplicité et le minimalisme. L’un des moyens les plus remarquables d’incorporer la simplicité dans leur langage consiste à utiliser des espaces blancs pour signifier des blocs de code au lieu de crochets ou de mots-clés. Voyons ce que cela signifie.

Jetons un coup d’œil à un programme simple «bonjour le monde».

print (“Bonjour tout le monde!”)

Ouais, c’est tout!

Comparez cela au programme C ++ «hello world».

Vous voyez à quel point c’est moins compliqué en comparaison? Et si on faisait quelque chose d’un peu plus compliqué? Disons que nous ajoutons deux nombres et imprimons le résultat.

num1 = 1,5

num2 = 6,3

somme = float (num1) + float (num2)

print (“La somme de {0} et {1} est {2}”. format (num1, num2, sum))

Et c’est tout.

La sortie de ce programme sera:

• La somme de 1,5 et 6,3 est 7,8

Alors, montons la mise. Comment allons-nous programmer une blockchain entière en utilisant Python? Les données et le code suivants sont tirés de l’article de Gerald Nash dans Medium.

Créer le bloc

Tout d’abord, faisons notre blocage:

importer hashlib comme hasher

Bloc de classe:

def __init __ (self, index, timestamp, data, previous_hash):

self.index = index

self.timestamp = horodatage

self.data = données

self.previous_hash = précédent_hash

self.hash = self.hash_block ()

def hash_block (soi):

sha = hasher.sha256 ()

sha.update (str (self.index) +

str (auto.horodatage) +

str (données personnelles) +

str (self.previous_hash))

retourne sha.hexdigest ()

Analyse de code

Nous commençons par importer la bibliothèque de hachage pour utiliser les finctions de hachage SHA 256 (un peu comme Javascript).

Tout comme avant, le bloc a la même valeur:

• Indice.
• Horodatage.
• Données.
• Hachage précédent.
• Hacher.

Une fois contre, nous remplissons les valeurs de hachage via une fonction, comme avant.

Créer le bloc de genèse

Maintenant, créons le bloc Genesis:

importer datetime comme date

def create_genesis_block ():

return Block (0, date.datetime.now (), “Genesis Block”, “0”)

Analyse de code

Nous avons importé datetime pour mettre l’horodatage.

Nous avons simplement généré le bloc de genèse et lui avons donné manuellement des données avec lesquelles travailler. La valeur de hachage précédente est «0» car elle ne pointe vers aucun autre bloc.

Créer le reste des blocs

Définissons maintenant comment les blocs suivants seront créés.

def next_block (dernier_bloc):

this_index = dernier_bloc.index + 1

this_timestamp = date.datetime.now ()

this_data = "Hé! Je suis bloqué " + str (this_index)

this_hash = last_block.hash

return Block (this_index, this_timestamp, this_data, this_hash)

Analyse de code

Alors, comment allons-nous déterminer les valeurs de chaque élément de données à l’intérieur de chaque bloc?

L’index de bloc est simplement l’indice du dernier bloc + 1.

L’horodatage est la date et l’heure actuelles.

Les données du bloc sont un simple message: «Hé! Je bloque ».

Hash que nous calculons en utilisant la fonction que nous avons définie précédemment.

Et finalement, nous renvoyons toutes ces valeurs au bloc.

Créer la blockchain

Enfin, créons la blockchain.

blockchain = [create_genesis_block ()]

previous_block = blockchain [0]

num_of_blocks_to_add = 15

pour i dans la plage (0, num_of_blocks_to_add):

block_to_add = next_block (previous_block)

blockchain.append (block_to_add)

previous_block = block_to_add

# Parlez-en à tout le monde!

impression "Le bloc n ° {} a été ajouté à la blockchain!".format (block_to_add.index)

impression "Hash: {} n".format (block_to_add.hash)

Analyse de code

Tout d’abord, nous créons le bloc genesis et attribuons sa valeur à “previous_block”.

Ensuite, nous déterminons le nombre de blocs à ajouter, dans cet exemple, nous allons avec 15.

Nous exécutons donc une boucle qui va jusqu’à 15 et ajoute chaque bloc à la blockchain. À la fin du look, nous imprimons quel bloc de numéros a été ajouté à la blockchain en affichant leur numéro d’index. De plus, nous imprimons également le Hash.

Voici à quoi ressemblera la sortie:

Courtoisie d’image: Article moyen de Gerald Nash

Évidemment, à la fois dans ce logiciel et dans le javascript, vous pouvez ajouter des fonctionnalités plus compliquées telles que la preuve de travail. Si vous voulez savoir comment mettre en œuvre cela, il est fortement recommandé de lire l’article de Gerald Nash. Mais pour l’instant, vous savez au moins comment créer une simple blockchain en Python.

Langue n ° 4: Solidité

Enfin, nous arrivons à Solidity. Pour tous ceux qui souhaitent apprendre à créer des DAPP (applications décentralisées) ou se lancer dans le jeu ICO, apprendre Solidity est un must absolu. Nous avons déjà un guide détaillé à ce sujet que vous pouvez lire ici. Cependant, nous allons vous donner ici un aperçu de base. Solidity a été développé par Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai et plusieurs anciens contributeurs principaux d’Ethereum pour permettre l’écriture de contrats intelligents sur des plateformes blockchain telles qu’Ethereum..

Solidity est un langage délibérément allégé, faiblement typé avec une syntaxe très similaire à ECMAScript (Javascript). Il y a quelques points clés à retenir du document Ethereum Design Rationale, à savoir que nous travaillons dans un modèle de pile et mémoire avec une taille de mot d’instruction de 32 octets, l’EVM (Ethereum Virtual Machine) nous donne accès au programme ” stack ”qui est comme un espace de registre où nous pouvons également coller des adresses mémoire pour faire une boucle / saut du compteur de programme (pour le contrôle séquentiel du programme), une“ mémoire ”temporaire extensible et un“ stockage ”plus permanent qui est en fait écrit dans le blockchain, et surtout, l’EVM nécessite un déterminisme total dans les contrats intelligents.

Alors, avant de continuer, voyons un exemple de contrat Solidity de base. (Codes tirés de github).

Lançons une simple boucle while en solidité:

contrat BasicIterator

{

créateur d’adresse; // en réserver un "adresse"-tache de type

uint8 [10] entiers; // réserve un morceau de stockage pour 10 entiers non signés de 8 bits dans un tableau

fonction BasicIterator ()

{

créateur = msg.sender;

uint8 x = 0;

// Section 1: Attribuer des valeurs

tandis que (x < integers.length) {

entiers [x] = x;

x ++;

}}

function getSum () constante renvoie (uint) {

uint8 somme = 0;

uint8 x = 0;

// Section 2: Ajout des entiers dans un tableau.

tandis que (x < integers.length) {

somme = somme + entiers [x];

x ++;

}

retourne la somme;

}

// Section 3: Tuer le contrat

fonction kill ()

{

if (msg.sender == créateur)

{

suicide (créateur);

}

}

}

Alors, analysons.

Section 1: Attribution de valeurs

Dans la première étape, nous remplissons un tableau appelé «entiers» qui contient 10 entiers non signés de 8 bits. La façon dont nous le faisons se fait via une boucle while. Regardons ce qui se passe dans la boucle while.

tandis que (x < integers.length) {

entiers [x] = x;

x ++;

}

N’oubliez pas que nous avons déjà attribué une valeur de «0» à l’entier x. La boucle while va de 0 à integers.length. Integers.length est une fonction qui renvoie la capacité maximale du tableau. Donc, si nous décidons qu’un tableau aura 10 entiers, arrayname.length renverra une valeur de 10. Dans la boucle ci-dessus, la valeur de x va de 0 à 9 (<10) et affecte également la valeur de lui-même au tableau d’entiers. Ainsi, à la fin de la boucle, les entiers auront la valeur suivante:

0,1,2,3,4,5,6,7,8,9.

Section 2: Ajout du contenu du tableau

Dans la fonction getSum (), nous allons additionner le contenu du tableau lui-même. La façon de le faire est de répéter la même boucle while que ci-dessus et d’utiliser la variable «sum» pour ajouter le contenu du tableau.

Section 3: Tuer le contrat

Cette fonction met fin au contrat et renvoie les fonds restants du contrat au créateur du contrat.

Interrogé sur l’inspiration et la motivation derrière la création de solidité, le Dr Gavin Woods a déclaré ceci:

«Il [Solidity] était censé être un outil sophistiqué pour développer des contrats qui pourrait finalement donner aux développeurs et aux utilisateurs de bonnes informations sur ce que faisait le code. Pour vous aider, j’ai conçu NatSpec, un format de documentation compatible avec les contrats, et en ai fait un citoyen de premier ordre dans Solidity. J’ai également proposé un sous-ensemble de langage de vérification formel (pas encore implémenté) afin de maximiser les types de garanties d’exactitude qui pourraient être apportées.

J’ai introduit les événements en tant que citoyen de première classe dans le langage Solidity afin de fournir une belle abstraction pour les LOGs de forme similaire aux appels de fonction. L’inspiration pour cela est venue des «signaux» du système de méta-objets Qt.

Une caractéristique ultérieure que Christian R. et moi avons découvert ensemble était les modificateurs de fonction; qui permet aux attributs placés dans le cadre d’une signature de fonction d’apporter des modifications au corps apparent de la fonction. Étant un moyen d’expression très déclaratif, c’est un idiome qui s’inscrit parfaitement dans l’espace de programmation orienté contrat. »

Codage blockchain: conclusion

Dans cet article, nous n’avons couvert que 4 langues pour le codage blockchain qui sont utilisées dans le développement dans et autour de la blockchain. En réalité, il existe de nombreux autres langages que vous pouvez potentiellement utiliser (Java, Go). Si vous êtes programmeur, les possibilités pour vous sont vraiment infinies. Alors que le monde devient de plus en plus décentralisé et que la blockchain devient de plus en plus courante, l’avenir pour vous est définitivement illimité.