Funciones recursivas en listas

Hay dos enfoques para trabajar con listas:

• Escribir funciones utilizando definiciones recursivas que atraviesan la estructura de la lista.
• Utilizar funciones estandar. 

Se prefiere el segundo enfoque, pero las funciones estándar de procesamiento de listas deben definirse, y esas definiciones usan el primer enfoque (definiciones recursivas).

Se crea una lista a partir de la lista vacía [] y la función cons :: a → [a] → [a] la cual se puede escribir con ":"

Una lista se puede definir como : 

• [] o
• (x: xs) para algunas x (el encabezado de la lista) y xs (la cola) donde (x: xs) 

La lista esta definida de forma recursiva, el caso base de la recursión es [], el caso de recursión (o inducción) es (x: xs).

La longitud de una lista se puede calcular de forma recursiva de la siguiente manera:

length :: [a] -> Int           -- function type

length [] = 0                  -- base case

length (x:xs) = 1 + length xs  -- recursion case

filter recibe un predicado (una función que da un resultado booleano) y una lista, y devuelve una lista de los elementos que satisfacen el predicado.

filter :: (a->Bool) -> [a] -> [a]

filter (<5) [3,9,2,12,6,4] -- > [3,2,4]

La podemos definir así:

filter :: (a -> Bool) -> [a] -> [a]

filter pred []    = []

filter pred (x:xs)

  | pred x         = x : filter pred xs

  | otherwise      = filter pred xs

Muchos cálculos que serían calculados con bucles for / while en un lenguaje imperativo se expresan naturalmente como cálculos de lista en un lenguaje funcional.

En Haskell tenemos: 

• Map : Realizar un cálculo en cada elemento de una lista
• Foldl: Iterar sobre una lista, de izquierda a derecha 
• Foldr: Iterar sobre una lista, de derecha a izquierda

Es una buena práctica usar estas tres funciones cuando corresponda

Podemos expresar un gran cálculo "encadenando" una secuencia de funciones que realizan cálculos más pequeños. Por ejemplo tenemos un argumento de tipo a, aplicamos una función g :: a−> b, obteniendo un resultado intermedio de tipo b luego aplicamos una función f :: b−> c al resultado intermedio, obteniendo el resultado final de tipo c. El cómputo completo (primero g, luego f) se escribe como f∘g. Esta es la notación matemática tradicional; solo recuerda que en f∘g, las funciones se usan en orden de derecha a izquierda.

Haskell utiliza el . como operador de composición de funciones

(.) :: (b->c) -> (a->b) -> a -> c

(f . g) x = f (g x)

Tutorial de Python, Guía básica de Python en español

Quiero compartir una página que nos permite aprender python de forma fácil y práctica. 

Reza la página: 

"Este tutorial de Python es una introducción a los principales aspectos y características del lenguaje. El tutorial sirve de guía de inicio para dar los primeros pasos con Python, familiarizarse con su sintaxis, conocer los principales tipos de datos y entender algunos conceptos clave.

¿Para quién es este tutorial Python?

En principio, el tutorial es apto para todos los públicos. Si nunca has programado en Python, te servirá para aprender lo básico del lenguaje. Por el contrario, si ya lo conoces y/o has desarrollado alguna aplicación con él, te será útil para reforzar conceptos y descubrir cosas nuevas que quizá desconozcas."

No tengo más que acotar, dejo link :  https://j2logo.com/python/tutorial/?fbclid=IwAR2igqihfrqMMr1ZnqR5hgx3ZUkwE2OmYBz-FBmPQrnRRCyJeoVv1s4Nd0k

HumanOS

HumanOS es un blog de software libre. Tiene post sobre temas de variados de diferentes temas y el propósito de este blog es mostrarle a las personas cuales son los provechos que se les puede sacar al software libre

Dejo link:

http://humanos.uci.cu/

Juego de adivinanzas en Haskell

Vamos a ser un juego de adivinanzas. Va a haber una palabra que el jugador debe adivinar. Para cada turno del juego, el jugador adivina una sola letra. Si esa letra es correcta, las letras adivinadas se muestran en los lugares correctos de la palabra. Si esa letra es incorrecta, el usuario pierde una estrella. Una vez que el usuario no tiene estrellas, ha perdido el juego. Sin embargo, si el usuario adivina todas las letras de la palabra, ha ganado el juego, como el ahorcado.

Comience creando un archivo de texto vacío llamado ahorcado.hs: la extensión hs es para indicar que este archivo contiene el código fuente de Haskell.


El corazón del juego consiste en verificar las conjeturas del jugador. Queremos saber si la suposición fue correcta. Este resultado es un valor Bool, ya sea verdadero o falso. Necesitamos actualizar la palabra mostrada, si la suposición fue correcta, reemplazando los guiones apropiados en la palabra mostrada con el carácter correctamente adivinado. Por lo tanto, el tipo de resultado de la función es un par (Bool, String). El primer elemento del par es el resultado de la suposición. El segundo elemento es la Cadena que se mostrará al usuario para la próxima ronda.

Ahora, la función de verificación necesita saber:

• La palabra secreta, una cadena
• La palabra que se muestra en pantalla o real, también una cadena
• El carácter elegido por el jugador.

Estas son las entradas a la función de verificación. Entonces ahora podemos establecer el tipo de la función:

check :: String -> String -> Char -> (Bool, String)

Siempre es útil determinar primero el tipo de función. Esto enfoca su atención en lo que se supone que debe calcular la función, y qué datos necesita para hacerlo. Los buenos ingenieros de software hacen las especificaciones antes de la implementación.

¿Cómo será el cuerpo de la función de verificación? La suposición del jugador es correcta si y solo si el carácter elegido c está en la palabra secreta. Entonces la suposición es correcta si :

c palabra `elem`

La nueva palabra que se mostrará será:

[(if x==c then c else y) | (x,y) <- zip word display]

Esta es una lista de comprensión, donde seleccionamos cada letra de la palabra real o de la pantalla anterior. La palabra es texto sin formato, mientras que la pantalla comienza con todos los caracteres discontinuos.

check :: String -> String -> Char -> (Bool, String)

check word display c

  = (c `elem` word, [if x==c

          then c

          else y | (x,y) <- zip word display])

La siguiente función que definiremos es la función de giro. Esta es la función que se llamará cada vez que sea el turno del jugador para ingresar un caracter. Primero debemos comprobar cuántas conjeturas le quedan al jugador:

if n == 0

Si quedan algunas conjeturas, entonces necesitamos ver si el jugador completo la palabra o no:

if word == display

Entonces tendremos dos verificaciones if, cada una seguida de mensajes de estado putStrLn y el final de la secuencia de llamada a la función (ya que es el final del juego). Sin embargo, si ninguna de las condiciones es verdadera, entonces el jugador puede tomar un turno, por lo que llamamos a otra función para obtener otro personaje de la entrada del usuario.

turn :: String -> String -> Int -> IO ()

turn word display n =

  do if n==0

       then putStrLn "You lose"

       else if word==display

              then putStrLn "You win!"

              else mkguess word display n

Tenga en cuenta que hay una forma más ordenada de escribir la función de giro, utilizando Haskell guards, pero no vamos a utilizarlas para simplificar el programa.

mkguess word display n =

  do putStrLn (display ++ "  " ++ take n (repeat '*'))

     putStr "  Enter your guess: "

     q <- getLine

     let (correct, display') = check word display (q!!0)

     let n' = if correct then n else n-1

     turn word display' n'

¿Cuál es el tipo de mkguess? ¿Puedes resolverlo y agregarlo antes de la definición de la función? Tomamos una línea de entrada del usuario, pero solo usamos el primer carácter para la suposición. Esto fallará si el usuario simplemente presiona ENTER sin escribir ningún carácter, ya que q será una cadena vacía.

Bien, ahora solo necesitamos una función de nivel superior:

starman :: String -> Int -> IO ()

starman word n = turn word ['-' | x <- word] n

Esta función toma dos argumentos, el primero es la palabra a adivinar y el segundo es el número de conjeturas incorrectas que el jugador tiene permitido.

Pongamos todas estas cuatro funciones en un archivo de texto, llamado starman.hs

Guarde el archivo, luego inicie ghci quizás escribiendo ghci en un símbolo del sistema de DOS, ejecutando WinGHCi o escribiendo ghci en una ventana de terminal (macOS o Linux).

Si está en el directorio correcto, es decir, en el que guardó starman.hs, debería poder escribir

:l starman.hs

y el programa debería cargarse. Dirá algo como:

Prelude> :l ahorcado.hs
[1 of 1] Compiling Main             ( ahorcado.hs, interpreted )
Ok, one module loaded.

Starman "funcionalmente" 5

y comienza a jugar el juego! Volverá a la solicitud de GHCi cuando se complete la función starman.

Y Listo!!

El estado del ecosistema del desarrollador 2019

Como en el 2018 la empresa jetbrains  compartido los resultados de su encuesta anual.

Sin más dejo el link: https://www.jetbrains.com/es-es/lp/devecosystem-2019/

Swift es como Kotlin

Quiero compartir una pagina que compara Swift con Kotlin.

Lo comparto porque hasta esta pagina, no me parecían similares pero son igualitos :D

Dejo link: http://nilhcem.com/swift-is-like-kotlin/

Libro gratuito de Scala

Quiero compartir el siguiente libro de Alvin Alexander que es gratuito y esta bueno. El libro tiene aproximadamente 225 páginas y proporciona una breve pero completa introducción al lenguaje Scala. Según el autor.

Sin más dejo el link: https://alvinalexander.com/scala/scala-book-free/

Ejemplo de pattern matching en Scala

La idea es que tenemos que saber si un string (en realidad lo hice con lista de caracteres) tiene sus paréntesis balanceados. Onda si abre uno lo tiene que cerrar y por supuesto, no puede comenzar cerrando.

Veamos como podemos solucionar esto en Scala:

def balance(palabra : List[Char]) : Boolean = {

  def balanceAux(palabra : List[Char], n : Int) : Int = palabra match {
    case List() => n
    case '('::tail => balanceAux(tail, n + 1)
    case ')'::tail => if (n == 0) -1 else balanceAux(tail, n - 1)
    case _::tail => balanceAux(tail, n)
  }

  balanceAux(palabra, 0) == 0
}

Se puede ver que el ultimo case tiene el valor que no es un paréntesis, cualquier otra letra y esto lo decimos con "_"

Es un ejemplo bastante pavo, pero podemos ver la potencia que tiene Pattern matching

Primer acercamiento a I/O en Haskell

Las funciones puras son el tipo de funciones toman valores como argumentos, procesan algunos de esos valores y luego devuelven un valor de resultado. Una función pura no depende del "estado del mundo". El cálculo es totalmente autónomo e independiente. Dados los mismos argumentos, una función pura siempre devolverá el mismo resultado.

I/O es impuro. Las operaciones de entrada y salida son impuras. Influyen e interactúan con el "mundo exterior". Esencialmente, esta es la única forma de hacer que las computadoras hagan cosas interesantes.

La función getLine lee la entrada del usuario y la devuelve como un tipo especial de valor de cadena: una cadena de I/O. La función putStrLn toma una entrada de cadena y la imprime en el terminal, devolviendo un valor de IO vacío, es decir, IO ().

Los tipos IO es lo que nos permite no mezclar funciones puras e impuras: el sistema de tipos nos mantiene honestos. Sabemos por el tipo de función si está involucrado con I/O.

Veamos esta simple función :

let greet() = do
    planet <- getLine
    home <- getLine
    putStrLn ("greetings " ++ planet ++ "ling.")
    putStrLn ("I am from " ++ home ++ ".")
    putStrLn "Take me to your leader."

Podemos escribirlo como una (¡muy larga!) Línea única:

do { planet <- getLine; home <- getLine; putStrLn ("greetings " ++ planet ++ "ling."); putStrLn ("I am from " ++ home ++ "."); putStrLn "Take me to your leader."}

Si ejecutamos esto, escribiendo "Earth" y "Mars". Entonces deberías ver:

greetings Earthling.
I am from Mars.
Take me to your leader.

Tenga en cuenta que el orden es importante aquí:

queremos que la primera llamada getLine obtenga el nombre del planeta en el que hemos aterrizado
queremos que la segunda llamada getLine obtenga el nombre de dónde somos.

El orden de evaluación de funciones no importa en código puro, por Ej.

let a = reverse "winston"
    b = reverse "churchill"
in "sir " ++ a ++ " " ++ b

No importa si hacemos el primer reverso antes del segundo; el resultado de la expresión sigue siendo el mismo. Sin embargo, este no es el caso de I/O. La secuencia es vital para las acciones de I/O.

La notación do nos permite secuenciar acciones. Esto se parece a una secuencia de comandos en un lenguaje de programación imperativo. Sin embargo, hacer es solo azúcar sintáctico. Debajo, se reescribe como una cadena de llamadas de función donde la salida de la primera función se convierte en la entrada de la segunda función. El operador de enlace realiza esta secuencia de funciones. Es una parte clave de la mónada IO. Estamos comenzando a arañar la superficie de Haskell IO y descubrimos que es muy complejo. Reservaremos la discusión de Mónadas y operadores de enlace para más adelante en el curso.

Por ahora, todo lo que necesitamos entender es:

• Las operaciones de I/O son impuras
• Puede usar do para especificar una secuencia de acciones
• use <- dentro de un do para asociar valores de entrada con nombres
• cualquier valor o función que implique I/O tiene IO en su tipo
• una secuencia de acciones de  I/O se describe como estar en la Mónada de IO

Tail recursion

Cuando me tocaba enseñar recursibidad, hago el típico ejemplo de la Sucesión de Fibonacci la cual podríamos definir de este modo :

f(0) = 1
f(1)= 1
f(n) = f(n - 1) + f(n - 2)

Y listo! esto es muy fácil de programar en scala, sería:

def fibo(n: Int) : Long = if (n==0 || n==1) 1 else fibo(n-1) + fibo(n-2)

esto funciona si no pretendemos calcular el fibonacci en la posición  n = 55

El problema es que este algoritmo tiene una complejidad de dos a la n.

Podemos resolver este problema empezando desde el comienzo. Si lo pensamos de forma imperativo, sería algo así :

  def fibonacci(n: Int): Long = {
     var fa = 1l
     var faa = 1l
     var i = 1
    while (i < n) {
      var aux = fa
      fa = fa + faa
      faa = aux
      i = i + 1
    }
    faa
  }

Es decir si empezamos desde el principio ya tenemos los f(n-1) y f(n-2), pero no solo es solucionable de este modo de forma imperativa, tambien podemos utilizar recursividad de este modo :

  def fibonacci(n: Int): Long = {
     def fibonacciAux(n: Int, fa: Long, faa: Long) : Long =
       if (n == 3) fa + faa
       else fibonacciAux(n-1, fa + faa, fa)

    if (n<=2) 1
    else fibonacciAux(n,1,1)
  }


Tail recursion es un tipo específico de recursión. En particular, se dice que una función recursiva usa tail recursion si la llamada a sí misma ocurre como la última acción de la función.

Cuando una función recursiva se llama a sí misma varias veces, las llamadas van acumulándose en la pila de llamadas, que de por sí, no es muy eficiente porque consume memoria. Pero aun peor, si se acumulan demasiadas llamadas en esta pila, eventualmente se desborda la pila de llamadas y te lanza la excepción java.lang.StackOverflowError.

Esta ineficiencia es un problema serio para un lenguaje funcional como Scala que promueve el uso de funciones recursivas.

Sin embargo, cuando Scala detecta que la función recursiva usa tail recursion, entonces el compilador es capaz de efectuar una optimización al código de forma automática, efectivamente eliminando la recursividad enteramente y reemplazándolo con un simple bucle. Esta optimización es comúnmente conocida como tail call optimization.

Y listo! La función de fibonacci funciona rápido porque utilizamos tail recursion y porque bajamo su complejidad.

Dejo link :
https://es.stackoverflow.com/questions/121965/que-es-tail-recursion

Libros gratuitos de Haskell

Me gustaría recomendar estos libros gratuitos :

Real World Haskell
Real World Haskell es un típico libro de lenguaje de programación O’Reilly. El contenido está disponible en línea de forma gratuita : http://book.realworldhaskell.org/read/

Learn You a Haskell
Learn You a Haskell es una introducción muy informal, pero hace un gran trabajo al explicar conceptos complejos. Puedes leerlo : http://learnyouahaskell.com/chapters

Listas en Haskell

Una estructura de datos clave es la lista

Sintaxis: los elementos se escriben entre corchetes, separados por comas.

['3', 'a']
[2.718, 50.0, -1.0]

Una función solo puede devolver un resultado pero las listas le permiten agrupar varios valores en un objeto, que puede ser devuelto por una función.

Aquí hay una función (minmax) que devuelve el menor y el mayor de dos números:

minmax = \x y -> [min x y, max x y]
minmax 3 8  -- > [3,8]
minmax 8 3  -- > [3,8]

Ojo! se puede hacer pero no esta del todo bien...

Se puede escribir una lista constante, de la siguiente manera:

mylist = [2,4,6,8]

A la vez los elementos pueden ser expresiones y se evalúan solo cuando se usan. Supongamos que se define:

answer = 42
yourlist = [7, answer+1, 7*8]

Entonces

yourlist -- > [7, 43, 56]

Pero mientras no acceda a la expresión, no se evalúa.

El operador (++) toma dos listas existentes y retorna una nueva que contiene todos los elementos de las listas pasadas por parámetro.

[23, 29] ++ [48, 41, 44] -- > [23, 29, 48, 41, 44]

Si xs es una lista, entonces [] ++ xs = xs = xs ++ [].

A veces es útil tener una secuencia de números.

En notación matemática estándar, puedes escribir 0,1, ..., n.

Haskell tiene una notación de secuencia para listas.

La secuencia se escribe entre corchetes, con el valor inicial, el operador ... y el valor final.

[0 .. 5] -> [0,1,2,3,4,5]
[100 .. 103] -> [100,101,102,103]

Las secuencias no están limitadas a números, hay muchos tipos enumerables donde hay una forma natural de incrementar un valor y se puede usar secuencias en cualquier de estos tipos.

Por ejemplo:

[’A’ .. ’z’] -> ['a', 'b', 'c', 'd', 'e', ​​'f', 'g', 'h', 'i', 'j', 'k', 'l', ' m ',' n ',' o ',' p ',' q ',' r ',' s ',' t ',' u ',' v ',' w ',' x ',' y ' , 'z']

['0' ... '9'] -> ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9' ']

es una lista de caracteres (que resultan ser los caracteres de dígitos);

[0 .. 9] -> [0,1,2,3,4,5,6,7,8,9]
Es una lista de números.

Una comprensión de lista es una notación de alto nivel para especificar el cálculo de una lista

El compilador transforma automáticamente las comprensiones de una lista en una expresión utilizando una familia de funciones básicas que operan en listas

Las comprensiones de listas se inspiraron en la comprensión del conjunto de notación matemática.

Ejemplos de comprensiones de conjuntos:

• Un conjunto obtenido multiplicando los elementos de otro conjunto por 3 es {3 × x | x ← {1, ..., 10}}.
• El conjunto de números pares es {2 × x | x ← N}.
• El conjunto de números impares es {2 × x + 1 | x ← N}.
• El producto cruzado de dos conjuntos A y B es {(a, b) | a ← A, b ← B}.

Ejemplos de listas por comprensión
[3 * x | x <- [1..10]]
->
[3,6,9,12,15,18,21,24,27,30]

[2 * x | x <- [0..10]]
->
[0,2,4,6,8,10,12,14,16,18,20]

[2 * x + 1 | x <- [0..10]]
->
[1,3,5,7,9,11,13,15,17,19,21]

[[a, b] | a <- [10,11,12], b <- [20,21]]
->
[[10,20], [10,21], [11,20], [11,21], [12,20], [12,21]]

Podemos indexar una lista numerando los elementos, comenzando por 0. Así, una forma canónica de una lista con n elementos es [x0, x1, .. xn − 1]. El operador !! toma una lista y un índice, y devuelve el elemento correspondiente.

[5,3,8,7] !! 2 -> 8
[0 .. 100] !! 81 -> 81
['a' .. 'z'] !! 13 -> 'n'

Si el índice es negativo o demasiado grande, se devuelve indefinido.

Hay funciones de la biblioteca estándar para acceder encabezado de una lista (su primer elemento) o la cola (todo el resto de la lista)

El resultado de aplicar head o tail a la lista vacía no está definido.

head :: [a] -> a
head [4,5,6] -- > 4
tail :: [a] -> [a]
tail [4,5,6] -- > [5,6]


Hemos mencionado antes que Haskell es "lazy", lo que significa que solo evalúa expresiones cuando son necesarias para la evaluación de otra expresión. Este comportamiento se extiende a las listas, por lo que podemos definir listas infinitas usando secuencias, por ejemplo [1 .. ] es la lista de todos los enteros positivos. Otro ejemplo es la función primos (del paquete Data.Numbers.Primes) que devuelve una lista infinita de números primos. Una consecuencia de lazy en las listas es que puede definir listas que contengan expresiones muy complejas y que requieren mucho tiempo, y no se evaluarán, si no son requeridas. Lo mismo es cierto para una expresión incorrecta, por ejemplo, definir xs = [1,2, xs !! 5,4] no generará un error siempre que no acceda al tercer elemento.

Otra cosa muy importante es que las listas también son inmutables. Como resultado, si define xs2 = xs ++ xs e intenta acceder al tercer elemento xs2 !! 2 aún generará un error porque xs no se ha modificado:

xs2 !! 2 -- > *** Exception: Prelude.(!!): index too large

Curiosamente, si cambiamos la definición de xs a xs = [1,2, xs2 !! 5,4], entonces ambas xs !! 2 y xs2 !! 2 devolverá 2:

xs = [1,2,xs2 !! 5,4]
xs2 = xs ++ xs
xs2 !! 2 -- > 2
xs !! 2 -- > 2

Esta es una consecuencia de la evaluación de expresiones de Haskell mediante la reducción: el orden de las expresiones no importa.

PD: la imagen es de http://learnyouahaskell.com/ con licencia Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License  porque no pudo encontrar una licencia con un nombre más largo.

DevOps: tecnología, herramientas y plan de carrera

DevOps se ha convertido en el nuevo paradigma de desarrollo. Su agilidad, una metodología de entrega continua y un sistema prueba-error que permite obtener feedback instantáneo, ha disparado la demanda de este tipo de profesionales en las empresas. ¿Quieres saber más? ¡Descárgate nuestro eBook gratuito "DevOps: "tecnología, herramientas y plan de carrera"!

Sito textual, la pagina que nos esta regalando un libro sobre esta tecnología.

Dejo link: https://landing.muypro.com/ebook-devops/

Funciones en Haskell

Haskell es un lenguaje funcional, por lo que el concepto de función es esencial para el lenguaje. Una función toma uno o más argumentos y calcula un resultado. Dados los mismos argumentos, el resultado siempre será el mismo. Esto es similar a una función matemática y significa que en Haskell no hay efectos secundarios. Hay dos operaciones fundamentales en las funciones: definición de función (crear una función) y aplicación de función (usar una función para calcular un resultado).

En Haskell, muchas funciones están predefinidas en una biblioteca estándar llamada preludio (prelude)

Una función se define mediante una ecuación.
f = \ x -> x + 1 - función lambda
- o
f x = x + 1 - función nombrada

Esto es equivalente a f (x) = x + 1 en notación matemática.

El lado izquierdo de la ecuación parece una variable, y eso es lo que es. El lado derecho es una expresión que usa las variables locales enumeradas entre paréntesis y define el resultado de la expresión.

Una aplicación es una expresión como f 31, donde 31 es el argumento. La aplicación se evalúa reemplazándola con el cuerpo de la función, donde los parámetros formales se reemplazan por los argumentos.

Veamos un ejemplo :

f = \ x -> x + 1
  f 3
-> {enlace x = 3}
  (x + 1) donde x = 3
-> {sustituir 3 por x}
  3 + 1
->
4

Una función con tres argumentos:

add3nums = \ x y z -> x + y + z

Y podemos usarlo :

10 + 4* add3nums 1 2 3
= {- put extra parentheses in to show structure -}
  10 + ( 4* (add3nums 1 2 3) )
  -- >
  10 + (4*(1+2+3) )
  -- >
  10 + (4*6)
  -- >
  10 + 24
  -- >
  34

Springer regala libros!!

En el contexto del Covid 19, Springer regala libros.

Hay libros muy interesantes de Java, Scala, programación en paralelo y ciencia de datos.

Dejo link : https://link.springer.com/search/page/1?facet-content-type=%22Book%22&package=mat-covid19_textbooks&fbclid=IwAR2dD_eYkJArztAjIwg501C7aa9sSA9FGh8ov0PCS6-eY3QFxz2NVqNanHs&facet-language=%22En%22&facet-discipline=%22Computer+Science%22

Reducción en Haskell

El mecanismo para ejecutar programas funcionales es la reducción. La reducción es el proceso de convertir una expresión a una forma más simple. Conceptualmente, una expresión se reduce simplificando una expresión reducible (llamada "redex") a la vez. Cada paso se denomina reducción y usaremos -> para mostrar el resultado.

  3 + (4*5)
--  >
  3 + 20
--  >
23

La reducción es importante porque es el único medio de ejecución de un programa funcional. No hay declaraciones, como en los lenguaje imperativos; todo el cómputo se logra únicamente mediante la reducción de expresiones.

Cuando se realiza una reducción, solo hay una respuesta posible. En este ejemplo, el cálculo solo tiene una ruta posible:

  3 + (5 * (8-2))
--  >
  3 + (5 * 6)
--  >
  3 + 30
--  >
33

Solo hay una posible ruta de reducción en ese ejemplo, porque en cada paso la expresión actual contiene solo una redex.

Si una expresión contiene varios redexes, habrá varias rutas de reducción.

(3+4) * (15-9)
-- >
  7 * (15-9)
-- >
  7 * 6
-- >
 42

(3+4) * (15-9)
-- >
  (3+4) * 6
-- >
  7 * 6
-- >
  42

¡El resultado no depende de la ruta de reducción!
Cada ruta de reducción de terminación da el mismo resultado

Esto significa que :

• La corrección no depende del orden de evaluación.
• El compilador (o programador) puede cambiar el orden libremente para mejorar el rendimiento, sin afectar el resultado.
• Se pueden evaluar diferentes expresiones en paralelo, sin afectar el resultado. 

Libros de Java Code Geeks

Download IT Guides!   Java NIO Programming Cookbook java.nio (NIO stands for non-blocking I/O) is a collection of Java programming language APIs that offer features for intensive I/O operations. It was introduced with the J2SE 1.4 release...     IntelliJ IDEA Handbook IntelliJ IDEA is a Java integrated development environment (IDE) for developing computer software. It is developed by JetBrains, and is available as an Apache 2 Licensed community...     Amazon S3 Tutorial Amazon S3 (Simple Storage Service) is a web service offered by Amazon Web Services. Amazon S3 provides storage through web services interfaces (REST, SOAP, and BitTorrent). Amazon...     JUnit Programming Cookbook JUnit is a unit testing framework to write repeatable tests. JUnit has been important in the development of test-driven development, and is one of a family of unit testing frameworks...

Elementos básicos en Haskell, Parte 2

Veamos algunos elementos más básicos (y no tan básicos) de Haskell a través de la comparación con otros lenguajes. No entraremos en detalles sobre las construcciones de Haskell, solo mostraremos las similitudes con las construcciones de los lenguajes que podamos conocer.

En JavaScript, las funciones suelen ser bloques de código:

    function roots(a,b,c) {
        det2 = b*b-4*a*c;
        det  = sqrt(det2);
        rootp = (-b + det)/a/2;
        rootm = (-b - det)/a/2;
        return [rootm,rootp]
    }

En Haskell, escribiríamos esta función de la siguiente manera:

    roots a b c = 

        let

            det2 = b*b-4*a*c;

            det  = sqrt(det2);

            rootp = (-b + det)/a/2;

            rootm = (-b - det)/a/2;

        in

            [rootm,rootp]

Tenga en cuenta que la construcción let ... in ... es una expresión, por lo que devuelve un valor. Por eso no hay necesidad de una palabra clave de return.

En Python podríamos escribir una función con una condición como esta:

def max(x,y):

    if x > y:

        return x

    else:

        return y

Por supuesto, Haskell también tiene una construcción if-then:

    max x y = 

        if x > y

            then x

            else y

Una vez más, la construcción if ... then ... else ... es una expresión, por lo que devuelve un valor.

Muchos lenguajes proporcionan una declaración de caso para condiciones con más de dos opciones. Por ejemplo, Ruby proporciona una expresión de caso:

    Red = 1

    Blue = 2

    Yellow = 3

    color = set_color();

    action = case color 

        when Red then action1()

        when Blue then action2()

        when Yellow then action3()

    end

En Haskell, el caso funciona y se ve similar:

    data Color = Red | Blue | Yellow

    color = set_color

    action = case color of

        Red -> action1

        Blue -> action2

        Yellow -> action3

Sin embargo, tenga en cuenta cómo usamos el tipo como el valor para decidir el caso, donde en otros lenguajes necesitamos definir algún tipo de enumeración.

En Java y C ++ hay tipos de datos genéricos (también conocidos como tipos de plantillas, generic o template en ingles), como:

    Map<String,Integer> set = new HashMap<String,Integer>();

En Haskell, escribirías esto de la siguiente manera:

    set :: Data.Map.Map String Integer 

    set = Data.Map.empty

La principal diferencia es, por supuesto, que el conjunto en Haskell no es un objeto sino una variable inmutable, por lo que en Java haríamos :

    set.put("Answer",42)

En Haskell haríamos :

    set' = Data.Map.insert "Answer" 42 set

Debido a que en Haskell las variables son inmutables, el valor de retorno de la llamada de inserción está vinculado a una nueva variable en lugar de actualizar la variable en su lugar como en Java.

MiniKanren

Si hablamos de programación lógica siempre pensamos en Prolog. Pero existen otros lengujes lógicos, como  MiniKanren que es un lenguaje embebido en Clojure.

miniKanren es un DSL (Domain Specific Language) para la programación logica.

miniKanren es muy simple, con sólo tres operadores lógicos y un operador de interfaz.

La primera implementación fue en scheme, pero ahora existen implementaciones en diferentes lenguajes y tecnologías como Racket, Clojure, Haskell, Python, JavaScript, Scala, Ruby, OCaml, PHP y algunos más.

De igual manera que prolog, esta centrado en reglas y constraits.

En este post vamos a utilizar la implementación de Clojure, MiniKanren se encuentra en core.logic, para poder usarlo debemos tener una jdk y Leiningen.

Para crear un proyecto debemos utilizar Leiningen de la siguiente manera:

lein new logical

Con esta instrucción podemos crear un proyecto.

Ahora debemos agregar las dependencias:

(defproject logical "0.1.0-SNAPSHOT"
          :dependencies [[org.clojure/clojure "1.5.1"]
          [org.clojure/core.logic "0.8.5"]])

core.logic es donde se encuentra MiniKanren.

Ahora cuando lancemos el relp se levantará miniKanren:

$ lein repl
nREPL server started on port 48235 on host 127.0.0.1
REPL-y 0.3.0
Clojure 1.5.1
Docs: (doc function-name-here)
(find-doc "part-of-name-here")
Source: (source function-name-here)
Javadoc: (javadoc java-object-or-class-here)
Exit: Control+D or (exit) or (quit)
Results: Stored in vars *1, *2, *3, an exception in *e
user=> (use 'clojure.core.logic)
WARNING: == already refers to: #'clojure.core/== in namespace: user, being
replaced by: #'clojure.core.logic/==
nil
user=>

Ahora podemos empezar con el relp de MiniKanren, veamos un ejemplo :

user=> (run* [q] (== q 1))
(1)

En el ejemplo corremos el programa con run* que permite correr programas logicos y retorna un conjunto de soluciones.  q es una variable logica. Y el programa contiene la siguiente expresión :
 (== q 1)

Dicha expresión es unification, que se puede ver como pattern matching. Este programa devuelve 1 dado que q va valer 1 para que esto sea verdadero.

Le está pidiendo al lenguaje que intente hacer que los lados izquierdo y derecho sean iguales, suponiendo que eso sea posible. Los lados izquierdo y derecho se comparan como en las pruebas de igualdad normales, y cualquier variable lógica no vinculada está vinculada a valores que harían coincidir los dos lados. En este ejemplo, q está vinculado a 1, que es una solución porque no hay otras reglas.

Las expresiones en un programa lógico son objetivos. No devuelven verdadero o falso, pero tienen éxito o fracasan. Es posible que el éxito se logre varias veces de diferentes maneras o en absoluto. Esto nos lleva al último bit de nuestro ejemplo: el resultado.

Nuestro ejemplo devuelto (1). run * devuelve los valores de q que resultan en éxito.

En nuestro ejemplo, unificar q con 1 une q al número 1 y tiene éxito. Nuestro resultado es la lista que contiene el enlace único para q.

Veamos un objetivo fallido:

user=> (run* [q] (== q 1) (== q 2))
()

Este programa tiene dos expresiones, cada una un objetivo. Un programa con múltiples objetivos tendrá éxito solo si todos los objetivos tienen éxito, de manera similar a && u operadores en otros lenguajes. Aquí, la primera unificación unirá q al número 1 como antes y tendrá éxito. La segunda unificación fallará, ya que q está unido a 1 y 1 no se unifica con 2. Debido a que ningún enlace de q puede hacer que ambos objetivos tengan éxito, la lista resultante está vacía. Es decir, no hay solución. 

En proximos post seguiremos con este particular lenguaje,  por ahora dejo link: http://minikanren.org/

Elementos básicos en Haskell

En casi todos los lenguajes de programación puede crear expresiones como:

    (b * b-4 * a * c) / 2 * a

y puedes asignar estas expresiones a variables:

    v = (b * b-4 * a * c) / 2 * a

En Haskell, también puedes hacer esto, y lo que es más: las expresiones son realmente todo lo que hay, no hay declaraciones.


En Python, puede definir una función como

    def hello(name):
        return "Hello, "+name

En Haskell puedes escribir esto simplemente como:

    hello name = "Hello, "++name

C tiene tipos, por ejemplo:

    int f (int x, int y) {
        return x*y+x+y;
    }

Haskell tiene un sistema de tipos mucho más poderosos que C, y hablaremos mucho sobre los tipos:

    f :: Int -> Int -> Int
    f x y =  x*y+x+y

En muchos lenguajes, como Python, JavaScript, Ruby, ... puedes crear listas como:

    lst = ["A", "lista", "de", "cadenas"]

Haskell también usa esta sintaxis para las listas.

Para unir listas, en Python podrías escribir

    lst = [1,2] + [3,4]

En Haskell esto sería muy similar:

    lst = [1,2] ++ [3,4]

En JavaScript puede definir funciones anónimas (funciones sin nombre) como:

    var f = función (x, y) {return x * y + x + y};

En Haskell, estas funciones anónimas se denominan funciones lambda y en realidad son la base del lenguaje. Nuevamente, la sintaxis es muy compacta:

    f = \ x y -> x * y + x + y

Finalmente, en muchos lenguaje, las funciones pueden operar en funciones. Por ejemplo, en Perl puede modificar los elementos en una lista usando:

    map sub ($x){$x*2+1}, [1..10]

Haskell proporciona muchas de estas llamadas funciones de orden superior y le permite definir las suyas propias.

    map (\x -> x*2+1) [1..10]

Prueba Haskell!

Probar Haskell es fácil.

Primero podemos usar nuestro navegador :  https://www.haskellmooc.co.uk , es un entorno interactivo de Haskell, ¡listo para usar!

Puede instalar el compilador / intérprete Haskell.

Vayamos a https://www.haskell.org/platform para obtener la plataforma Haskell, es muy fácil de instalar.

Luego de instalar haskell podemos utilizar el intérprete de Haskell ghci

Para iniciar el intérprete interactivo Haskell ghci, simplemente escriba ghci en su terminal:

[wim @ fp4 ~] $ ghci
GHCi, versión 7.8.3: http://www.haskell.org/ghc/:? por ayuda
Cargando paquete ghc-prim ... enlace ... hecho.
Cargando paquete integer-gmp ... enlace ... hecho.
Cargando la base del paquete ... enlazando ... hecho.
Preludio>
 - Evaluar una expresión -
Preludio> 3 + 4
7

Y Listo!!

Introducción a las expresiones y ecuaciones en Haskell

¡Haskell no tiene declaraciones, solo expresiones!

En un lenguaje imperativo como C o Java, hay expresiones que denotan cálculos a pequeña escala (2 * x), y declaraciones que manejan secuenciación, bucles, condicionales y toda la operación a gran escala del programa.

Los lenguajes de programación funcionales puros no tienen ningún enunciado: no hay asignaciones ni saltos. En cambio, todo el cálculo se realiza evaluando expresiones

Una expresión se evalúa como un resultado (generalmente escrito e⇝r pero usaremos e -> r). Haskell usa una notación similar para números y operadores como la mayoría de los lenguajes :

    2 -> 2
    3 + 4 -> 7
    3 + 4 * 5 {equivalente a 3+ (4 * 5)} -> 23
    (3 + 4) * 5 {equivalente a 7 * 5} -> 35

Los paréntesis se usan para agrupar, al igual que en matemáticas.

Los operadores tienen prioridad, p. ∗ tiene una precedencia "más estricta" que +, entonces 2 + 3 ∗ 4 significa 2 + (3 ∗ 4).

Las expresiones pueden contener llamadas a funciones.

Una función toma argumentos, realiza algunos cálculos y produce resultados.

La función abs da el valor absoluto de un número. Para usar una función, se aplica a un argumento. Escribe la función seguida del argumento, separada por un espacio.

  abs 5 -> 5
  abs (-6) -> 6

Los paréntesis son para agrupar

  2 + 3 * 5
  2+ (3 * 5): puede ser más claro para algunos lectores
  abs 7

Por ejemplo, min y max son funciones que toman dos argumentos. Los argumentos se dan después de la función, separados por espacios en blanco.

Escriba min 3 8, no escriba min (3, 8);

    min 3 8 -> 3
    max 3 8 -> 8

La aplicación de funciones se une más fuerte que cualquier otra cosa. Entonces f x + 3 significa (f x) + 3 y no f (x + 3). Si un argumento para una función es una expresión, se deberá poner entre paréntesis.

Las ecuaciones se usan para dar nombres a los valores. Por ejemplo:

respuesta = 42

Una ecuación en Haskell es una ecuación matemática: dice que el lado izquierdo y el lado derecho denotan el mismo valor. El lado izquierdo debe ser un nombre al que le estás dando un valor.

Correcto: x = 5 * y
Incorrecto: 2 * x = (3 * x) ** 2 - La reasignación no está permitida en un FPL puro

A un nombre solo se le puede dar un valor. Los nombres a menudo se denominan "variables", pero no varían.

En Haskell las variables son constantes!

    n = 1 - ¡bien!
    x = 3 * n - bien
    n = x - Incorrecto: solo puede tener una definición de n

Una vez que le da un valor a un nombre, ¡nunca podrá cambiarlo!

Esto es parte del significado de "puro" y "sin efectos secundarios"

¿Qué pasa con n = n + 1?

En idiomas imperativos, decimos con frecuencia n: = n + 1 ¡Esta es una tarea, no una ecuación! Significa (1) calcular el lado derecho, utilizando el antiguo valor de n; luego (2) descarte el antiguo valor de n y sobrescríbalo con el nuevo valor. No hay ecuaciones en lenguajes imperativos como C y Java.

En Haskell, es válido escribir n = n + 1. ¡Esta es una ecuación, no una tarea! Significa: calcular el valor de n que tiene la propiedad de que n = n + 1. Haskell lo intentará y fallará.

¿Cómo puedes calcular sin asignaciones?

Piense en una declaración de asignación como hacer tres cosas:
Evalúa el lado derecho: calcular un valor útil.
Descarta el valor de la variable en el lado izquierdo: destruye un valor que podría o no ser útil.
Guarda el valor útil del RHS en la variable.

En un lenguaje funcional puro Nunca destruimos viejos valores. Simplemente calculamos nuevos útiles.

Si el valor anterior era realmente inútil, el recolector de basura recuperará su almacenamiento.

Bootstrap + Vue = BootstrapVue

Te gusta Bootstrap y te gusta Vue entonces BootstrapVue es para vos!!

Como sabemos Bootstrap nos permite hacer aplicaciones web responsive y Vue es un framework front-end javascript que nos hace la vida muy fácil. Por ende con BootstrapVue podemos utilizar Vue con Bootstrap con los css de Bootstrap.

Con este framework utilizamos Bootstrap 4.

Como se instala? Primero que nada tengo que tener  instalado Vue y un proyecto creado. Si no saben como hacer esto pueden leer este post: https://emanuelpeg.blogspot.com/2020/04/como-instalar-vuejs.html

Luego tengo que instalar bootstrap-vue:

npm install bootstrap-vue

Y por ultimo, debemos registrar el complemento BootstrapVue como con las instrucciones del paquete web:

import Vue from 'vue'
import { BootstrapVue, BootstrapVueIcons } from 'bootstrap-vue'

import 'bootstrap/dist/css/bootstrap.css'
import 'bootstrap-vue/dist/bootstrap-vue.css'

Vue.use(BootstrapVue)
Vue.use(BootstrapVueIcons)

BootstrapVue fue librerado bajo licencia MIT.

Dejo link : https://bootstrap-vue.js.org/

Free ebook: Protecting Your Web Applications

Me llego el siguiente mail de  y quiero compartirlo con ustedes :

Hi Emanuel, Websites, applications, and online services are critical business assets, but they are also among the most vulnerable to attack. Successful cybersecurity attacks can cost your company customers, revenue, and reputation. Download this practical ebook to get an overview of today’s major threat patterns and the strategies and techniques you need to prevent and protect against a host of attacks. And did we mention it’s free, our gift to you?

DOWNLOAD THE EBOOK

The O’Reilly Team PS If you need to stay up to date on security (and who doesn’t?), take a look at O’Reilly online learning. You’ll get the latest information on security technologies and best practices, as well as security certification prep and practice exams, and more.

Funciones en Haskell

En Haskell las funciones se definen usualmente a través de una colección de ecuaciones. Por ejemplo, la función inc puede definirse por una única ecuación:

inc n = n+1

Una ecuación es un ejemplo de declaración. Otra forma de declaración es la declaración de tipo de una función o type signature declaration, con la cual podemos dar de forma explícita el tipo de una función; por ejemplo, el tipo de la función inc:

inc :: Integer -> Integer

Si a y b son dos tipos, entonces a->b es el tipo de una función que toma como argumento un elemento de tipo a y devuelve un valor de tipo b.

Las funciones en Haskell son ciudadanos de primera clase. Pueden ser argumentos o resultados de otras funciones o ser componentes de estructuras de datos. Esto permite simular mediante funciones de un único argumento, funciones con múltiples argumentos.

Por ejemplo, la función de suma (+) . En matemáticas se toma la suma como una función que toma una pareja de enteros y devuelve un entero. Sin embargo, en Haskell, la función suma tiene el tipo:

(+)::Int->(Int->Int)

(+) es una función de un argumento de tipo Int que devuelve una función de tipo Int->Int . De hecho "(+) 5" denota una función que toma un entero y devuelve dicho entero más 5. Este proceso se denomina currificación (en honor a Haskell B.Curry ) y permite reducir el número de paréntesis necesarios para escribir expresiones. De hecho, no es necesario escribir f(x) para denotar la aplicación del argumento x a la función x , sino simplemente f x .

Se podría escribir simplemente (+)::Int->Int->Int , puesto que el operador -> es asociativo a la derecha.

Como instalar vue.js ?

Vamos a instalar vue cli en Linux, yo tengo Fedora ahora, pero es medio lo mismo que con otros Linux o Windows o Mac.

Primero tenemos que instalar npm. Esto es muy fácil, hacemos en consola :

sudo dnf install nodejs

En fedora, CentOs, Red Hat y

sudo apt-get install nodejs

En Ubuntu, Debian, Mint, etc.

Instalado npm, ahora podemos instalar vue, como? así :

npm install -g @vue/cli

Ojo podemos utilizar yarn pero yo voy a utilizar npm.

Y listo!

Ahora podemos crear un proyecto, como? así :

vue create mi-proyecto

o de forma visual con:

vue ui

De forma visual, se abrirá un browser y podemos completar los datos.

Dejo link : https://cli.vuejs.org/

Tipos en Haskell parte 2

Seguimos con los tipos en Haskell : https://emanuelpeg.blogspot.com/2020/04/tipos-en-haskell.html

Me quedaron 2 post cortitos, medio que podría haber hecho 1, cosas que pasan.

En la definición de una función se puede incluir información de tipo mediante una expresión de la forma A::B para indicar al sistema que “A es de tipo B”. Por ejemplo:

cuadrado:: Int -> Int //no es necesario, pero es buena práctica
cuadrado x = x * x

La primera línea indica que la función cuadrado es del tipo "función que toma un entero y devuelve un entero".

Esto no es obligatorio dado que con la inferencia de tipos, haskell puede inferir esto. Pero, sí es una buena práctica, ya que el Haskell chequea que el tipo declarado coincide que el tipo inferido por el sistema a partir de la definición, permitiendo detectar errores de tipos.

Existen varios “tipos” predefinidos del sistema Haskell, éstos se podrían clasificar en: tipos básicos,
cuyos valores se toman como primitivos, por ejemplo, Enteros, Flotantes, Caracteres y Booleanos; y
tipos compuestos, cuyos valores se construyen utilizando otros tipos, por ejemplo, listas, funciones y
tuplas.

Complimentary O’Reilly Cassandra Book

Me llego este mail de un libro que estuve leyendo y esta muy bueno, de cassandra :

Hello Emanuel, 

Thanks for your recent interest in Apache Cassandra™, I’m here to help with any content resources to make you successful.

The newest edition of O’Reilly’s “Cassandra, The Definitive Guide” by Jeff Carpenter and Eben Hewitt is just out, here is a complimentary PDF.

Our community forum is also a good place to ask or answer questions.

Again, our mission is to help you be successful with Cassandra. I hope these are useful!

Best Regards,
Angela Young
angela.young@datastax.com | datastax.com

Conclusión nos regalan el libro que esta rebueno en ese link de arriba que es este : https://www.datastax.com/sites/default/files/content/ebook/2020-03/cassandra_ER.pdf?mkt_tok=eyJpIjoiWWpjeU4yVXdaalJoTVdOaCIsInQiOiJPSVplZ0I1M2MzXC9LcWZtbE8yaUZobTRBejh4YmFpMm45NlBVZkhncnJaa2E0UDJGRm9PUlBnS251NEpmbjNuMlMxZUhVN0dGSGR3UTR3ZFY5MjJTMUFHNENubkVNek5SdlhXUTBoWlpzVGdZK1loeit2aEVGTk1QdUFcL3dZZEpIIn0%3D

Tipos en Haskell

Haskell es un lenguaje de programación fuertemente tipado. Los tipos son penetrantes (pervasive), y presenta además un potente y complejo sistema de tipos. Si están familiarizados con Java, C, Modula, o incluso ML, el sistema de tipos de Haskell es diferente y algo más rico.

Una parte importante del lenguaje Haskell lo forma el sistema de tipos que es utilizado para detectar
errores en expresiones y definiciones de función.

El universo de valores es particionado en colecciones organizadas, denominadas tipos. Cada tipo tiene asociadas un conjunto de operaciones que no tienen significado para otros tipos, por ejemplo, se puede aplicar la función (+) entre enteros pero no entre caracteres o funciones.

Una propiedad importante del Haskell es que es posible asociar un único tipo a toda expresión bien
formada. Esta propiedad hace que el Haskell sea un lenguaje fuertemente tipado. Como consecuencia, cualquier expresión a la que no se le pueda asociar un tipo es rechazada como incorrecta antes de la evaluación.

Por ejemplo:
f x = 'A'
g x = x + f x

La expresión 'A' denota el carácter A . Para cualquier valor de x , el valor de f x es igual al caracter 'A' , por tanto es de tipo Char . Puesto que el (+) es la operación suma entre números, la parte derecha de la definición de g no está bien formada, ya que no es posible aplicar (+) sobre un carácter.

El análisis de los escritos puede dividirse en dos fases: Análisis sintáctico, para chequear la corrección sintáctica de las expresiones y análisis de tipo, para chequear que todas las expresiones tienen un tipo correcto.