DEV Community: Gustavo Preciado

Digest of Papers: Bitcoin: A Peer-to-Peer Electronic Cash System

Gustavo Preciado — Sat, 02 May 2020 20:30:47 +0000

Bitcoin is the most popular blockchain implementation and its whitepaper written by the anonymous Satoshi Nakamoto was one of the first papers that divided and explained each element required for blockchain implementation. The purpose of this paper was to eliminate the necessity of having a trusted third party entity, like banks, as the only way to avoid the double-spending problem in money transactions.

Transactions

Blocks in Bitcoin are data structures designed to store all the information about money transactions between users, so each time that one user sends one coin to other its create a transaction that includes an electronic signature composed by the previous transaction hash and the public key of the new owner, this signature allows the receiver to validate that the transactions were for him, but he cannot validate the previous owner didn't send the same coin to another user. Additionally, transactions can have multiple inputs and outputs to split and combine coins into groups.

Proof of Work

PoW is a computational challenge consist of finding a certain value that can be added to the next block and after applying a hash function, like SHA-256, it returns a specific amount of zeros at the begging. The computing capacity required by this challenge is the shield against attackers who want to add corrupted blocks because they will need to have the 51% total capacity of the network to produce the accepted next block due to the consensus algorithm make each node to prefer the largest chain so you have to be the first in resolve the PoW.

In order to works in the long term, the PoW has to increase the difficulty to match the increment in components capacity so the network is constantly changing the challenge by requiring more and more zeros.

Of course, none of the network's nodes want to put this capacity for free so there is a transaction fee that is paid to the one who solves the challenge, and also the generation of a new block creates new coins that are inserted into the network via the solver this inflation of the coin its expect to be unnecessary in the future and the reward will be only the transaction fee.

Network

Each new transaction is added to the blockchain and spread around the network in 6 steps:
The transaction is broadcast to all nodes.
Each node group new transactions in one block.
Each node start working in the PoW.
One node solves the PoW and broadcast the new block.
All nodes accept the largest chain of new blocks that pass the PoW.
Each node adds the new blocks to the chain and starts working in the next.

Merkle Tree

With the accumulative history of transactions, the whole chain can require a lot of disk space in the nodes so a Merkle tree is used as the data structure of this history because it allows the nodes to order the hashes in a way that it is easy to delete the oldest transactions of a coin without breaking the operation.

Privacy

Each transaction in the network is public so everyone knows where the coins are, but the only data available is the value that is being transferred and the public key of the receiver so you can't know who this is person or entity is.

Repasando Artículos: Blockchain Technology: Beyond Bitcoin

Gustavo Preciado — Fri, 31 May 2019 05:09:41 +0000

Crosby (Google), Nachiappan (Yahoo), Pattanayak (Yahoo), Verma (Samsung Research America), Kalyanaraman (Fairchild Semiconductor) 2016

Blockchain es una tecnología que ha incrementado ampliamente su popularidad en los últimos años debido a que busca resolver los problemas de seguridad, confianza y privacidad de múltiples modelos de negocio que involucran el intercambio de bienes o servicios entre dos usuarios. Actualmente estos problemas son resueltos por un tercero que hace de intermediario y quien obtiene una ganancia por ayudar a llegar a un consenso entre los involucrados, sin embargo estos terceros no siempre garantizan la solución de los problemas de seguridad, el nivel deseado de privacidad o no ofrecen la transparencia necesaria para crear confianza en todos los involucrados.

Para explicar el funcionamiento de Blockchain el articulo se basa principalmente en la implementación realizada por el proyecto Bitcoin acompañado de Etherum que busca resolver de una forma mas general los problemas mencionados con el uso de los llamados "Smart Contracts" que permiten ejecutar acciones especificas al cumplir un grupo de condiciones acordadas por las partes involucradas. Posteriormente lista algunas de las aplicaciones que se están llevando acabo actualmente dividas en financieras y no financieras y por ultimo expone algunos de los riesgos que conlleva la adopción de estas tecnologías.

Ya realice una explicación del funcionamiento de Bitcoin aquí por lo cual lo omitiré de este repaso

Aplicaciones Financieras

NASDAQ private equity: NASDAQ en conjunto con la startup chain.com lanzaron una plataforma privada de intercambio de "acciones", legalmente es equity, en una fase previa a la salida a la bolsa de las compañías que no requiere de la intervención de los bancos.
- Augur: Es una aplicación que permite vender acciones de forma anticipada a un evento que puede afectar el mercado sin la necesidad de cobrar comisiones altas o depender de brokers centralizados, adicionalmente el pago se hace a través de Etherum.
- Everledger: Una compañía que utiliza blockchain para hacer seguimiento de las características y el historial de propietarios que ha tenido cada diamante.

Aplicaciones no financieras

La certificación de documentos para diferentes efectos legales también esta siendo ampliamente impactada por las tecnologías de Blockchain, algunas de las empresas que están trabajando en prestar este tipo de servicios son:

Otras aplicaciones mencionadas en el articulo cubren diferentes campos como los derechos de autor que enfrentan crecientes problemas debido al aumento de las plataformas de streaming, sistemas que permitan controlar las falsificaciones en las cadenas de suministros, la necesidad de conectar múltiples dispositivos en una red independiente en redes cada vez mas grandes de IoT(Internet of Things) o el mantenimiento de registros como los DNS sin la necesidad de gobiernos o grandes compañías como intermediaros.

Riesgos de Adopción

Resistencia al cambio: Blockchain conlleva un cambio de paradigma en la forma en la que se realizan transacciones entre dos partes y esto puede generar resistencia por parte las grandes corporaciones dedicadas a resolver los problemas de confianza y privacidad como VISA y Mastercard, en el caso de las tarjetas de credito, e incluso por parte de los mismos usuarios.
Escalabilidad: Con el paso del tiempo la cantidad de bloques crece y realizar una sola transacción puede resultar costoso a pesar del uso de herramientas como Merkle Tree en el caso de Bitcoin.
Costos de Migración de datos: La aplicación de Blockchain en algunos de los campos mencionados incluye largos procesos de ETL como la migración de los contratos y documentos actuales en negocios como la propiedad raíz.
Regulaciones: Actualmente no hay regulaciones para estas redes P2P por parte de los gobiernos y estos podrían poner trabas para su adopción.
Actividades Fraudulentas: Si bien los usuarios suelen preocuparse por su privacidad por cuestiones personales o de seguridad también hay otro grupo de personas interesadas en mantener el anonimato para realizar actos ilegales.
Computación Quántica: Gran parte de la seguridad de las redes basadas en Blockchain recae en la dificultad matemática de resolver puzzles criptográficos, pero con la llegada de la computación quántica puede que los algoritmos actuales no sean suficientemente costos a nivel de hardware para asegurar que una parte de los involucrados logre engañar el sistema a su favor.

Repasando Artículos: Bitcoin: A Peer-to-Peer Electronic Cash System

Gustavo Preciado — Mon, 04 Feb 2019 04:14:10 +0000

Satoshi Nakamoto

Bitcoin es la implementación mas reconocida de blockchain y el whitepaper escrito por el autor anónimo Satoshi Nakamoto fue uno de los primeros en listar y describir todos los elementos que componen una implementación de blockchain, la principal intención de este articulo era proponer una moneda electrónica que eliminara la necesidad de tener un tercero de confianza como intermediario de todas las transacciones como único método para evitar el problema de doble gasto.

Transacciones

Los bloques de bitcoin son una estructura de datos diseñada para almacenar las transacciones de dinero entre usuarios de la red para ello cada que un usuario desea transferir una moneda a otro crea una "Transacción" que lleva una firma electrónica compuesta del hash de la transacción anterior de la moneda unido a la llave publica del usuario que recibirá la transferencia; con esta firma el nuevo dueño de la moneda puede verificar que le han hecho a él la transferencia sin embargo no puede comprobar que el dueño anterior no haya realizado la misma transferencia a otro, esto es lo que se conoce como doble-gasto(double-spending problem). Adicionalmente las transacciones se componen de múltiples entradas y múltiples salidas para permitir combinar y separar grupos de monedas y que no sea necesario manejarlas individualmente.

Proof of Work

La prueba de trabajo consiste en buscar un valor tal que al unirlo con un grupo el siguiente grupo de transacciones, o bloque, y aplicar una función de hash, como SHA-256, da como resultado un numero especifico de ceros al inicio del hash. El trabajo de computación necesario para hallar este valor sirve para garantizar que un atacante no pueda crear un bloque con transacciones corruptas sin tener por lo menos el 51% de la capacidad de computación de toda la red y a su vez sirve como argumento para que en el algoritmo de consenso los nodos siempre elijan la cadena de bloques mas larga en caso de recibir diferentes cadenas desde diferentes nodos.

Adicionalmente para controlar el aumento en la capacidad de los componentes de computación la red se encuentra constantemente incrementando el numero de ceros requeridos para aumentar la dificultad y de esta forma exigir aun mas capacidad de computación.

Este costo computacional de crear cada bloque nuevo también esta ligado a la creación de nuevas monedas añadidas a la red, dando incentivos a aquellos que logran resolver el desafió a través de la inmersión de nuevas monedas y del cobro de una cuota por "honorarios" al valor de la transacción. Se espera que llegue un punto donde los honorarios sean suficientes para cubrir los gastos de prestar este poder de computación a la red.

Network

Cada que se realiza una nueva transacción esta es transmitida y añadida a la cadena de bloque siguiendo 6 pasos:

La transacción es emitida a todos los nodos
Cada nodo agrupa las nuevas transacciones en un bloque
Cada nodo trata de encontrar el valor que satisfaga la prueba de trabajo
Cuando un nodo supera la prueba de trabajo emite el nuevo bloque a toda la red
Los nodos aceptan los bloques siempre y cuando todas las transacciones sean validas y los bloques cumplan la prueba de trabajo
Los nodos añaden el bloque que aceptaron y pasan a trabajar en el siguiente

Merkle Tree

Con el paso del tiempo la cantidad de transacciones dentro de la red podrían llegar a ocupar demasiado espacio en disco si se mantiene todo el historial desde el inicio de la red, por esta razón se utiliza un Merkle Tree como estructura de datos para ordenar los hashes de las diferentes transacciones dentro de un bloque, de este modo cuando hay suficientes transacciones sobre una moneda las mas viejas pueden ser eliminadas del árbol sin afectar la cadena de bloques manteniendo únicamente la raíz del bloque.

Privacy

Dentro de la red todas las transacciones son publicas sin embargo lo único que puede observarse en ellas es la cantidad de valor que se esta transfiriendo y la llave publica de aquel que recibe este valor sin embargo la identidad de las personas detrás de estas transacciones permanece oculta.

Digest of Papers: Monads For Functional Programming

Gustavo Preciado — Sat, 22 Dec 2018 00:01:48 +0000

Wadler, Philip , 2001
Read this post in spanish

Monads are one of the many concepts shared between mathematics and functional programming. It comes from categories theory to solve problems like exceptions control , counters or execution traces. This problems are easy to attack in imperatives languages but in the pure ones it can be a little complicated.

Pure functional languages have this advantage: all flow of data is made explicit. And this disadvantage: sometimes it is painfully explicit.

The paper explain how this explicit data flow improve the modularity and the importance of this feature in programming.

A monad, also called standard construction, is a data structure that encapsulate behaviors. This behaviors are commonly implements as side effects in imperative programming. A key example to understand monads is the Try value in Scala or VAVR(functional data structures for JAVA) that encapsulate exceptions. This value can be used to compose functions without explicit management of each possible error until the final apply.


public static Try<Integer> divide(Integer dividend, Integer divider) {
      return Try.of(() -> dividend/divider);
  }

  public static void main(String[] args) {
      Try<Integer> result = divide(100, 0).flatMap(r1 -> divide(r1, 10));
      System.out.println("RESULT 1 = " + resultado.map(String::valueOf)
       .getOrElseGet(Throwable::getMessage));
       // RESULT 1 = / by zero

      result = divide(100, 10).flatMap(r1 -> divide(r1, 10));
      System.out.println("RESULT 2 = " + resultado.map(String::valueOf)
       .getOrElseGet(Throwable::getMessage));
       // RESULT 2 = 1

  }

Monads Laws

The formal definition of monad include 3 laws to determine if the structure is a monad. This laws maybe have more theoric than practical value, but this blog is about the paper :P so I will try to explain the principles.

Left Unit/Left Identity

This law said that apply a function to a value and apply it to monad with the same value inside should be equal, if you use the correct composition(map or flatMap according to the return of the function).


  public static void main(String[] args) {
      Integer hundred = 100;
      Try<Integer> tryHundred = Try.of(() -> hundred);
      Boolean r = tryHundred.flatMap(value -> divide(100, value))
      .equals(divide(100, hundred));
      // True
  }

  return a >>= f = f

Right Unit/Right Identity

Like the previous law if we have a function that receive a value and encapsulate the result in a monad the result of applies it to the value or composes it with another monad function should be the same.


  public static void main(String[] args) {
      Integer hundred = 100;
      Try<Integer> tryHundred = Try.of(() -> hundred);
      // success return the same value encapsulated in a Try but cannot catch exceptions
      Boolean r = tryHundred.flatMap(value -> Try.success(value))
      .equals(Try.success(hundred));// True
  }

  m >>= return = m

This examples in JAVA appear to have the same implementation, but the difference between both laws is more evident in Haskell. Like I said this laws are theoric and Haskell is pure functional and more close to mathematics.

Associativity

The associativity law said that we should be able to compose functions sequentially or calling one as the input of the other.


public class MonadTest {

  public static Try<Integer> divideByTen(Integer dividend) {
      return Try.of(() -> dividend/10);
  }

  public static Try<Integer> doubleVal(Integer n1) {
      return Try.of(() -> n1 * 2);
  }

  public static void main(String[] args) {

      Try<Integer> tryHundred = Try.of(() -> 100);
      Try<Integer> r1 = tryHundred.flatMap(MonadTest::divideByTen).flatMap(doubleVal::doubleVal);
      Try<Integer> r2 = tryHundred.flatMap(
                        hundred -> divideByTen(hundred).flatMap(MonadTest::doubleVal)
                        );
      Boolean r = r1.equals(r2);// True

  }

}

  (m >>= f) >>= g ≡ m >>= (\x -> f x >>= g)

Digest of papers: Why Functional Programming Matters

Gustavo Preciado — Tue, 04 Dec 2018 16:13:05 +0000

D. Turner, Addison-Wesley, 1990
Read this post in spanish

Modularity and readability are two of the most important features of code in order to achieve high quality and maintainable code, but writing modular code create the need for "glue code" that some times include side effects and reduce the readability. Functional programming use high-order functions and lazy evaluation in order to improve or even avoid this "glue code" and guarantee the readability with the referential transparency.

Referential Transparency

Function of FP share their definition with the math concept as follow : "A relation from a set of inputs to a set of possible outputs where each input is related to exactly one output" , consequently there is no side effects!. Additionally this allow us to replace a function call with the return value without having to view the whole context of the function and create more reusable and easy to test "modules".

High Order Functions

If a function return another function or have functions as input it's considered a high order function, it's also called first-class citizen in a more software-related approach.

Using high order functions we can define some abstract behaviors that apply to multiple data types and requires less "glue code".

The foldLeft function of collections in VAVR is a simple example of how this work:

The examples use a JAVA library called VAVR


  public static void main(String[] args) {
      List<Integer> list = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
      Integer r = list.foldLeft(0, Integer::sum); // 45
  }


  //source code of VAVR 
  default <U> U foldLeft(U zero, BiFunction<? super U, ? super T, ? extends U> f) {
        Objects.requireNonNull(f, "f is null");
        U xs = zero;
        for (T x : this) {
            xs = f.apply(xs, x);
        }
        return xs;
    }

Lazy Evaluation

Since we don't have side effects in FP it's possible write the definition of a value without evaluate them until the runtime execution and don't overthink about the infinite possible escenarios created by side effects.

A great example of this feature is the square root function that use a "infinite" list of candidates and choose the first value to pass the precision required.


  public static Function1<Double, Double> nextCandidate(Double n){
      /**
       * Sequence of candidates for the square root according to Newton-Raphson
       */
      return Function1.of((previous) -> (previous + (n / previous)) / 2d);
  }

  public static Double squareRoot(Double n){
      Stream<Double> s = Stream.iterate(1d, nextCandidate(n));
      Double epsilon = 0.0001d; // precision required
      return s.takeUntil(candidate -> Math.abs((candidate * candidate) - n) < epsilon).last();
  }

  public static void main(String[] args) {
      System.out.println(squareRoot(25d)); // 5.000023178253949
  }

The previous example also show another example of high order functions, represented by nextCandidate which have a function as output.

Feel free to comment about your experience with Functional programming in the comments.

This is my first English post and the firs of a serie of papers summaries, so I appreciate the feedback about the writing style, the content, other papers to read and recommended tags for the serie :)

Repasando Artículos: Monads For Functional Programming

Gustavo Preciado — Fri, 30 Nov 2018 20:40:05 +0000

Wadler, Philip , 2001

La programación funcional esta muy atada a las matemáticas y la definición de las funciones no es el único caso, otro ejemplo de esta relación es el concepto de Monada que se viene de la teoría de categorías en las matemáticas abstractas. Este concepto se integra en la programación para resolver los problemas que tenían los lenguajes funcionales puros al tratar de hacer algunas cosas que en los lenguajes imperativos son relativamente simples como manejar excepciones, llevar contadores o crear trazas de ejecución.

En el artículo mencionan como estos problemas surgen debido al flujo de datos explicito que se tiene en los lenguajes funcionales: "Pure functional languages have this advantage: all flow of data is made explicit. And this disadvantage: sometimes it is painfully explicit.", no obstante el articulo también resalta la modularidad que ofrece este flujo explicito de datos lo que ayuda a dar importancia al concepto de Monada.

Una monada, también conocida como construcción estándar, es en términos simples una estructura de datos que nos permite enriquecer el retorno de una función y a su vez facilita la composición de las mismas encapsulando algunos comportamientos que en los lenguajes imperativos se manejan como efectos colaterales. Un ejemplo clave para entender las monadas puede ser la estructura Try en Scala o en VAVR(librería funcional para JAVA) la cual permite almacenar excepciones, de forma que un objeto Try puede almacenar un Integer o una excepción lo que permite establecer el flujo de datos a través de la composición de funciones sin que se pierda el control de excepciones y sin que estas tengan que lidiar con todos los errores que pueden ocurrir en otras funciones que retornen un Integer.

El siguiente es un ejemplo de como usando la clase Try de VAVR se puede capturar una excepción durante la composición de funciones:


public static Try<Integer> dividir(Integer dividendo, Integer divisor) {
      return Try.of(() -> dividendo/divisor);
  }

  public static void main(String[] args) {
      Try<Integer> resultado = dividir(100, 0).flatMap(r1 -> dividir(r1, 10));
      System.out.println("RESULTADO 1 = " + resultado.map(String::valueOf).getOrElseGet(Throwable::getMessage));// RESULTADO 1 = / by zero

      resultado = dividir(100, 10).flatMap(r1 -> dividir(r1, 10));
      System.out.println("RESULTADO 2 = " + resultado.map(String::valueOf).getOrElseGet(Throwable::getMessage));// RESULTADO 2 = 1

  }

Leyes Monádicas

En la definición formal de monada se encuentran 3 leyes que se deben cumplir en estas estructuras, aunque pueden tener mayor valor teórico que practico.

"Left Unit" o "Left Identity"

no encontré una traducción al español

Esta ley indica que aplicar una función que retorna una Monada a un valor cualquiera debe ser igual a aplicar dicha función al valor que hay dentro de una Monada usando funciones de composición flatMap.


  public static void main(String[] args) {
      Integer cien = 100;
      Try<Integer> tryCien = Try.of(() -> cien);
      Boolean r = tryCien.flatMap(valor -> dividir(100, valor)   ).equals(  dividir(100, cien));// True
  }

  return a >>= f = f

"Right Unit" o "Right Identity"

no encontré una traducción al español

Similar a la anterior para cumplir esta ley si tenemos una función que reciba un valor y retorna este mismo pero dentro de una monada debemos poder aplicar esta función dentro de un flatMap o directamente al valor y obtener el mismo resultado.


  public static void main(String[] args) {
      Integer cien = 100;
      Try<Integer> tryCien = Try.of(() -> cien);
      // El método success retorna el valor en un try sin hacerle ningún cambio
      Boolean r = tryCien.flatMap(valor -> Try.success(valor)).equals(  Try.success(cien));// True
  }

  m >>= return = m

Los anteriores ejemplos en JAVA dan la falsa impresión que las dos leyes son la misma siendo "Right Identity" solo una especificidad de la anterior, pero como dije estas leyes son mas de valor teórico y su diferencia se hace mas evidente en lenguajes mas matemáticos como haskell.

Asociatividad o "Associativity"

En esta ley se hace referencia a la capacidad de las monadas de aplicar los métodos flatMap en secuencia o encerrando uno dentro de otro.


public class PruebaMonadas {

  public static Try<Integer> dividirPor10(Integer dividendo) {
      return Try.of(() -> dividendo/10);
  }

  public static Try<Integer> duplicar(Integer n1) {
      return Try.of(() -> n1 * 2);
  }

  public static void main(String[] args) {

      Try<Integer> tryCien = Try.of(() -> 100);
      Try<Integer> r1 = tryCien.flatMap(PruebaMonadas::dividirPor10).flatMap(PruebaMonadas::duplicar);
      Try<Integer> r2 = tryCien.flatMap(cien -> dividirPor10(cien).flatMap(PruebaMonadas::duplicar));
      // El método success retorna el valor en un try sin hacerle ningún cambio
      Boolean r = r1.equals(r2);// True

  }

}

  (m >>= f) >>= g ≡ m >>= (\x -> f x >>= g)

Repasando Artículos: Why Functional Programming Matters

Gustavo Preciado — Mon, 08 Oct 2018 03:25:43 +0000

D. Turner, Addison-Wesley, 1990

Con el tiempo el software ha aumentado en complejidad y cada vez es mas evidente la importancia de la modularidad para garantizar la calidad y facilitar el mantenimiento del código, debido a que un modulo pequeño es mas fácil de desarrollar, reusar y probar; sin embargo la modularidad genera una nueva necesidad que consiste en mejorar el "glue code" que consiste en el código utilizado para unir los diferentes módulos. Las principales ventajas de la programación funcional apuntan a mejorar la modularización haciendo que cada modulo sea mas fácil de reusar y de probar gracias a la transparencia referencial y uniéndolos mas eficientemente con la implementación de funciones de orden superior y evaluación perezosa.

Los ejemplos de código están escritos en JAVA utilizando la librería de VAVR que implementa una gran parte de las características de la programación funcional.

Transparencia referencial

En la programación funcional las funciones comparten su definición con las funciones matemáticas, una de las principales características de estas es que para un parámetro de entrada determinado siempre retornara el mismo valor en otras palabras eliminan los efectos colaterales presentes en otros paradigmas de programación. Esto tiene como resultado que el llamado a una función pueda ser remplazado por su valor sin tener consecuencia por el orden de ejecución u algún otro factor implícito del contexto de ejecución, esto fuerza la creación de módulos mas fáciles de comprender, reusar y probar.

Funciones de orden superior

Las funciones de orden superior son aquellas que reciben o retornan una o mas funciones, esto permite la reutilización de código y la generalización de algunos comportamientos para diferentes tipos de datos, los cuales solo deberán reescribir las funciones base que definan su comportamiento especifico, así como un "glue code" mas corto y facil de comprender. Un ejemplo básico de las funciones de orden superior es la función foldLeft que permite combinar todos los elementos de una lista en unico elemento resultado de la aplicar repetidamente una función cualquiera que reciba como parámetro objetos del tipo de los elementos de la lista.


  public static void main(String[] args) {
      List<Integer> list = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
      Integer r = list.foldLeft(0, Integer::sum); // 45
  }


  //codigo de la funcion foldLeft tomado del código fuente de vavr
  default <U> U foldLeft(U zero, BiFunction<? super U, ? super T, ? extends U> f) {
        Objects.requireNonNull(f, "f is null");
        U xs = zero;
        for (T x : this) {
            xs = f.apply(xs, x);
        }
        return xs;
    }

Evaluación Perezosa

Uno de los beneficios de la ausencia de los efectos colaterales es que los programadores pueden hacer uso de la evaluación perezosa sin tener que prever infinidad de escenarios posibles, esta consiste en definir valores como resultado de una función que no serán calculados hasta que la ejecución del programa no lo requiera lo que permite crear comportamientos como arreglos de longitud teóricamente infinita, en la mayoría de los casos llamados streams. Un ejemplo del uso de evaluación perezosa es el calculo de la raíz cuadrada de un numero utilizando un sucesión infinita de candidatos que se evalúa hasta encontrar uno que cumpla con la precisión requerida.


  public static Function1<Double, Double> siguienteCandidato(Double n){
      /**
       * Formula para calcular la sucesión de candidatos a para la raíz cuadrada de n según el método de Newton-Raphson
       */
      return Function1.of((anterior) -> (anterior + (n / anterior)) / 2d);
  }

  public static Double calcularRaizCuadrada(Double n){
      Stream<Double> s = Stream.iterate(1d, siguienteCandidato(n));
      Double epsilon = 0.0001d; // Se utiliza para especificar la precisión
      return s.takeUntil(candidato -> Math.abs((candidato * candidato) - n) < epsilon).last();
  }

  public static void main(String[] args) {
      System.out.println(calcularRaizCuadrada(25d)); // 5.000023178253949
  }

En el ejemplo anterior también se puede observar el segundo caso de funciones de orden superior, representado por siguienteCandidato que consta de una función que retorna otra función.

Hi, I'm Gustavo Preciado

Gustavo Preciado — Wed, 07 Jun 2017 19:56:30 +0000

I have been coding for 3 years.

You can find me on GitHub as gustavo94

I live in Envigado, Colombia.

I work for S4N,

I mostly program in Ruby, Python and now I am learning Scala.

I am currently learning more about web development, open source projects, functional programing and continuous testing.

Nice to meet you.