Empezando con Python de nuevo!

Hace mucho mucho tiempo que no hago nada en python y por x motivo debo volver a programar en este lenguaje. Por suerte me tope con la pagina: http://www.python.org.ar/ . En la cual se puede encontrar muchos recursos para empezar y de muy buena calidad.

Aprendiendo Python

¡Felicitaciones! No todos los días se toma el coraje de adentrarse en un mundo desconocido para muchos y tan divertido para otros. Me pone muy contento que te haya surgido la inquietud de ver "¿de qué se trata esto de Python?" y hayas llegado a este sitio web.

Aquí podrás encontrar unos pequeños lineamientos que te pueden ser de gran ayuda a la hora de aprender a programar en Python. Incluso, si no tienes conocimiento alguno de programación.

Antes que nada, algunos consejos para que no te desanimes en el camino del aprendizaje y te resulte más sencillo:

• Programar es muy divertido, pero como cualquier otra disciplina: lleva tiempo.
• A diferencia de otros lenguajes de programación, Python tiene una curva de aprendizaje mucho más rápida, lo cual te permitirá obtener resultados casi de inmediato.
• Al fin y al cabo, era mucho más fácil aprender a programar (y mantenerse actualizado) si se dominaba, al menos, un nivel básico de Inglés.
• Cualquiera puede aprender a programar. ¡Sí, cualquiera! No hay que ser un genio ni un maestro en nada. Yo pude, ;)
• En el camino, aprenderás a investigar y a resolver problemas por tu propia cuenta. Simplemente, con una conexión a Internet y leyendo varios foros/listas de correo o preguntando en diferentes canales de chat.
• ¡Sí, eso! Suscríbete a la lista de correo de tu región para así poder hacerle preguntas a otras personas que tienen más experiencia en el tema y siempre tienen ganas de ayudar.

¡Ahora sí, vamos a lo importante y centrémonos en aprender!

La teoría es cuando creés saber algo pero no anda. La práctica es cuando algo funciona pero no sabés porqué. El programador combina ambas: nada anda y no sabe porqué.

Einstein + Anónimo

Antes de empezar a leer fuertemente los libros o tutoriales que te recomendamos aquí, me parece muy bueno pegarle una primera ojeada a algunos de ellos (los que más te llamen la atención) y en base a eso, determinar cuál puede ser más divertido y entusiasmante empezar a leer. Incluso, ¡hay algunos que son interactivos y están buenísimos!

¿Por dónde empezar?

No sé nada de Python, ni de programación, y quiero empezar desde lo más básico:

• El Tutorial de Python en Español (PDF)
• Aprenda a pensar como un programador con Python
• Python (curso interactivo en Code Academy)
• Aprender python

¿Por dónde seguir?

Tengo algún conocimiento en programación, o incluso en Python, y quiero leer algo un poquito más avanzado:

• Inmersión en Python 3 (PDF)
• El tutorial de Django (PDF)

Me manejo con el Inglés

Tengo un dominio básico de lectura en inglés.

• How to Think Like a Computer Scientist (Interactive edition)
• Learn Python: The hard way
• Dive into Python 3 (PDF)
• Automate the Boring Stuff with Python

Soy científico y quiero analizar mis datos

Pertenezco al mundo de las ciencias de alguna manera: biología, química, genética, matemática, física, <coloque aquí su ciencia preferida> y quiero aprender a utilizar Python, por ejemplo, para analizar un enorme conjunto de datos de una forma automatizada.

• Introducción a Python para científicos e ingenieros (curso en línea)

---

Muchísimo más material!

¡Me re copé con Python, leí un montón de cosas y ahora quiero rockearla!

Aquí listamos todo el material excedente que consideramos muy útil para seguir con el estudio de Python y la programación, pero que quizás desorienta un poco al principio. En esta sección podés encontrar otras guías similares a esta, más herramientas y módulos, documentación que se encuentra en progreso y diferentes tutoriales orientados a públicos distintos.

• Byte of Python es un libro para iniciarse en Python, el autor proclama que es para quien lo unico que sabe de computación es grabar un archivo. Actualmente cuenta con ediciones para Python 2.x y 3.
• Instant Python es un curso de entrenamiento corto e intensivo. (Versión en español).
• Python Ya Python desde cero. Tutorial web interactivo. Permite escribir y ejecutar nuestros programas directamente en la página, sin necesidad de tener Python instalado.
• Tutor para No-Programadores Josh Cogliati 1999-2002 - Traducción Victor M. Rosas Garcia.
• Python no muerde - Roberto Alsina
• Python para todos Raúl González Duque
• El libro de Web2py en español
• El wiki oficial de Apache OpenOffice - Como crear macros con Python

Empezando con Elixir 10

Mix

Antes de que podamos sumergirnos en las aguas más profundas de Elixir, primero tenemos que aprender Mix. Si está familiarizado con Ruby, Mix es Bundler, RubyGems y Rake combinados. Es una parte crucial de cualquier proyecto de Elixir y en esta lección vamos a explorar solo algunas de sus excelentes características.


Hasta ahora hemos estado trabajando exclusivamente dentro de iex, que tiene limitaciones. Para construir algo sustancial necesitamos dividir nuestro código en muchos archivos para administrarlo efectivamente; Mix nos permite hacer eso con proyectos.

Proyectos

Para hacer un nuevo proyecto debemos hacer :

$ mix new example

De la salida podemos ver que Mix ha creado nuestro directorio y una serie de archivos:

* creating README.md
* creating .gitignore
* creating mix.exs
* creating config
* creating config/config.exs
* creating lib
* creating lib/example.ex
* creating test
* creating test/test_helper.exs
* creating test/example_test.exs

Vamos a centrarnos mix.exs. Aquí configuramos nuestra aplicación, dependencias, entorno y versión. Vamos abrir este archivo :

defmodule Example.Mixfile do
  use Mix.Project

  def project do
    [app: :example,
     version: "0.0.1",
     elixir: "~> 1.1-dev",
     build_embedded: Mix.env == :prod,
     start_permanent: Mix.env == :prod,
     deps: deps]
  end

  # Configuration for the OTP application
  #
  # Type `mix help compile.app` for more information
  def application do
    [applications: [:logger]]
  end

  # Dependencies can be Hex packages:
  #
  #   {:mydep, "~> 0.3.0"}
  #
  # Or git/path repositories:
  #
  #   {:mydep, git: "https://github.com/elixir-lang/mydep.git", tag: "0.1.0"}
  #
  # Type `mix help deps` for more examples and options
  defp deps do
    []
  end
end

La primera sección es project. Aquí definimos el nombre de nuestra aplicación (app), especificamos nuestra versión (version), versión de Elixir (elixir) y finalmente nuestras dependencias (deps).

En application configuramos settings que se usa durante la generación de nuestro archivo de aplicación.

Interactivo

Puede ser necesario usar iex dentro del contexto de nuestra aplicación. Afortunadamente para nosotros, Mix lo hace fácil. Podemos comenzar una nueva sesión iex:

$ iex -S mix

Iniciar iex de esta manera cargará la aplicación y dependencias en el tiempo de ejecución.

Compilacion

Mix es inteligente y compilará los cambios cuando sea necesario. Para compilar de forma manual un proyecto Mix solo necesitamos ejecutar la compilación de Mix en nuestro directorio base:

$ mix compile

si se compilo con exito retornará :

Compiled lib/example.ex

Generated example app

Cuando compilamos un proyecto Mix crea un directorio _build para nuestros artefactos. Si miramos dentro de _build veremos nuestra aplicación compilada: example.app.

Administrar dependencias

Nuestro proyecto no tiene dependencias, pero lo hará en breve, así que seguiremos adelante y cubriremos las dependencias definitorias y las buscaremos.

Para agregar una nueva dependencia, primero debemos agregarla a nuestra mix.exs en la sección deps. Nuestra lista de dependencias se compone de tuplas con dos valores obligatorios y uno opcional: el nombre del paquete como un átomo, la cadena de versión y opciones.

Para este ejemplo, veamos un proyecto con dependencias, con phoenix_slim:

def deps do

  [

    {:phoenix, "~> 1.1 or ~> 1.2"},

    {:phoenix_html, "~> 2.3"},

    {:cowboy, "~> 1.0", only: [:dev, :test]},

    {:slime, "~> 0.14"}

  ]

end

La dependencia cowboy solo es necesaria durante el desarrollo y la prueba.

Una vez que hemos definido nuestras dependencias, hay un último paso: obtenerlas. Esto es análogo a la instalación del paquete:

$ mix deps.get

Hemos definido y buscado nuestras dependencias de proyectos. 

Entornos

Mix, al igual que Bundler, admite diferentes entornos. Mix funciona con tres entornos:

• :dev - El entorno predeterminado.
• :test - Usado por la prueba de mezcla. Cubierto más en nuestra próxima lección.
• :prod - se usa cuando enviamos nuestra aplicación a producción.

Se puede acceder al entorno actual utilizando Mix.env. Como se esperaba, el entorno se puede cambiar a través de la variable de entorno MIX_ENV:

$ MIX_ENV=prod mix compile

Comparando F# con C# parte 3

Vamos ha hacer un programa que baje una pagina en F# y en C# para comparar.

Veamos la implementación en F# :

// open es similar al using
open System.Net
open System
open System.IO

// Obtener los contenidos de una página web
let fetchUrl callback url =     
    let req = WebRequest.Create(Uri(url))
    use resp = req.GetResponse()
    use stream = resp.GetResponseStream()
    use reader = new IO.StreamReader(stream)
    callback reader url

Repasemos este código:

• El "open" en la parte superior nos permite escribir "WebRequest" en lugar de "System.Net.WebRequest". Es similar a un encabezado "using System.Net" en C#.
• A continuación, definimos la función fetchUrl, que toma dos argumentos, un callback para procesar la pagina y la URL a buscar.
• Luego, creamos una Uri con la URL. F# tiene una estricta comprobación de tipos, por lo tanto, si en  hubiéramos escrito: let req = WebRequest.Create(url), el compilador se habría quejado de que no sabía qué versión de WebRequest.Create usar.
• Al declarar los valores de respuesta, transmisión y lectura, se usa la palabra clave "use" en lugar de "let". Esto solo se puede usar junto con las clases que implementan IDisposable. Le dice al compilador que elimine automáticamente el recurso cuando se sale del alcance. Esto es equivalente a la palabra clave "using" C#.
• La última línea llama a la función callback con StreamReader y la url como parámetros. Note que nunca especificamos el timpo del callback. 

Ahora veamos la implementación equivalente de C#:

class WebPageDownloader
{
    public TResult FetchUrl<TResult>(
        string url,
        Func<string, StreamReader, TResult> callback)
    {
        var req = WebRequest.Create(url);
        using (var resp = req.GetResponse())
        {
            using (var stream = resp.GetResponseStream())
            {
                using (var reader = new StreamReader(stream))
                {
                    return callback(url, reader);
                }
            }
        }
    }
}

Como de costumbre, la versión C # tiene más 'ruido'.

• Hay diez líneas solo para llaves, y existe la complejidad visual de 5 niveles de anidación *
• Todos los tipos de parámetros deben declararse explícitamente, y el tipo TResult genérico debe repetirse tres veces.

Podemos probar el codigo de la siguiente manera : 

let myCallback (reader:IO.StreamReader) url = 

    let html = reader.ReadToEnd()

    let html1000 = html.Substring(0,1000)

    printfn "Downloaded %s. First 1000 is %s" url html1000

    html      // return all the html

//test

let google = fetchUrl myCallback "http://google.com"

Finalmente, tenemos que recurrir a una declaración de tipo para el parámetro del lector (reader:IO.StreamReader). Esto es necesario porque el compilador F# no puede determinar el tipo del parámetro "reader" automáticamente.

Una característica muy útil de F# es que puede "pasar" parámetros en una función para que no tengan que pasarse en todo momento. Esta es la razón por la que el parámetro url se colocó en último lugar en lugar de primero, como en la versión de C#. La devolución de llamada se puede configurar una vez, mientras que la URL varía de llamada a llamada.

// build a function with the callback "baked in"

let fetchUrl2 = fetchUrl myCallback 

// test

let google = fetchUrl2 "http://www.google.com"

let bbc    = fetchUrl2 "http://news.bbc.co.uk"

// test with a list of sites

let sites = ["http://www.bing.com";

             "http://www.google.com";

             "http://www.yahoo.com"]

// process each site in the list

sites |> List.map fetchUrl2 

La última línea (usando List.map) muestra cómo la nueva función se puede usar fácilmente junto con las funciones de procesamiento de listas para descargar una lista completa a la vez.

Aquí está el código de prueba C# equivalente:

[Test]

public void TestFetchUrlWithCallback()

{

    Func<string, StreamReader, string> myCallback = (url, reader) =>

    {

        var html = reader.ReadToEnd();

        var html1000 = html.Substring(0, 1000);

        Console.WriteLine(

            "Downloaded {0}. First 1000 is {1}", url,

            html1000);

        return html;

    };

    var downloader = new WebPageDownloader();

    var google = downloader.FetchUrl("http://www.google.com",

                                      myCallback);

            

    // test with a list of sites     var sites = new List<string> {

        "http://www.bing.com",

        "http://www.google.com",

        "http://www.yahoo.com"};

    // process each site in the list   
   sites.ForEach(site => downloader.FetchUrl(site, myCallback));

}

De nuevo, el código tiene más ruido que el código F#, con muchas referencias explícitas de tipo. Lo que es más importante, el código C# no le permite pasar fácilmente algunos de los parámetros en una función, por lo que la devolución de llamada se debe referenciar explícitamente cada vez.

Dejo link: https://fsharpforfunandprofit.com/posts/fvsc-download/

Encuesta de ecosistemas de Desarrolladores

El año pasado, en JetBrains realizamos una Encuesta de Ecosistemas de Desarrolladores para comprender mejor a los desarrolladores y sus necesidades en todo el mundo. 9,000 encuestados en todo el mundo nos dieron sus comentarios, y compartieron los datos más interesantes (así como datos brutos anonimizados) con la comunidad.

Este año estan haciendo otra encuesta, Developer Ecosystem Survey 2018, y necesitan tu ayuda nuevamente.

Y completando esta encuesta de 20 minutos tendremos la oportunidad de ganar un valioso premio: $ 1,000 para su educación, un certificado de Amazon de $ 100 o un paquete de regalo de sorpresa de JetBrains.

Como siempre, los ganadores serán elegidos al azar. Es bueno proporcionar respuestas significativas a las preguntas de la encuesta.

Dejo link: https://surveys.jetbrains.com/s3/c4-DevEcosystem18?gclid=EAIaIQobChMIy8HhiOXO2AIVVFMMCh3WCAQCEAEYASAAEgKnwvD_BwE

Lenguajes de programación para aprender en 2018

Quiero compartir un excelente articulo sobre lenguajes de programación en 2018 (es decir este año)

Si bien el articulo no presenta mayor sorpresa, lista los lenguajes más populares de 2017 y que seguirán fuerte en 2018. Ojo aparece Scala (esto me llamo mucho la atención)

Yo empece el año con Crystal y se lo recomiendo porque esta muy bueno el lenguaje.

Dejo link: https://platzi.com/blog/lenguajes-de-programacion-2018/?utm_source=facebook&utm_medium=paidsocial&utm_campaign=pubetapa0

Juego de Serie en Crystal

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente, para cumplirlo vamos a utilizar las ventajas de herencia y polimorfismo.

Vamos a desarrollar este juego en Crystal :

Comencemos haciendo un nuevo proyecto:

crystal init app secuenciaCrystal
cd secuenciaCrystal

y luego probamos compilar :

shards build

Y todo debería funcionar. 

Ahora utilizaremos visual code con un plugin para crystal, para importar el proyecto, vamos a abrir carpeta y seleccionamos la carpeta donde estamos trabajando : 

Ahora vamos a hacer un archivo secuencia.cr que va a tener las clases de secuencias:


abstract class Secuencia

  @secuencia : Array(Int32)

  getter secuencia

  def initialize()
    @secuencia = generarSecuencia()
  end

  abstract def generarSecuencia() : Array(Int32)

end

class SecuenciaPar < Secuencia

  def generarSecuencia() : Array(Int32)
     Array(Int32).new(4) { |i|
       i * 2 * rand(100) + rand(10) * 2
     }

  end

end

class SecuenciaInPar < Secuencia

  def generarSecuencia() : Array(Int32)
    Array(Int32).new(4) { |i|
       i * 2 * rand(100) + rand(10) * 2 + 1
    }
  end

end

Luego hacemos otro archivo para juego:

require "./secuencia.cr"

class Juego

  getter puntos

  @secuencia : Secuencia

  def initialize()
    @puntos = 0
    @secuencia = generarSecuencia()
  end

  def generarSecuencia() : Secuencia
    i = rand(2)

    case i
        when 0
          SecuenciaPar.new
        else
          SecuenciaInPar.new
    end
  end

  def valor1()
    @secuencia.secuencia[0]   
  end

  def valor2()
    @secuencia.secuencia[1]   
  end

  def valor4()
    @secuencia.secuencia[3]   
  end

  def esta_bien?(num : Int32?) : Bool
    if @secuencia.secuencia[2] == num
       @puntos = @puntos + 1
       @secuencia = generarSecuencia()
       true
    else
       @puntos = @puntos - 1
       @secuencia = generarSecuencia()
       false
    end
  end

end

Y por ultimo tenemos el programa propiamente dicho:

require "./secuenciaCrystal/*"
require "./juego.cr"


module SecuenciaCrystal
  puts "Bienvenido a Secuancia Crystal"
  juego = Juego.new
  while true
    puts juego.valor1.to_s + " " + juego.valor2.to_s + " ______ " + juego.valor4.to_s + " \n"
    puts "Ingere el valor \n"
   
    valorStr = gets.to_s
   
    valor = (valorStr).to_i32

    if juego.esta_bien?(valor)
      puts " Ganaste !! Tus puntos : " + juego.puntos.to_s
    else
      puts " Perdiste !! Tus puntos : " + juego.puntos.to_s
    end
    puts "Ingere 0 para salir y otro valor para continuar"
    if gets()  == "0"
      break
    end

  end
  puts "Bye!"
end

Como se puede apreciar el diseño del juego permite generar una interfaz de consola o gráfica o en otra tecnología esta es la mayor ventaja de separar nuestros objetos de la capa de presentación.

Funcionando es muy divertido:

Dejo el repo: https://github.com/emanuelpeg/secuenciaCrystal

Primeros pasos con Crystal parte 2

Instalado el compilador y probado. Podemos empezar a hacer nuestro primer proyecto.

Para poder continuar el post con un ide un poco más comoda que nano, voy a usar el visual code con un pluging para Crystal. Es muy fácil instalar esto, van a complementos y buscan Crystal :

Si conocen otra IDE mejor, por favor comenten. Gracias.

Ahora voy a la consola y voy hacer mi proyecto:

crystal init app MiPrimerApp

Esto creo todo un proyecto ya listo para usar con git y con dependencias, versión y todo lo necesario :

Por ahora y solo por ahora, vamos a hacer un "Hola mundo" . Editamos MiPrimerApp.cr y escribimos:

require "./MiPrimerApp/*"

module MiPrimerApp
  puts "Hola Mundo"
end

Luego en la consola entramos en la carpeta MiPrimerApp

cd MiPrimerApp

Ahora a ejecutar:

crystal deps

Para resolver las dependencias

crystal docs

Para generar la documentación. 

shards build

Para compilar todo. (luego hablaremos de shards)

Si todo fue bien, podemos entrar a la carpeta bin y ejecutar nuestra aplicación: 

 cd bin/

./MiPrimerApp 

Y listo!!

Primeros pasos con Crystal

Ya instalado Crystal, vamos a comenzar haciendo un "Hola mundo"

Para hacer un ejemplo rápido vamos a utilizar la consola.

Primero con nano, vamos a hacer nuestro archivo que debe tener extensión .cr :

nano holaMundo.cr

Luego vamos a programar el hola mundo : 

puts "Hola Mundo"

Luego salimos y guardamos.

Ahora vamos a compilar y ejecutar: 

crystal holaMundo.cr

Si solo queremos ejecutar podemos hacer : 

crystal run holaMundo.cr 

Para generar un ejecutable debemos hacer : 

crystal build holaMundo.cr

Luego podemos ejecutar nuestro programa con : 

./holaMundo

Por defecto, los archivos ejecutables generados no están completamente optimizados. Para activar optimizaciones, se debe usar --release

crystal build holaMundo.cr --release

Si queremos no solo trabajar con un solo archivo sino hacer proyectos debemos utilizar el comando init pero eso sera en otro post. 

Dejo link: https://crystal-lang.org/docs/using_the_compiler/

Instalar Crystal en Linux

Para instalar Crystal en Linux es muy fácil.

Vamos por pasos:

Primero, debe agregar el repositorio a su configuración APT. Podemos hacerlo con este comando:

curl https://dist.crystal-lang.org/apt/setup.sh | sudo bash

Eso agregará la clave de firma y la configuración del repositorio. Si queremos hacerlo manualmente, ejecutamos los siguientes comandos como root:

apt-key adv --keyserver keys.gnupg.net --recv-keys 09617FD37CC06B54
echo "deb https://dist.crystal-lang.org/apt crystal main" > /etc/apt/sources.list.d/crystal.list
apt-get update

Una vez que el repositorio está configurado, estamos listo para instalar Crystal:

sudo apt-get install crystal

Algunas veces necesitará instalar el paquete build-essential para ejecutar o construir programas Crystal. Puedes instalarlo con el comando:

sudo apt-get install build-essential

Y Listo!!

Dejo link: https://crystal-lang.org/docs/installation/on_debian_and_ubuntu.html

Ruby + C = Crystal

Imaginate un lenguaje con la potencia de C pero la sintaxis de Ruby. En resumen eso es Crystal, un lenguaje con chequeo de tipos y sintaxis similar a Ruby.

Veamos un ejemplo:

# A very basic HTTP server
require "http/server"

server = HTTP::Server.new(8080) do |context|
  context.response.content_type = "text/plain"
  context.response.print "Hello world, got #{context.request.path}!"
end

puts "Listening on http://127.0.0.1:8080"
server.listen

Este pequeño ejemplo hemos montado un servidor web con una página de ejemplo.

Crystal tiene chequeo de tipo forma estática, por lo que el compilador detectará cualquier tipo de error antes de que falle en el tiempo de ejecución. Además, y para mantener el lenguaje limpio, Crystal tiene inferencia de tipos, por lo que no es necesario indicar el tipo la mayoría de las veces.

def shout(x)
  # Notice that both Int32 and String respond_to `to_s`
  x.to_s.upcase
end

foo = ENV["FOO"]? || 10

typeof(foo) # => (Int32 | String)
typeof(shout(foo)) # => String

Los tipos no permiten null y las variables nullable se representan como una unión entre el tipo y null. Como consecuencia, el compilador comprobará automáticamente si hay referencias nulas en tiempo de compilación.

if rand(2) > 0
  my_string = "hello world"
end

puts my_string.upcase

Si corremos esto :

$ crystal hello_world.cr
Error in hello_world.cr:5: undefined method 'upcase' for Nil (compile-time type is (String | Nil))

puts my_string.upcase

Crystal posee un potente sistema de macro , que abarca desde la inspección básica de plantillas y AST hasta la inspección de tipos y la ejecución de programas externos arbitrarios.

class Object
  def has_instance_var?(name) : Bool
    {{ @type.instance_vars.map &.name.stringify }}.includes? name
  end
end

person = Person.new "John", 30
person.has_instance_var?("name") #=> true
person.has_instance_var?("birthday") #=> false

Crystal usa hilos verdes, llamados fibras, para lograr concurrencia. Las fibras se comunican entre sí mediante canales, como en Go o Clojure, sin tener que recurrir a la memoria compartida o bloqueos.

channel = Channel(Int32).new
total_lines = 0
files = Dir.glob("*.txt")

files.each do |f|
  spawn do
    lines = File.read(f).lines.size
    channel.send lines
  end
end

files.size.times do
  total_lines += channel.receive
end

puts total_lines

Crystal tiene una sintaxis dedicada para llamar fácilmente a bibliotecas nativas, eliminando la necesidad de volver a implementar tareas de bajo nivel.

# Fragment of the BigInt implementation that uses GMP
@[Link("gmp")]
lib LibGMP
  alias Int = LibC::Int
  alias ULong = LibC::ULong

  struct MPZ
    _mp_alloc : Int32
    _mp_size : Int32
    _mp_d : ULong*
  end

  fun init_set_str = __gmpz_init_set_str(rop : MPZ*, str : UInt8*, base : Int) : Int
  fun cmp = __gmpz_cmp(op1 : MPZ*, op2 : MPZ*) : Int
end

struct BigInt < Int
  def initialize(str : String, base = 10)
    err = LibGMP.init_set_str(out @mpz, str, base)
    raise ArgumentError.new("invalid BigInt: #{str}") if err == -1
  end

  def <=>(other : BigInt)
    LibGMP.cmp(mpz, other)
  end
end

Las bibliotecas de Crystal se empaquetan como fragmentos y se distribuyen a través de Git sin necesidad de un repositorio centralizado. Los comandos incorporados permiten que las dependencias se especifiquen fácilmente a través de un archivo YAML y se obtengan de sus respectivos repositorios.

name: my-project
version: 0.1
license: MIT

crystal: 0.21.0

dependencies:
  mysql:
    github: crystal-lang/crystal-mysql
    version: ~> 0.3.1

Esto es solo un post de muestra. Para empezar de lleno vamos a tener que instalar el lenguaje y luego a estudiar, pero esos serán otros post.

Dejo link: https://crystal-lang.org/
https://github.com/crystal-lang/crystal/

10 ebook populares del 2017

Me llego este mail y como la mayoría de los libros son gratuitos, lo quiero compartir:

Download the Top 10 eBooks!     10) Getting Started with Git Find out what sets Git apart from the more traditional, centralized version controls systems and how it can work for you. Since its inception in 2005, Git continues to grow as the de facto standard for version control in both local and distributed environments. With its beginnings rooted in the open source community, and Linus Torvald’s original authorship, Git’s many features encompass social-driven collaboration that exceeds that of other version control systems.       9) An Introduction to AWS Security AWS is an incredibly rich ecosystem of services and tools, some of which have security aspects baked in (like S3 SSE), and others that provide overarching security capabilities (like IAM and VPC) that apply to many services. With regard to data storage, operating system, and applications, security functions largely the same in the cloud or on-premises software. Customers can and should continue to follow best practices that have served them well in their own data centers.       8) Contemporary Cryptography These slides are intended for computer scientist, electrical engineers, and mathematicians both in research and practice. Cryptography is an enabling technology (or tool) to secure the information infrastructures we build, use, and count on in daily life. Computer scientists, electrical engineers, and applied mathematicians should care about (and be educated in) the principles and applications of cryptography. Download these slides from Prof. Dr. Rolf Oppliger to help continue your Cryptography research.       7) Evolving Along with the Internet of Things The Internet of Things (IoT) is more than a network of smart toasters, refrigerators, and thermostats. They represent just the tip of a very large and mostly invisible iceberg, and the data the IoT generates makes an integrated data strategy more vital than ever. Using that data to produce actionable insights will require fast, accurate, reliable, and scalable infrastructure and processes. This O'Reilly white paper from Teradata looks at why the Internet of Things integrated data strategy more vital than ever.       6) Learn Linux in 5 Days If you want to learn how to use Linux and level up your career but are pressed for time, read on. In this eBook, you will learn the most important concepts and commands, and be guided step-by-step through several practical and real-world examples. As new concepts, commands, or jargon are encountered they are explained in plain language, making it easy to understand. The most important material is condensed into five sections, each designed to be consumed in a day.       5) Amazon Web Services: An Overview There's a great chance that AWS has more than a few products to help you work faster, smarter, and more cost effectively. So, where should you start? Getting a clear understanding of what Amazon Web Services (AWS) is and how it can help your business can be a daunting task. The depth and breadth of AWS is significant, comprising more than 48 services in dozens of data centers located at 11 Regions throughout the globe. They offer computing, storage, networking, deployment, management, and a host of supporting services like queues and email.       4) Dive Into Python (Free 328p. eBook) Python from novice to pro: Whether you're an experienced programmer looking to get into Python or grizzled Python veteran who remembers the days when you had to import the string module, Dive Into Python is your 'desert island' Python book.       3) The Beginners Guide to NoSQL Take advantage of noSQL by learning the basics and more with this FREE eBook. We are storing more data now than we ever have before and connections between our data are growing all the time. We don't make things knowing the structure from day one. Server architecture is now at a stage where we can take advantage of it.       2) Jump Start GIT ($30 Value, FREE) Take control of your code and assets with this descriptive FREE eBook. This book includes: An outline of the philosophy of version control, Exploring Git through the basics and command line, Using Git in a team environment, The "branching" option of Git, Specific tools for efficiency, Examining GUI tools, Using Git for purposes other than code versioning.       1) Learning Python Learn to code like a professional with Python - an open source, versatile, and powerful programming language. Learning Python has a dynamic and varied nature. It reads easily and lays a good foundation for those who are interested in digging deeper. Starting with the fundamentals of programming and Python, it ends by exploring very different topics, like GUIs, web apps and data science. The book takes you all the way to creating a fully fledged application.

Comparando F# con C# parte 2

Ahora, implementaremos un el algoritmo quicksort para ordenar listas y lo haremos en F# y C# para compararlos.

Para el que no conoce el algoritmo quicksort, vamos a ver la lógica:

Si la lista está vacía, no hay nada que hacer.
De otra manera:

1. Tome el primer elemento de la lista, que lo llamaremos pivot
2. Buscamos todos los elementos menores al pivot y los ordenamos usando el algoritmo quicksort.
3. Buscamos todos los elementos mayores al pivot y los ordenamos usando el algoritmo quicksort.
4. Combinamos las tres partes para obtener el resultado final: (elementos menores + pivot + elementos mayores)

Tenga en cuenta que hemos simplificado este algoritmo para hacer la explicación más simple.

Veamos el código en F#:

let rec quicksort list =

   match list with

   | [] ->                            // Si la lista es vacia

        []                            // retorna una lista vacia

   | firstElem::otherElements ->      // si no es vacia

        let smallerElements =         // toma los menores

            otherElements             

            |> List.filter (fun e -> e < firstElem) 

            |> quicksort              // y los ordena

        let largerElements =          // toma los mayores 

            otherElements 

            |> List.filter (fun e -> e >= firstElem)

            |> quicksort              // y los ordena

        // concatena estas 3 partes y la retorna. 

        List.concat [smallerElements; [firstElem]; largerElements]

//test

printfn "%A" (quicksort [1;5;23;18;9;1;3])

Repasemos el código:

No hay declaraciones de tipos en ningún lado. Esta función funcionará en cualquier lista que tenga elementos comparables (que es casi todos los tipos F#, ya que automáticamente tienen una función de comparación predeterminada).
Toda la función es recursiva: esto se señala al compilador utilizando la palabra clave rec en "let rec quicksort list =".
Con  match..with se esta usando pattern matching, las expresiones son como esta:

match x with
| caseA -> something
| caseB -> somethingElse

El pattern matching es una técnica que analiza objetos y ejecuta el código que corresponde (cuando el objeto aplica le patron)

De esta manera se pregunta si la lista es vacía, y si es vacía se retorna una lista vacía.
De lo contrario, aplica la lógica descrita anteriormente. Es decir filtra la lista de los menores por medio de una función anónima que se pasa como clausura, que indica como se va a filtrar y luego se ordena utilizando quicksort, luego filtra la lista de los mayores y los ordena .  Y por ultimo se retorna la concatenación de estas 3 partes.                                                                                                     ,

Veamos la implementación en C# sin LinQ :

public class QuickSortHelper
{
   public static List<T> QuickSort<T>(List<T> values)
      where T : IComparable
   {
      if (values.Count == 0)
      {
         return new List<T>();
      }
     // Tomamos el primer valor
     T firstElement = values[0];
     // Filtramos los elementos
      var smallerElements = new List<T>();
      var largerElements = new List<T>();

      for (int i = 1; i < values.Count; i++)   {
 
         var elem = values[i];
 
         if (elem.CompareTo(firstElement) < 0)
         {
            smallerElements.Add(elem);
         }
         else
         {
            largerElements.Add(elem);
         }
      }

      result.AddRange(QuickSort(smallerElements.ToList()));
      result.Add(firstElement);
      result.AddRange(QuickSort(largerElements.ToList()));
      return result;
   }
}

Comparando los dos programas, nuevamente podemos ver que el código F# es mucho más compacto, con menos ruido y sin necesidad de declaraciones de tipo.

Además, el código F# se lee casi exactamente como es algoritmo, a diferencia del código C#. Esta es otra ventaja clave de F# - el código es generalmente más declarativo ("qué hacer") y menos imperativo ("cómo hacerlo") que C#, y por lo tanto es mucho más autodocumentado.

Veamos una versión más funcional en C#:

public static class QuickSortExtension
{
     public static IEnumerable<T> QuickSort<T>(
        this IEnumerable<T> values) where T : IComparable
    {
        if (values == null || !values.Any())
        {
            return new List<T>();
        }

        var rest = values.Skip(1);
                .Where(i => i.CompareTo(firstElement) < 0)
                .QuickSort();

        var largerElements = rest
                .Where(i => i.CompareTo(firstElement) >= 0)
                .QuickSort();
     
        return smallerElements
            .Concat(new List<T>{firstElement})
            .Concat(largerElements);
    }
}

Esto es mucho más limpio, y lee casi lo mismo que la versión F#.

Finalmente, el código F# a menudo funciona la primera vez, mientras que el código C# puede requerir más depuración.

Pero incluso la ultima versión funcional C# tiene inconvenientes en comparación con la versión F#. Por ejemplo, como F# usa la coincidencia de patrones, no es posible derivar al caso de la "lista no vacía" con una lista vacía.

Dejo link: https://fsharpforfunandprofit.com/posts/fvsc-quicksort/