# Algorithm the problem of the backpack (Knapsack problem) in more than 128 words

The problem of the algorithmic backpack is interesting and is part of the first digital science and computer science program.

This problem illustrates the gluttonous algorithms that list all the possibilities of solving a problem to find the best solution.

The problem of the backpack is a problem of optimization, i.e. a function that must be maximized or minimized and constraints that must be met.

The problem of the backpack

For a backpack of maximum capacity of P and N items each with its own weight and a set value, throw the items inside the backpack so that the final contents have maximum value.

Example of a statement:

• Maximum backpack capacity: 11 units
• Item number: 5
• Object Values: \$10.50,20,30.60
• Weight of Objects: '1,5,3,2,4'

What is the maximum value that can be put in the backpack considering the maximum capacity constraint of the bag which is 11?

Gluttonous algorithm

An effective solution is to use a gluttonous algorithm. The idea is to calculate the value/weight ratio for each object and sort the object based on this calculated ratio.

You take the object with the highest ratio and add until you can't add any more.

In fractional version it is possible to add fractions of item to the backpack.

Implementation of the problem in non-fractional version

Here is an implementation of the problem in a non-fractional version, i.e. you can't add a fraction of an object to the bag. Only whole objects can be added.

```itemsac class:
def __init__ (self, weight, value, index):
self.index - index
self.weight - weight
self.value
self.report - value // weight
#Fonction for comparison between two ObjectsSac
#On compares the ratio calculated to sort them
def __lt__ (self, other):
return self.report< other.rapport

def getValeurMax (weights, values, ability):
TableTrie[]
for i in range:
tableTrie.append (ObjectSac (weigh[i]ts, value[i]s, i))

#Trier the elements of the bag by their report
tableTrie.sort (reverse - True)

MeterValeur - 0
for object in tableauTrie:
WeightCourant - int (object.weight)
ValueCourante - int (object.value)
if capacity - weightsCourant '0:
#on adds the object to the bag
#On subtracts capacity
capacity - weightsCourant
MeterValeur - ValueCourante
#On adds value to the bag
return counterValeur

Weights[1,5,3,2,4]
Values[10,50,20,30,60]
capacity - 11
Maximum value - getValeurMax (weight, values, capacity)
print ("Maximum value in the backpack," ValueMax) ```

The result is as follows:

```py sacados.py
Maximum value in backpack - 120```

Implementation of the problem in fractional version

In a fractional version of the backpack problem you can add fractions of object to the backpack.

```itemsac class:
def __init__ (self, weight, value, index):
self.index - index
self.weight - weight
self.value
self.report - value // weight
#Fonction for comparison between two ObjectsSac
#On compares the ratio calculated to sort them
def __lt__ (self, other):
return self.report< other.rapport

def getValeurMax (weights, values, ability):
TableTrie[]
for i in range:
tableTrie.append (ObjectSac (weigh[i]ts, value[i]s, i))

#Trier the elements of the bag by their report
tableTrie.sort (reverse - True)

MeterValeur - 0
for object in tableauTrie:
WeightCourant - int (object.weight)
ValueCourante - int (object.value)
if capacity - weightsCourant '0:
#on adds the object to the bag
#On subtracts capacity
capacity - weightsCourant
MeterValeur - ValueCourante
#On adds value to the bag
else
fraction - capacity / weightCouring
MeterValeur -Courante value - fraction
capacity - int (capacity - (weightsCourant - fraction))
Break
return counterValeur

Weights[1,5,3,2,4]
Values[10,50,20,30,60]
capacity - 11
Maximum value - getValeurMax (weight, values, capacity)
print ("Maximum value in the backpack," ValueMax) ```

The result is as follows:

```py sacados.py
Maximum value in backpack - 140.0```

# Algoritmo el problema de la mochila (problema de mochila) en más de 128 palabras

El problema de la mochila algorítmica es interesante y forma parte del primer programa de ciencia digital e informática.

Este problema ilustra los algoritmos glotón que enumeran todas las posibilidades de resolver un problema para encontrar la mejor solución.

El problema de la mochila es un problema de optimización, es decir, una función que debe ser maximizada o minimizada y restricciones que deben cumplirse.

El problema de la mochila

Para una mochila de máxima capacidad de artículos P y N cada uno con su propio peso y un valor establecido, tire los artículos dentro de la mochila para que el contenido final tenga el máximo valor.

Ejemplo de una declaración:

• Número de artículo: 5
• Valores de objeto: \$10.50,20,30.60
• Peso de los objetos: ‘1,5,3,2,4’

¿Cuál es el valor máximo que se puede poner en la mochila teniendo en cuenta la restricción de capacidad máxima de la bolsa que es 11?

Algoritmo gluttonoso

Una solución eficaz es utilizar un algoritmo glotón. La idea es calcular la relación valor/peso para cada objeto y ordenar el objeto en función de esta relación calculada.

Toma el objeto con la proporción más alta y agrega hasta que no puedaagregar más.

En versión fraccionaria es posible añadir fracciones de artículo a la mochila.

Implementación del problema en versión no fraccionada

Aquí está una implementación del problema en una versión no fraccionada, es decir, no se puede agregar una fracción de un objeto a la bolsa. Solo se pueden agregar objetos enteros.

```itemsac clase:
def __init__ (auto, peso, valor, índice):
self.index - índice
self.weight - peso
self.value
self.report - valor // peso
#Fonction para la comparación entre dos ObjectsSac
#On compara la relación calculada para ordenarlas
def __lt__ (yo, otros):
devolver self.report< other.rapport

TableTrie[]
para i en el rango:
tableTrie.append (ObjectSac (peso[i]s, valore[i]s, i))

#Trier los elementos de la bolsa por su informe
tableTrie.sort (reverse - True)

MeterValeur - 0
para el objeto en tableauTrie:
WeightCourant - int (object.weight)
ValueCourante - int (object.value)
si la capacidad - weightsCourant '0:
#on añade el objeto a la bolsa
MeterValeur - ValueCourante
#On añade valor a la bolsa
devolver contraValeur

Pesos[1,5,3,2,4]
Valores[10,50,20,30,60]
Valor máximo - getValeurMax (peso, valores, capacidad)
(valor máximo en la mochila", ValueMax) ```

```py sacados.py
Valor máximo en mochila - 120```

Implementación del problema en versión fraccionaria

En una versión fraccionaria del problema de la mochila se pueden añadir fracciones de objeto a la mochila.

```itemsac clase:
def __init__ (auto, peso, valor, índice):
self.index - índice
self.weight - peso
self.value
self.report - valor // peso
#Fonction para la comparación entre dos ObjectsSac
#On compara la relación calculada para ordenarlas
def __lt__ (yo, otros):
devolver self.report< other.rapport

TableTrie[]
para i en el rango:
tableTrie.append (ObjectSac (peso[i]s, valore[i]s, i))

#Trier los elementos de la bolsa por su informe
tableTrie.sort (reverse - True)

MeterValeur - 0
para el objeto en tableauTrie:
WeightCourant - int (object.weight)
ValueCourante - int (object.value)
si la capacidad - weightsCourant '0:
#on añade el objeto a la bolsa
MeterValeur - ValueCourante
#On añade valor a la bolsa
Otro:
MeterValeur -Valor Courante - fracción
Romper
devolver contraValeur

Pesos[1,5,3,2,4]
Valores[10,50,20,30,60]
Valor máximo - getValeurMax (peso, valores, capacidad)
(valor máximo en la mochila", ValueMax) ```

```py sacados.py
Valor máximo en mochila - 140.0```

# Problème du sac à dos – Algorithme en Python (knapsack problem)

Le problème du sac à dos en algorithmique (et son implémentation python) est intéressant et fait parti du programme de Sciences numériques et informatique de première.

Ce problème illustre les algorithmes gloutons qui énumèrent toutes les possibilités de résolution d’un problème pour trouver la meilleure solution.

Le problème du sac à dos algorithme python est un problème d’optimisation, c’est à dire une fonction que l’on doit maximiser ou minimiser et des contraintes qu’il faut satisfaire.

## Le problème du sac à dos – algorithme Python

Pour un sac à dos de capacité maximale de P et N articles chacun avec son propre poids et une valeur définie, jetez les articles à l’intérieur du sac à dos de telle sorte que le contenu final ait la valeur maximale.

Exemple d’énoncé :

• Capacité maximum du sac à dos : 11 unités
• Nombre d’objet : 5
• Valeurs des objets : {10,50,20,30,60}
• Poids des objets : {1,5,3,2,4}

Quelles est la valeur maximum qu’il est possible de mettre dans le sac à dos en considérant la contrainte de capacité maximum du sac qui est de 11 ?

## Algorithme glouton python

Une solution efficace consiste à utiliser un algorithme glouton. L’idée est de calculer le rapport valeur / poids pour chaque objet et de trier l’objet sur la base de ce rapport calculé .

On prends l’objet avec le ratio le plus élevé et on ajoute jusqu’à ce qu’on ne puisse plus en ajouter.

En version fractionnaire il est possible d’ajouter des fractions d’article au sac à dos.

## Implémentation du problème du sac à dos Python – version non fractionnaire

Voici une implémentation du problème du sac à dos python en version non fractionnaire, c’est à dire qu’on ne peut pas ajouter de fraction d’un objet dans le sac. Seul des objets entiers peuvent être ajoutés.

```class ObjetSac:
def __init__(self, poids, valeur, indice):
self.indice = indice
self.poids = poids
self.valeur = valeur
self.rapport = valeur // poids
#Fonction pour la comparaison entre deux ObjetSac
#On compare le rapport calculé pour les trier
def __lt__(self, other):
return self.rapport < other.rapport

def getValeurMax(poids, valeurs, capacite):
tableauTrie = []
for i in range(len(poids)):
tableauTrie.append(ObjetSac(poids[i], valeurs[i], i))

#Trier les éléments du sac par leur rapport
tableauTrie.sort(reverse = True)

compteurValeur = 0
for objet in tableauTrie:
poidsCourant = int(objet.poids)
valeurCourante = int(objet.valeur)
if capacite - poidsCourant >= 0:
#on ajoute l'objet dans le sac
#On soustrait la capacité
capacite -= poidsCourant
compteurValeur += valeurCourante
#On ajoute la valeur dans le sac
return compteurValeur

poids = [1,5,3,2,4]
valeurs = [10,50,20,30,60]
capacite = 11
valeurMax = getValeurMax(poids, valeurs, capacite)
print("Valeur maxi dans le sac à dos =", valeurMax) ```

Le résultat obtenu est le suivant :

```py sacados.py
Valeur maxi dans le sac à dos = 120```

## Implémentation du problème du sac à dos python – version fractionnaire

En version fractionnaire de l’agorithme du sac à dos python on peut ajouter des fractions d’objet au sac à dos.

```class ObjetSac:
def __init__(self, poids, valeur, indice):
self.indice = indice
self.poids = poids
self.valeur = valeur
self.rapport = valeur // poids
#Fonction pour la comparaison entre deux ObjetSac
#On compare le rapport calculé pour les trier
def __lt__(self, other):
return self.rapport < other.rapport

def getValeurMax(poids, valeurs, capacite):
tableauTrie = []
for i in range(len(poids)):
tableauTrie.append(ObjetSac(poids[i], valeurs[i], i))

#Trier les éléments du sac par leur rapport
tableauTrie.sort(reverse = True)

compteurValeur = 0
for objet in tableauTrie:
poidsCourant = int(objet.poids)
valeurCourante = int(objet.valeur)
if capacite - poidsCourant >= 0:
#on ajoute l'objet dans le sac
#On soustrait la capacité
capacite -= poidsCourant
compteurValeur += valeurCourante
#On ajoute la valeur dans le sac
else:
fraction = capacite / poidsCourant
compteurValeur += valeurCourante * fraction
capacite = int(capacite - (poidsCourant * fraction))
break
return compteurValeur

poids = [1,5,3,2,4]
valeurs = [10,50,20,30,60]
capacite = 11
valeurMax = getValeurMax(poids, valeurs, capacite)
print("Valeur maxi dans le sac à dos =", valeurMax) ```

Le résultat obtenu est le suivant :

```py sacados.py
Valeur maxi dans le sac à dos = 140.0```

## Liens internes algorithme python :

https://128mots.com/index.php/category/python/

## Liens externes algorithme python :

Website math.univ-lyon1.fr

Website www.dil.univ-mrs.fr

# Ethereum solidity tutorial – Build a step-by-step Blockchain Dapp

The first 2 articles provide a better understanding of the concept of blockchain and decentralized application.

Creating the project

A directory is created for the voting application project on songs.

`mkdir vote-song-dapp`

To accelerate development we will use a « truffle box »: https://www.trufflesuite.com/boxes

It’s sort of a template, an application canvas that allows you to focus on the Dapp by having a structure already created.

I will base my explanation on the pet-shop box available here: https://www.trufflesuite.com/tutorials/pet-shop. This is one of the first truffle tutorials to create a Dapp.

This truffle box includes the basic structure of the project as well as the user interface code.

Use the truffle unbox command:

`truffle unbox pet-shop`

As a reminder the installation of truffle is possible via the order:

`npm install -g truffle`

If you open the vote-chason-dapp folder with vscode then you get the following tree:

• contract: storage of the application’s smart contract
• migration: Migrations allow smart contracts to be transferred to the Ethereum blockchain (local test or mainnet). Migrations also allow you to link smart contracts with other smart contracts and start them.
• src: Front-end application directory (customer)
• test: Storage of tests for the application
• truffle-config.js: Javascript file that can execute any code needed to create your configuration.

Creating the smart contract

As a reminder we are developing an application that allows to elect the favorite song of voters.

We will first create the part that allows to create a vote for the best song based on 3 eligible songs.

The contract written in solidity is as follows:

```TopChanson contract
struct Song
uint ID;
title string;
uint counter;
}
uint public counterDeChansons;
mapping (uint - Song) public songs;

function addChansonElligible (string memory nomChanson) private
CounterDeChansons;
songs -[compteurDeChansons] Song (CounterDeChansons, NameChanson, 0);
}

TopChansons(public) function
}

}```

Note the use of « mapping (uint – Song) public songs; »

This data structure will allow us to store the titles of eligible songs like a hash table. That is, a table that takes as an access key in our case a uint that is the song ID and allows to recover the value that is a structured song type.

The Song type is structured, see solidity documentation: https://solidity.readthedocs.io/en/v0.6.6/types.html#structs

Here there is a special case on the feature addChansonElligible, it takes into argument the name of the song which is a string character chain. If you don’t add the keyword « memory » you get the following error:

TypeError: Data location must be « storage » or « memory » for parameter in function, but none was given.

For function settings and return variables, the location of the data must be explained for all type variables (struct, mapping, thong).

The contract is migrated via the order:

`truffle migrate --reset`

We then get:

```Compiling your contracts...
===========================
Compiling ./contracts/Migrations.sol
Compiling ./contracts/TopChanson.sol```

## Ethereum solidity tutorial – Liens internes :

https://128mots.com/index.php/2020/03/30/construire-une-application-decentralisee-full-stack-pas-a-pas-ethereum-blockchain-dapp-en-plus-de-128-mots-partie-1/

https://128mots.com/index.php/2020/04/02/construire-une-application-decentralisee-full-stack-pas-a-pas-ethereum-blockchain-dapp-en-plus-de-128-mots-partie-2/

https://128mots.com/index.php/category/python/

# Construir una aplicación paso a paso y descentralizada (Ethereum Blockchain Dapp) en más de 128 palabras – Parte 3

Este artículo sigue los dos primeros artículos sobre el tema:

Los primeros 2 artículos proporcionan una mejor comprensión del concepto de blockchain y aplicación descentralizada.

Creación del proyecto

Se crea un directorio para el proyecto de aplicación de votación en canciones.

`mkdir vote-song-dapp`

Para acelerar el desarrollo utilizaremos una "caja de trufa": https://www.trufflesuite.com/boxes

Es una especie de plantilla, un lienzo de aplicación que le permite centrarse en el Dapp al tener una estructura ya creada.

Basaré mi explicación en la caja de la tienda de mascotas disponible aquí: https://www.trufflesuite.com/tutorials/pet-shop. Este es uno de los primeros tutoriales de trufa para crear un Dapp.

Este cuadro de trufa incluye la estructura básica del proyecto, así como el código de la interfaz de usuario.

Utilice el comando trufero unbox:

`trufa unbox pet-shop`

Como recordatorio la instalación de la trufa es posible a través del pedido:

`npm instalar -g trufa`

Si abre la carpeta vote-chason-dapp con vscode, obtendrá el siguiente árbol:

• contrato: almacenamiento del contrato inteligente de la aplicación
• Migración: Las migraciones permiten transferir contratos inteligentes a la cadena de bloques Ethereum (prueba local o mainnet). Las migraciones también le permiten vincular contratos inteligentes con otros contratos inteligentes e iniciarlos.
• node_modules: La carpeta node_modules contiene bibliotecas descargadas de npm.
• src: Directorio de aplicaciones front-end (cliente)
• prueba: Almacenamiento de pruebas para la aplicación
• trufa-config.js: archivo Javascript que puede ejecutar cualquier código necesario para crear la configuración.

Creación del contrato inteligente

Como recordatorio estamos desarrollando una aplicación que permite elegir la canción favorita de los votantes.

Primero crearemos la parte que permite crear un voto para la mejor canción basada en 3 canciones elegibles.

El contrato escrito en solidez es el siguiente:

```Contrato de TopChanson
struct Song
ID de uint;
}
mapeo (uint - Canción) canciones públicas;

CounterDeChansons;
cancion[compteurDeChansons]es - Song (CounterDeChansons, NameChanson, 0);
}

Función TopChansons(público)
}

}```

Tenga en cuenta el uso de "mapping (uint – Song) canciones públicas;"

Esta estructura de datos nos permitirá almacenar los títulos de las canciones elegibles como una tabla hash. Es decir, una tabla que toma como clave de acceso en nuestro caso un uint que es el ID de la canción y permite recuperar el valor que es un tipo de canción estructurada.

El tipo de canción está estructurado, consulte la documentación de solidez: https://solidity.readthedocs.io/en/v0.6.6/types.html#structs

Aquí hay un caso especial en la característica addChansonElligible, toma en discusión el nombre de la canción que es una cadena de caracteres de cadena. Si no agrega la palabra clave "memory", obtendrá el siguiente error:

TypeError: la ubicación de los datos debe ser "almacenamiento" o "memoria" para el parámetro en función, pero no se ha dado ninguna.

Para la configuración de la función y las variables de retorno, la ubicación de los datos debe explicarse para todas las variables de tipo (struct, mapping, thong).

El contrato se migra a través del pedido:

`trufa migrar --reset`

Luego obtenemos:

```Recopilando tus contratos...
===========================
Compilación de ./contracts/Migrations.sol
Compilación de ./contracts/TopChanson.sol```

seguir…

# Construire une application décentralisée full-stack pas à pas (Ethereum Blockchain Dapp) en plus de 128 mots – Partie 3

Cet article fait suite aux deux premiers articles sur le sujet :

Les 2 premiers articles permettent de mieux comprendre le concept de blockchain et d’application décentralisée.

Création du projet

On crée un répertoire pour le projet d’application de vote sur des chansons.

`mkdir vote-chanson-dapp`

Pour accélérer le développement on va utiliser une « truffle box » : https://www.trufflesuite.com/boxes

C’est en quelques sorte un modèle, un canevas d’application qui vous permet de vous focaliser sur la Dapp en ayant une structure déjà créée.

Je vais baser mon explication sur la pet-shop box disponible ici : Website www.trufflesuite.com. C’est un des premiers tutos de truffle pour créer une Dapp.

Cette truffle box comprend la structure de base du projet ainsi que le code de l’interface utilisateur.

Utilisez la commande truffle unbox :

`truffle unbox pet-shop`

Pour rappel l’installation de truffle est possible via la commande :

`npm install -g truffle`

Si vous ouvrez le dossier vote-chason-dapp avec vscode vous obtenez alors l’arborescence suivante :

• contract : stockage du smart contract de l’application
• migration : Les migrations permettent de transférer les smarts contracts vers la blockchain Ethereum (en local test ou mainnet). Les migrations permettent également de relier des smart contrats avec d’autres smarts contracts et de les initialiser.
• node_modules : Le dossier node_modules contient les bibliothèques téléchargées depuis npm.
• src : Répertoire de l’application front-end (client)
• test : Stockage des tests pour l’application
• truffle-config.js : fichier Javascript qui peut exécuter tout code nécessaire pour créer votre configuration.

Création du smart contract

Pour rappel nous développons une application qui permet d’élire la chanson préférée des électeurs.

Nous allons créer dans un premier temps la partie qui permet de créer un vote pour la meilleure chanson basée sur 3 chansons éligibles.

Le contrat écrit en solidity est le suivant :

```contract TopChanson {
struct Chanson {
uint identifiant;
string titre;
uint compteur;
}
uint public compteurDeChansons;
mapping(uint => Chanson) public chansons;

function ajouterChansonElligible (string memory nomChanson) private {
compteurDeChansons ++;
chansons[compteurDeChansons] = Chanson(compteurDeChansons, nomChanson, 0);
}

function TopChansons() public {
ajouterChansonElligible("Au clair de la lune");
ajouterChansonElligible("Maman les p'tits bateaux");
ajouterChansonElligible("Ah ! Les crocodiles");
}

}```

A noter l’utilisation de « mapping(uint => Chanson) public chansons; »

Cette structure de donnée va nous permettre de stocker les titres des chansons éligibles à la façon d’une table de hachage. C’est à dire un tableau qui prend pour clé d’accès dans notre cas un uint qui est l’identifiant de la chanson et permet de récupérer la valeur qui est un type Chanson structuré.

Le type Chanson est structuré, voir la documentation solidity : https://solidity.readthedocs.io/en/v0.6.6/types.html#structs

Ici il y a un cas particulier sur la fonction ajouterChansonElligible, elle prends en argument le nom de la chanson qui est une chaine de caractère STRING. Si on ajoute pas le mot clé « memory » on obtient l’erreur suivante:

TypeError: Data location must be « storage » or « memory » for parameter in function, but none was given.

Pour les paramètres de fonction et les variables de retour, l’emplacement des données doit être explicité pour toutes les variables de type (struct, mapping, string).

La migration du contrat s’effectue via la commande :

`truffle migrate --reset`

On obtient alors :

```Compiling your contracts...
===========================
> Compiling ./contracts/Migrations.sol
> Compiling ./contracts/TopChanson.sol```

A suivre …

# Build a step-by-step, decentralized application (Ethereum Blockchain Dapp) in more than 128 words – Part 2

Example of decentralized voting application (Dapp)

The user of the decentralized application needs a wallet that contains Ether. As stated in the first article it is possible to easily create a wallet on https://metamask.io/.

First we will use the ropsten network. Ropsten Ethereum, also known as the « Ethereum Testnet », is, as the name suggests, a test network that performs the same protocol as Ethereum and is used for testing purposes before deploying on the main network (Mainnet). Website ropsten.etherscan.io

The use will allow us to create and use our app for free before eventually broadcasting it on Ethereum’s main network.

When the user connects to our application and the network he sends his vote and has to pay a few fees via his wallet in order to write his transaction in the Blockchain (called « Gas », this term refers to the fees to complete a transaction or execute a contract on the Ethereum blockchain).

Dapp app architecture

The application architecture consists of a front-end that will be in HTML and Javascript. This Frontend will engage directly with the local ethereum blockchain that we will install.

As stated in the first article the business rules and logic will be coded in a Smart Contract. The Smart Contract is written with the solidity programming language: Website solidity.readthedocs.io

Creation of the Front-End

The front-end will be simple it allows you to display the result of the vote for your favorite song in the form of a list and to choose from a drop-down list the song for which you wish to vote.

Check node installation

`node -v`

If node is not installed you can refer to my article on angular: http://128mots.com/index.php/2020/02/27/angular-en-plus-de-128-mots-partie-1/

Installation of the truffle framework: Truffle is a development environment, a testing framework and an asset pipeline for Ethereum, aimed at making your life easier as an Ethereum developer. It provides tools that allow us to write intelligent contacts with the Solidity programming language.

It will also be used to develop the front-end of the application.

`npm install -g truffle`

Ganache installation:

Ganache is a personal blockchain for Ethereum development that you can use to deploy contracts, develop your applications and run tests.

Website www.trufflesuite.com

This will allow you to have a local blockchain with 10 accounts that are powered with fake Ether.

I started the app and clicked Quick Start

We see the different accounts of our local blockchain.

# Construir una aplicación paso a paso y descentralizada (Ethereum Blockchain Dapp) en más de 128 palabras – Parte 2

Este artículo sigue el primer artículo sobre el tema: http://128mots.com/index.php/2020/03/30/construire-une-application-decentralisee-full-stack-pas-a-pas-ethereum-blockchain-dapp-en-plus-de-128-mots-partie-1/

Ejemplo de aplicación de votación descentralizada (Dapp)

El usuario de la aplicación descentralizada necesita un monedero que contenga éter. Como se indica en el primer artículo es posible crear fácilmente una cartera en https://metamask.io/.

Primero usaremos la red ropsten. Ropsten Ethereum, también conocido como el « Ethereum Testnet », es, como su nombre indica, una red de prueba que realiza el mismo protocolo que Ethereum y se utiliza para fines de prueba antes de implementar en la red principal (Mainnet). Website ropsten.etherscan.io

El uso nos permitirá crear y utilizar nuestra aplicación de forma gratuita antes de eventualmente transmitirla en la red principal de Ethereum.

Cuando el usuario se conecta a nuestra aplicación y a la red envía su voto y tiene que pagar algunas tarifas a través de su cartera con el fin de escribir su transacción en el Blockchain (llamado « Gas », este término se refiere a las tarifas para completar una transacción o ejecutar un contrato en la cadena de bloques Ethereum).

Arquitectura de aplicaciones Dapp

La arquitectura de la aplicación consta de un front-end que estará en HTML y Javascript. Este Frontend interactuará directamente con la cadena de bloques ethereum local que instalaremos.

Como se indica en el primer artículo, las reglas de negocio y la lógica se codificarán en un contrato inteligente. El Contrato Inteligente está escrito con el lenguaje de programación de solidez: https://solidity.readthedocs.io

Creación del Front-End

El front-end será simple que le permite mostrar el resultado de la votación para su canción favorita en forma de una lista y elegir de una lista desplegable la canción por la que desea votar.

Comprobar la instalación del nodo

`nodo -v`

Si el nodo no está instalado, puede consultar mi artículo sobre angular: http://128mots.com/index.php/2020/02/27/angular-en-plus-de-128-mots-partie-1/

Instalación del marco de la trufa: La trufa es un entorno de desarrollo, un marco de pruebas y una canalización de activos para Ethereum, con el objetivo de hacer su vida más fácil como desarrollador de Ethereum. Proporciona herramientas que nos permiten escribir contactos inteligentes con el lenguaje de programación Solidity.

También se utilizará para desarrollar el front-end de la aplicación.

`npm instalar -g trufa`

Instalación de Ganache:

Ganache es una cadena de bloques personal para el desarrollo de Ethereum que puede utilizar para implementar contratos, desarrollar sus aplicaciones y ejecutar pruebas.

Website www.trufflesuite.com

Esto le permitirá tener una cadena de bloques local con 10 cuentas que están alimentadas con éter falso.

Comencé la aplicación y hice clic en Inicio rápido

Vemos las diferentes cuentas de nuestra cadena de bloques local.

# Construire une application décentralisée full-stack pas à pas (Ethereum Blockchain Dapp) en plus de 128 mots – Partie 2

Cet article fait suite au premier article sur le sujet : https://128mots.com/index.php/2020/03/30/construire-une-application-decentralisee-full-stack-pas-a-pas-ethereum-blockchain-dapp-en-plus-de-128-mots-partie-1/

Exemple d’application décentralisée (Dapp) de vote

L’utilisateur de l’application décentralisée a besoin d’un portefeuille qui contient des Ether. Comme indiqué dans le premier article il est possible de se créer facilement un wallet sur Website metamask.io.

Dans un premier temps nous utiliserons le réseau ropsten. Ropsten Ethereum, également connu sous le nom de «Ethereum Testnet», est comme son nom l’indique, un réseau de test qui exécute le même protocole qu’Ethereum et est utilisé à des fins de test avant de se déployer sur le réseau principal (Mainnet). Website ropsten.etherscan.io

L’utilisation va nous permettre de créer et d’utiliser gratuitement notre application avant d’éventuellement la diffuser sur le réseau principal d’Ethereum.

Lorsque l’utilisateur se connecte à notre application et au réseau il envoie son vote et doit payer quelques frais via son portefeuille afin d’écrire sa transaction dans la Blockchain (Appelé « Gas », ce terme se réfère aux frais pour mener à bien une transaction ou exécuter un contrat sur la blockchain Ethereum).

Architecture de l’application Dapp

L’architecture de l’application se compose d’un front-end qui sera en HTML et Javascript. Ce Frontend dialoguera directement avec la blockchain ethereum local que nous installerons.

Comme indiqué dans le premier article les règles métier et la logique seront codées dans un Smart Contract. Le Smart Contract est rédigé avec le langage de programmation solidity : Website solidity.readthedocs.io

Création du Front-End

Le front-end sera simple il permet d’afficher le résultat du vote pour sa chanson préférée sous forme d’une liste et de choisir dans une liste déroulante la chanson pour laquelle on souhaite voter.

Vérifier l’installation de node

`node -v`

Si node n’est pas installé vous pouvez vous référer à mon article sur angular : https://128mots.com/index.php/2020/02/27/angular-en-plus-de-128-mots-partie-1/

Installation de Metamask : il s’agit d’installer https://metamask.io/ en tant qu’extension de votre navigateur

Installation du framework truffle : Truffle est un environnement de développement, un cadre de test et un pipeline d’actifs pour Ethereum, visant à vous faciliter la vie en tant que développeur Ethereum. Il fournit des outils qui nous permettent d’écrire des contacts intelligents avec le langage de programmation Solidity.

Il sera également utilisé pour développer le front-end de l’application.

`npm install -g truffle`

Installation de Ganache :

Ganache est une blockchain personnelle pour le développement Ethereum que vous pouvez utiliser pour déployer des contrats, développer vos applications et exécuter des tests.

Website www.trufflesuite.com

Cela va vous permettre d’avoir une blockchain locale avec 10 comptes qui sont alimenté avec des faux Ether.

J’ai démarré l’application et j’ai cliqué sur Quick Start

On voit s’afficher les différents comptes de notre blockchain locale.