Recompensas para desarrolladores

Hablamos hace tiempo de distintos sitios en los que podías aprender a programar mientras jugabas. Hoy vamos a ver algunos sitios en los que para gamificar el desarrollo con sus tecnologías, te dan recompensas físicas a ciertos logros. A veces son unas simples (pero muy chulas) pegatinas, y a veces son cacharros con los que podrás jugar mucho más.

devRant duck

Por internet puedes encontrar algún recopilatorio e incluso hay alguna comunidad centrada en la obtención de recompensas (como codecuriosity y mulesoft), pero no conozco ninguno que tenga los premios o recompensas que se pueden conseguir específicamente en España, ya que algunas empresas distinguen entre países. Vamos a verlas:

  • En Codeship puedes conseguir merchan por usar su plataforma de integración continua.
  • En devRant puedes conseguir pegatinas o una bola anti-estrés si alguno de los mensajes que dejes en su comunidad de developers tiene más de 20 o 500 positivos. Si no quieres compartir nada, siempre puedes comprar en su tienda ¡y tienen patitos!
  • En Digital Ocean te dan unas pegatinas muy chulas de su mascota, sólo por rellenar una encuesta.
  • En Google Assistant te dan una camiseta si lanzas una aplicación, y te regalan uno de sus cacharros si consigues muchos usuarios, o si tus usuarios son recurrentes, o si pones tu aplicación en al menos dos idiomas.
  • En Product Hunt, si montas un evento o un hackathon, te mandan merchan para los asistentes.
  • En Hurricane Electric te dan una camiseta si te certificas como que sabes de IPV6.
  • En Scaleway te mandan una camiseta por usar su plataforma cloud.
  • En Datadog te mandan una camiseta por probar su plataforma de monitorización y análisis.

Estas son las que tengo fichadas ¿conocéis alguna otra?

Desarrollo seguro: OWASP

Recientemente, he estado repasando los cursos que hay online, en universidades y en otras entidades sobre desarrollo seguro, viendo que casi todos se centran en OWASP (Open Web Application Segurity Project), lo cual está muy bien, pero se quedan en hablar del Top 10 de vulnerabilidades, y en realidad hay mucho más.
security photo

Está muy bien saber cómo se puede originar un fuego, pero es mucho más importante saber cómo actuar en cada caso o cómo se puede evitar que el fuego llegue a iniciarse ¿no? Con la seguridad en el desarrollo pasa lo mismo.

En el PDF que resume las vulnerabilidades, se pueden ver unos anexos con las responsabilidades de cada perfil (manager, developer y tester), y una pequeña guía para que una organización sea  segura. Esos anexos son muy importantes, puesto que nos ayudarán a ver si estamos haciendo las cosas bien o no.

Y bien, sabiendo los problemas que pueden surgir y la responsabilidad de cada uno para tener una empresa que practique desarrollo seguro ¿qué hacemos? Llegamos al que para mi es uno de los compendios más importantes que realiza este proyecto: OWASP Proactive Controls. En él se resumen las buenas prácticas que hay que realizar para funcionar de un modo seguro y evitar la mayoría de los incendios. Este es su propio Top 10:

  1. Verificar la seguridad pronto y a menudo
  2. Parametrizar las queries
  3. Codificar los datos
  4. Validar todas las entradas
  5. Implementar controles de autenticación y de identidad
  6. Implementar controles de acceso apropiados
  7. Proteger los datos
  8. Implementar logging y detección de intrusos
  9. Aprovechar frameworks y librerías de seguridad
  10. Manejo de errores y excepciones

¿Pones todos esos puntos en práctica? Sé que puede parecer difícil, pero profundizando un poco más, podréis ver que tienen también guías específicas de cómo hacerlo con cada tecnología, porque no es lo mismo estar haciendo una app para Android, que una web en PHP, y siguiéndolas podréis de un modo sencillo aseguraros de que estáis poniendo todo de vuestra parte para que vuestros desarrollos sean seguros.

Get to the point with Solidity

As I explained in my previous post about coding for Ethereum, there are a lot of ways to learn Solidity. However, most of them are really humdrum if you already know how to code, almost if you know javascript. So, let’s get to the point with Solidity looking the simplest structures you need to start coding.

ethereum photo

Solidity is based on javascript, but it also owns structures from other functional languages like Haskell and from object-oriented languages like Java. To do Dapps you need more than knowing the language because you need to know about patterns, security, how to compile and publish, and what actions cost more gas than others. Also, Solidity owns more reserved words than the explained below and more complex structures like inserting assembly inline, but with a little base of javascript and reading the following script (just 242 lines) you will be ready to start the backend of your very own distributed application over the Ethereum Virtual Machine.

pragma solidity ^0.4.19; //Version of the compiler

import "./otherContractsFile.sol";

contract ContractName { //Declaration of the basic unit of code
   /***Variables and funtions***/
   bool boolVariable;
   uint unsignedIntVariable;
   int intVariable;
   int intVariableWithValue = 10;
   uint16 unsigned16BitInt;
   uint256 unsignedIntVariable2;
   ufixed unsignedFixedVariable;
   fixed128x19 fixedVariableWith128bitsAnd19DecimalPoints;
   string stringVariable = "It can store any UTF-8 encoded string";
   address addressVariable; //addresses are used to store user accounts and contracts identifiers
   var aVariable = intVariableWithValue; //aVariable is defined as an int variable
   uint constant lustrum = 5 years;

   /*State variables are permanently stored in the EVM
    *between external function calls for this contract. 
    */
   uint stateVariable;

   function doSomething(uint uintParam) {
      /*Variables declared inside functions
       *are stored in memory and they are reset 
       *between different calls to the function.
       */
      uint functionVariable;
      
      functionVariable++;
      stateVariable = stateVariable + functionVariable;
      /*functionVariable = 1
       *stateVariable = 1 the first time this function is executed,
       *2 the second time this functions is executed, 3 the third, ...
       */
   }

   /***Collections and your own types***/
   uint[2] fixedArray;
   uint[] dynamicArray;
   mapping (address => uint) mapFromAddressToUint;

   enum EnumType {
      FirstValue,
      SecondValue,
      ThirdValue
   }

   struct StructType {
      uint uintField;
      string stringField;
   }
   StructType structVariable;
   StructType structVariableWithValue = StructType(10, "something");
   StructType[] structArray;

   function manageStructArrayByValue() {
      /*This variable is asigned by value (a copy is done)*/
      StructType memory myStruct = structArray[0]; 
      myStruct.uintField = 10; //structArray[0].uintField = 0;
   }

   function manageStructArrayByReference() {
      /*This variable is asigned by reference (a pointer is created)*/
      StructType storage myStruct = structArray[0]; 
      myStruct.uintField = 10; //structArray[0].uintField = 10;
   }

   uint[] public publicArray; //A public array is read-only publicly accessible by other contracts
   mapping (uint => string) public publicMap;

   function workWithArrays() private {
      uint[] myArray;
      myArray.push(1); //myArray = [1]
      myArray.push(2); //myArray = [1,2]
      uint newLenth = myArray.push(1); //newLenth = 3, myArray = [1,2,1] 
   }

   /*Functions are public by default, so you need to set them private
    *in order to keep your contract secure. In other case, functions
    *can be called (and executed) by other contracts.
    */
   function doSomethingPrivate(uint uintParam) private {
      //some code
   }

   /*Internal functions are functions that can be called from
    *contracts that inherit from this one.
    */
   function doSomethingInternal(uint uintParam) internal {
       //some code
   }

   /*Public functions can be called from anywhere.*/
   function do(uint param) public {
      //some code
      doSomethingPrivate(param);
      doSomethingInternal(unsignedIntVariable);
      doSomethingPrivate(10); //Can't call to doSomethingExternal
   }

   /*External functions can be called from external contracts
    *but not from inside this contract.
    */
   function doSomethingExternal(uint param) external {
      //some code
   }

   function ContractName() public { //this is a constructor but be carefull using them, they are not executed in some special cases
      //do something
   }

   function return10() returns (uint) {
      return 10;
   }

   function returnMultipleValues() returns (uint value1, uint value2) {
      value1 = 10;
      value2 = 20;
   }

   function returnMultipleValues2() returns (uint, uint) {
      return(10, 20);
   }

   function useMultipleValues() {
      uint value1;
      uint value2;
      (value1, value2) = returnMultipleValues();

      uint value4;
      (,value4) = returnMultpleValues2();
   }

   /*function throwsAnError(int a) private returns (int8) {
    *   return a + 1;
    *}
    */

   function addAndConvert(int a) private returns (int8) {
      return int8(a) + 1; //uses the 8 less significant bits of a
   }

   function addAndConvertIfIsInt8(uint a) private returns (uint8) {
      require(a <= 2 ** 8); //Throws an error if false
      return uint8(a) + 1;
   }

   /***Events***/
   event sthOccurred(uint param);

   function throwEvent() private {
      sthOcurred(10);
   }

   /***Modifiers***/
   //"view" can be used to identify functions that are not changing any data
   function returnInt() public view returns (int) {
      return intVariable;
   }

   //"pure" can be used to identify functions that do not access any data in the contract
   function add(int a, int b) public pure returns (int) {
      return a + b;
   }

   //"payable" is needed in order to receive Ether with a call
   function aFunctionThatCost() public payable {
      //this contract will own the ether sended at the end of the execution
   }

   modifier myModifier() {
      //some code to be executed before the function
      _; //this is a placeholder that indicates the point where the code of the function will be executed
      //some code to be executed after the function
   }

   function functionWithModifier() public myModifier {
      //some code to be executed in the place where the placeholder is set inside modifier's code
   }

   function otherFunctionsAndValues() private {
      keccak256("qwerty"); //returns a 256-bit hexadecimal with a SHA3 hash of the param
      //"qwerty" == "QWERTY"; Solidity can't compare strings. Instead you can do
      keccak256("qwerty") != keccak256("QWERTY");

      uint currentUnixTimestamp = now;
      1 minutes == 60;
      1 hours == 3600;
      //you also have available "days", "weeks" and "years" units

      address currentBlocMiner = block.coinbase;
      uint currentBlockDifficulty = block.difficulty;
      uint currentBlockGasLimit = block.gaslimit;
      uint currentBlockNumber = block.number; 
      uint currentBlockUnixTimestamp = block.timestamp;
      bytes32 theHash = block.blockhash(block.number); //only works for 256 most recent blocks excluding current
      bytes completeCallData = msg.data;
      uint remainingGas = msg.gas;
      address callerWhoInitiatesThisExecution = msg.sender;
      bytes4 firstFourBytesOfMsgData = msg.sig;
      uint numberOfWei = msg.value;
      uint gasPriceOfTheTransaction = tx.gasprice;
      uint senderOfTheTransaction = tx.origin;

      assert(1==2); //like require but for internal errors
      revert(); //abort and revert changes
   }

}

/***Inheritance and rehusability***/
contract A {
   function aFunction {}
}

contract B is A {
   function bFunction {
      aFunction();
   }
}

/*If you want to use an external contract, you need to define an
 *interface with the definition of the methods that you want to
 *use.
 */
contract InterfaceOfExternalContract {
   function functionExternalDefinition(uint param) external return (uint);

   function functionPublicDefinition(uint param) public return (uint);
}

contract ContractWichUsesTheExternalContract {
   address externalContractAddress = 0x...;
   InterfaceOfExternalContract externalContract = InterfaceOfExternalContract(externalContractAddress);

   function aFunction() {
      uint value = externalContract.functionExternalDefinition(1);
   }
}

And now, what are you starting to code?

Como empezar a programar apps distribuidas en Solidity para Ethereum

Podría parecer que para programar Dapps, las aplicaciones que corren sobre la máquina virtual de Ethereum, es necesario ser un experto en blockchain, saber de criptografía, entender cómo se calculan los hash de los bloques, entender cómo está implementado el Proof of Work, o incluso saber cómo se mina. Sin embargo, no hace falta profundizar tanto para echar a andar una aplicación distribuida, veamos por dónde se puede empezar.

learn photo

Para desarrollar Dapps, basta con conocer cómo funciona la Ethereum Virutal Machine, conocer las arquitecturas y patrones que se emplean y manejarse con alguno de los lenguajes pensados para tal fin. El más popular es Solidity, que está basado en javascript, aunque hay otros como LLL (que está basado en Lisp) o Serpent (basado en Python).

Para aprender a programar con Solidity se puede empezar por muchos sitios. Puedes empezar a dar vueltas por el Wiki de Ethereum, o ir directamente a la documentación oficial, aunque personalmente creo que es un poco tediosa y no va demasiado al grano. Otra opción es buscar un buen tutorial en el que te enseñen paso a paso, como Cryptozombies que te enseña a hacer desde cero un juego como el popular Cryptokitties.

Para aprender el lenguaje cualquiera de esas vías es válida. Sin embargo,  por desgracia, creo que es necesario pasar por todas esas documentaciones para tener conocimiento de los patrones más habituales y estar preparado para hacer cualquier tipo de aplicación, ya que si por ejemplo te quedas en ver cómo está hecho Cryptokitties, sólo conocerás aquellos que sirven para hacer un sistema de compraventa de bienes únicos.

Es cierto que esto puede llevar mucho tiempo, y si tienes prisa por empezar a programar, puedes buscar un curso para que alguien te guíe y te dé información concisa y bien estructurada. Recientemente he empezado a colaborar con DevAcademy, una academia que ofrece cursos de alto nivel para las tecnologías más punteras (DevOps, Machine Learning, Big Data, …) y, cómo no, entre ellos tiene un curso de Solidity. Es una buena alternativa para que te lo den todo mascado, y además, le puedes pedir a tu empresa que te lo pague ya que le saldrá gratis por ser formación bonificada. Si quieres saber más sobre este u otro de sus cursos, no dudes en ponerte en contacto conmigo y que podamos ver tus necesidades o las de tu empresa.

Minado de Ether: ¿Qué es? ¿Cómo se hace? ¿Es rentable?

Estamos viviendo un boom (o burbuja) de las cryptomonedas comparable a la de la fiebre del oro. Tiene algunas similitudes, ya que cualquiera se puede poner a minar y conseguir cryptomonedas “gratis”. Veremos todos los detalles de esta práctica centrándonos en conseguir Ether, la cryptomoneda de Ethereum.

Ethereum es una plataforma que utiliza una arquitectura blockchain. En estas, como ya explicamos cuando hablamos de cryptojacking y de las diferencias entre Prueba de trabajo y Prueba de confianza (o interés), cada bloque guarda el hash del anterior como identificador único, y que al estar encadenados todos los bloques sea, en la práctica, imposible alterar los datos pasados. Para obtener ese hash hay que realizar muchos cálculos, por eso al propietario de la máquina que consigue obtenerlo en primer lugar, la plataforma le da una recompensa (actualmente 5 ETH).

Por tanto, es fácil, si tu quieres obtener Ether sin aflojar la cartera, tan sólo tienes que convertirte en minero poniendo tu ordenador a trabajar por ti. ¡Fa-ci-lí-si-mo!

Veamos, ¿cómo podemos poner a nuestro equipo a trabajar en ello?

Lo primero es obtener geth (Go Ethereum). Es la consola/aplicación de consola oficial. Si tienes instalado el Wallet de Ethereum o Mist, ya la tendrás instalada y configurada, ya que es por ejemplo la encargada de sincronizar tu sistema con toda la red de Ethereum para que tengas los mismos bloques que el resto.

Una vez montado sólo tienes que ejecutar el siguiente comando:


geth --etherbase '0xHashDeTuWallet' --mine

Ten en cuenta que si ya tenías geth configurado por tener el Wallet, te bastará solo con usar el argumento “–mine” porque ya tendrás establecido tu coinbase.

Otra opción que tienes es iniciarlo en modo consola y luego arrancar el miner:


geth console
...
>miner.start()

Yo prefiero esta modalidad ya que nos permite consultar nuestro hashrate y la dificultad de lo que ha costado conseguir el último bloque, con lo que podremos echar una estimación de cuanto tiempo tardaremos (estadísticamente) en conseguir cerrar uno de los bloques y llevarnos nosotros la recompensa:

Comprobación de tiempo para obtener un hash
Comprobación de tiempo para obtener un hash

Como se puede comprobar en la imagen, en mi máquina se tardarían más de 87.000 días en obtener un hash.

¿Está eso bien? ¿Qué ocurre aquí?

El comando geth no está preparado para usar GPUs, por lo que usa la CPU y por mucho que mi máquina sea un maquinón, mis 8 cores no están a la altura de ninguna GPU.

Para solucionarlo hay dos opciones sencillas: una es usar una implementación en C++ de la definición de Ethereum, la cual sí está preparada para usar GPUs pero que oficialmente no ha sido lanzada; la otra opción (y mi preferida por seguir usando el software verificado) es usar otra aplicación para las operaciones que se conecte a geth para que se encargue del resto.

Para esta última opción hay que poner a geth a escuchar:

geth --rpc --rpccorsdomain localhost

Y luego arrancar ethminer con la opción que queramos:

  • G usa las tarjetas que estén habilitadas para funcionar con OpenCL.

  • U usa las tarjetas que estén habilitadas para funcionar con CUDA.

  • X usa todas las tarjetas.

No vamos a entrar en grandes detalles, pero os contaré que en mi caso tengo dos tarjetas. La NVIDIA dedicada es CUDA y la Intel que usa memoria compartida es OpenCL. Podría parecer que lo mejor es usar la opción “-X” y poner todas a funcionar, pero es un error ya que los recursos del sistema son limitados y entonces se pelearán por ellos… este es un caso de en los que menos es más.

En mi equipo usando una tarjeta dedicada con 4GB se obtiene que estadísticamente tardaría aproximádamente 1500 días en obtener esos 5ETH. Seguro que algún ludópata ya está echando las cuentas, pero la verdad es que con el cambio de 626€ actual, esto supone que se estarían ganando unos 2€ al día. No está mal sin hacer nada ¿verdad? Pero hay que contar que el consumo eléctrico de la máquina (en mi caso) se duplica, que probablemente dentro de 1500 días no se pueda minar con la máquina que estés minando hoy, o que puede que 1ETH dentro de 4 años valga mucho más o mucho menos… Echad vuestras propias cuentas y decidid si vais a jugar o no, porque esto es una lotería y aunque puede que tengáis suerte, las probabilidades están en vuestra contra.

¿No hay ninguna opción de empezar a ganar dinero desde ya?

Sí, claro que la hay. Te puedes unir a un pool que en cierto modo te paga por cada hash prometedor que le mandas independientemente de que sea exitoso o no. Es como si repartiese las ganancias que se generan entre todos los que están trabajando con él.

Podéis estudiar que pool os da más. Yo usé ethermine.org y ponerlo en marcha es muy sencillo. Sólo tenéis que bajaros un programa, modificar el start.bat para establecer el servidor que os quede más cerca y vuestra cartera y echarlo a andar:

setx GPU_FORCE_64BIT_PTR 0
setx GPU_MAX_HEAP_SIZE 100
setx GPU_USE_SYNC_OBJECTS 1
setx GPU_MAX_ALLOC_PERCENT 100
setx GPU_SINGLE_ALLOC_PERCENT 100
EthDcrMiner64.exe -epool eu1.ethermine.org:4444 -ewal 0x4bf644b03a83a4e3f5534f81a3dd1e8b28b32076.Rig001 -epsw x

Mi primera experiencia con esto fue que tras tres horas había conseguido ganar 0.00026ETH que al cambio del momento eran unos 0.10€. Habrá quien diga que el valor en euros no vale, ya que mientras escribo estas líneas esa misma cantidad de Ether vale aproximadamente 0.16€, pero podemos verlo de otro modo: cuando pasé Ether que había comprado en Coinbase a mi cartera, el fee de la transacción fue de casi el doble de lo que saqué minando durante 3 horas.

Esto es lo que pasa con el Ether, pero con Bitcoin y otras cryptomonedas populares pasa más de lo mismo. Cada uno puede sacar sus propias conclusiones y sus propias cuentas, pero creo que a día de hoy, por mucha burbuja que haya, no vale la pena ponerse a minar cryptomoneda, a no ser que salga una nueva y os aventuréis a ser uno de los primeros mineros igual que aquellos que corrían de un lado a otro de California buscando la próxima veta.

Gmail Add-ons: How-to be on all desktops and mobiles with a simple app

Some weeks ago, Google opened the possibility of create Gmail add-ons for all developers. Let’s see what are the possibilities and how to create and distribute our own Gmail add-on.

This is not a very hard and abstract post, add-ons are something easy, so I hope my explanation to be simple too. It is based on an add-on created by myself that allows any user adding an email to Google Tasks (probably it is more useful than the add-on for MSN Messenger that I created years ago which read received messages with “real” voice). It is a functionality that has been always present on Gmail web client but that is not available on mobile clients.

In order to create a Gmail add-on you need to create a new Google Apps Script project. After that you can add as much scripts as you want to create an interface using Cards and the functionality to interact with other services, APIs and so.

For instance, in our example the functionality is very basic:



function getContextualAddOn(e) {
  var message = getMessage(e);
  var subject = message.getSubject();
  var permaLink = message.getThread().getPermalink();
  
  var card = CardService.newCardBuilder();
  card.setHeader(CardService.newCardHeader()
                 .setTitle('Save as task'));
  var section = CardService.newCardSection();
  
  var button = prepareSend(permaLink);
  section.addWidget(button);
  
  section.addWidget(prepareList());
  
  section.addWidget(prepareTitle(subject));
  
  section.addWidget(prepareDueDate());
  
  section.addWidget(button);
  
  section.addWidget(prepareSign());
  
  card.addSection(section);
  console.log("Open");
  return [card.build()];
}

function getMessage(e){
  var accessToken = e.messageMetadata.accessToken;
  GmailApp.setCurrentMessageAccessToken(accessToken);
  
  var messageId = e.messageMetadata.messageId;
  return GmailApp.getMessageById(messageId);
}

function prepareSend(permaLink){
   var action = CardService.newAction()
  .setFunctionName("saveTask")
  .setParameters({permaLink: permaLink});
  return CardService.newTextButton()
                    .setText("Save")
                    .setOnClickAction(action);
}

function saveTask(e){
  var res = e['formInput'];
  var task = Tasks.newTask();
  task.title = res["title"];
  task.notes = e['parameters'].permaLink;
  
  if(res["due-date"] &amp;&amp; res["due-date"] != "")
    task.due = res["due-date"] + "T00:00:00Z"
  
  task = Tasks.Tasks.insert(task, res["list"]);
  console.log("Saved");
}

function prepareList() {
  var response = Tasks.Tasklists.list();
  var taskLists = response.items;
  var dropdown = CardService.newSelectionInput()
     .setType(CardService.SelectionInputType.DROPDOWN)
     .setTitle("List")
     .setFieldName("list");

  if (taskLists &amp;&amp; taskLists.length &gt; 0) {
    Logger.log('Task lists:');
    for (var i = 0; i &lt; taskLists.length; i++) {
      var taskList = taskLists[i];
      Logger.log('%s (%s)', taskList.title, taskList.id);
      dropdown.addItem(taskList.title, taskList.id, i==0);
    }
  } else {
    Logger.log('No task lists found.');
  }
  return dropdown;
}

function prepareTitle(subject){
  return CardService.newTextInput()
                    .setFieldName("title")
                    .setTitle("Title")
                    .setValue(subject)
}

function prepareDueDate(){
  var d = new Date();
  var dd = new Date(d.setDate(d.getDate() + ( 7 - d.getDay()) % 7));
  return CardService.newTextInput()
                    .setFieldName("due-date")
                    .setTitle("Due date")
                    .setValue(dd.getYear() + "-" + (dd.getMonth() + 1) + "-" + dd.getDate())
                    .setHint("YYYY-MM-DD");
}

function prepareSign(){
  var button = CardService.newTextButton()
     .setText("@JaviLopezG")
     .setOpenLink(CardService.newOpenLink()
         .setUrl("https://javilopezg.com/")
         .setOpenAs(CardService.OpenAs.OVERLAY)
         .setOnClose(CardService.OnClose.RELOAD_ADD_ON));
  return CardService.newKeyValue()
     .setContent("Developed and maintained by")
  .setButton(button);
}

You also have to change script’s manifest. To do this you need to access to the menu “View>Show manifest file”. Now you can modify it as you want, following our example you have to replace the content with following lines:

{
  "timeZone": "GMT",
  "dependencies": {
    "enabledAdvancedServices": [{
      "userSymbol": "Tasks",
      "serviceId": "tasks",
      "version": "v1"
    }]
  },
  "oauthScopes": ["https://www.googleapis.com/auth/gmail.addons.execute", "https://www.googleapis.com/auth/gmail.addons.current.message.readonly", "https://www.googleapis.com/auth/tasks"],
  "gmail": {
    "name": "Save as task",
    "logoUrl": "https://i0.wp.com/javilopezg.com/wp-content/uploads/2017/11/save-as-tag-ico-24.png",
    "contextualTriggers": [{
      "unconditional": {
      },
      "onTriggerFunction": "getContextualAddOn"
    }],
    "primaryColor": "#000000",
    "secondaryColor": "#888888",
    "version": "TRUSTED_TESTER_V2",
    "openLinkUrlPrefixes": [
      "https://javilopezg.com/"
    ]
  }
}

As soon as you save all changes you are ready to publish your add-on. Unfortunately the Gmail add-ons store is not publicly available yet. However, you can get the ID of your add-on and distribute it to your company co-workers in order to allow them install your add on in their gmail accounts. See images below:

Gmail Add-on ID
Gmail Add-on ID
Add-ons in Gmail settings
Add-ons in Gmail settings

I know that it’s frustrating not being able to publish an add-on to all gmail users around the world yet. Anyway, I already have two cool ideas to implement as soon as I was able to distribute it at least to my friends. Something to draw an ordered tree of a conversation thread and an add-on to respond an e-mail with a video in an easy way. And you? What ideas are coming to your head?

PoW vs PoS

Cuando hablamos del Cryptojacking y de la minería, pasamos de puntillas un concepto que afecta a como se valida cada uno de los bloques de un blockchain. Es la “prueba“, y aunque en la mayoría de blockchains se usa Proof of Work, son muchos los expertos que apuntan a la necesidad de pasar a blockchains que usen Proof of Stake. Veamos en que se diferencian y el porqué de la necesidad de este cambio.

military byzantine photo
Photo by Internet Archive Book Images

Aunque inicialmente pueda parecer algo super técnico, como habéis ido viendo en otros posts relacionados con el tema, los blockchains son sistemas realmente básicos, aunque se tiene que enfrentar a los problemas típicos de los sistemas distribuidos que ya vimos cuando tratamos los patrones cloud.

En concreto, estas pruebas son soluciones al problema de consenso que normalmente se ejemplifica con el problema de los generales bizantinos. En este problema se busca la coordinación de varios jefes militares que intentan atacar o retirarse de un modo conjunto. Su aplicación mediante estas “pruebas” a los blockchains, sirve para la toma de decisiones en un entorno distribuido como este.

La prueba de trabajo (Proof of Work), se basa en el cálculo de un hash que “cierre” el bloque. Por tanto, el sistema que encuentra el hash valido es el que tiene la última palabra en cuanto a las operaciones registradas en dicho bloque.

Pongamos que hay un blockchain en el que participan Alberto, Braulio, Carlos, Diego y Esteban. Cada uno le manda al siguiente en la lista una moneda, pero Carlos no se ha enterado de que Esteban le ha mandado una moneda a Alberto. A la hora de minar, todos se ponen a buscar un hash de un bloque que almacenará 5 operaciones, menos Carlos que sólo ha recibido información de 4. Si el primero en lograr su trabajo es Diego, el hash que encuentre será de las 5 operaciones y por tanto las 5 quedarán confirmadas. Por el contrario, si quien logra dicha labor es Carlos, sólo 4 operaciones quedarán confirmadas y el envío de Esteban a Alberto deberá volver a realizarse.

En este tipo de pruebas toma la decisión el primero que consigue realizar un trabajo más o menos complejo como es el cálculo de ese hash.

La prueba de participación (Proof of Stake), se basa en la participación de los distintos componentes en el sistema. Depende del blockchain se tienen unas normas u otras (aunque podéis entrar en detalle en como será Ethereum cuando pase a PoS), pero en general se presupone que los elementos más partícipes (porque tengan más dinero, hagan más operaciones, etc.) son los principales interesados en que todo funcione correctamente y se haga del modo más limpio. Por tanto, estos se convierten en validadores que pueden recibir el “honor” de dar por bueno un bloque ya sea de manera aleatoria, rotativa, por votación…

De nuevo pensemos en un blockchain, pero en este participan Alba, Barbara, Carla, Diana y Ester. Cada una tiene el doble de monedas que la anterior en este blockchain, que está “gobernado” por un PoS en el que determina el bloque quien más dinero tenga. Si en cada transacción cada una le envía a la anterior la mitad de sus monedas, el primer bloque lo decidirá Ester, pero el segundo lo decidirá Diana por ser la nueva mayor participante. Por tanto, primero Ester y después Diana serán quienes decidan que operaciones quedan confirmadas, asumiéndose que al ser las mayores poseedoras de esta criptomoneda, son también las principales interesadas en que funcione bien y sea un sistema de fiar.

Aunque los dos tipos de prueba tienen sus cosas buenas y malas, hay una en la que PoS gana de calle a PoW y que nadie podrá rebatir. Es el consumo de electricidad gastado para realizar estos trabajos. Con cada bloque de la cadena todos los mineros se ponen a buscar el hash que toque, pero sólo uno lo consigue, por lo que todo el tiempo de cálculo anterior ha sido completamente inútil para todos menos uno. Por ejemplo, si atendemos a los Bitcoins, el consumo energético de este blockchain es similar al de Nigeria, o la electricidad que se emplea para una sola transacción de Bitcoin serviría para proveer a una casa durante un mes.

Espero haberos explicado de un modo suficientemente claro estos conceptos y el porqué de este debate, como para que podáis entrar en él. ¿Hay algún concepto que creáis que es importante aclarar?