Creo que GO es ahora mi lenguaje favorito

el

El lenguaje GO

Me estoy actualizando con las tendencias de TI tales como: Microservcies, Docker, NGINX, y entre estos me di cuenta que Docker está desarrollado en GO, lo que me hizo pensar que ha de ser un lenguaje muy potente, y en efecto así es.

GO es un lenguaje Open Source desarrollado por GOogle y una comunidad creciente de colaboradores. Al visitar el sitio https://golang.org/ no es de extrañarse encontrar el ejemplo de "Hola Mundo" o "Hello World!", para luego visitar el tour donde se aprecia la simplicidad y claridad del lenguaje.

Pero entre las características que más me llamaron la atención es que el compilador de GO genera binarios del sistema operativo y no intermediarios como el IL (Intermedia Language) de .NET o WARs de Java, lo que implica que no hace falta un Framework o un "runtime" o mucho menos un interprete como Python. Lo que hace que el resultado final sea muy potente.

Otra de las características impresionantes son las librerías de terceros, puesto que la instalación de GO para programar ya cuenta con librerías (Packages) estándar, las de terceros están disponibles en línea.

Por ejemplo una librería estándar es la de formato o "fmt" como se ve en el programa hola mundo.
package main

import "fmt"

func main() {
    fmt.Println("¡Hola Mundo!")
}

Ahora si por ejemplo se necesita hacer una conexión a una base de datos Mongo, existe una librería mux disponible en github, para la cual no hay necesidad de instalar nada, solamente importar el repositorio así:
import "github.com/gorilla/mux"

Al momento de compilar el programa que hace referencia a la librería, esta es importada a los paquetes de la instalación local de GO. También se puede importar manualmente con el CLI de Go.
(Nota: Mongo cuenta ya con su propia librería o driver para GO.) 

Mi primera incursión en GO

Tengo un script en Python que me sirve para apagar la PC despues de un tiempo determinado, me sirve para cuando veo una película tarde de la noche, o estoy descargando algo que se tardará 3 horas pero no quiero dejar la PC encendida toda la noche.

Básicamente ejecuta el comando "poweroff" del sistema operativo después del "delay" que le indico como parámetro, el script se resume a esto:
import os
import time
import sys

if __name__ == "__main__":
    mins = 0
    if len(sys.argv) > 1 :
        mins = int(sys.argv[1])
    t = 0 
    while (t < mins):
        print("Minuto {}".format(t))
        time.sleep(60)
        t = t + 1
    os.system("poweroff")

Y esta es la versión GO (https://github.com/markoaherrera/shutme)
package main

import (
  "fmt"
  "os"
  "os/exec"
  "time"
  "strconv"
)

func main() {

  args := os.Args[1:]

  sleepTime := args[0]

  minutes, convErr := strconv.Atoi(sleepTime)
  if convErr != nil { panic(convErr) }

  minute := 1
  for ; minute <= minutes; {
    fmt.Printf("\rMinute %d", minute)
    time.Sleep(1 * time.Minute)
    minute += 1
  }
  fmt.Printf("\nPowering off, bye!\n")

  cmd := exec.Command("poweroff")
  cmdErr := cmd.Run()
  if cmdErr != nil {
    panic(cmdErr)
  }

}

Es evidente que son muchas más líneas de código, pero hay más revisiones de errores, puesto que algunas funciones devuelven hasta dos valores en una sola llamada, como lo es la conversión a entero del parámetro de minutos con "strconv.Atoi"
  minutes, convErr := strconv.Atoi(sleepTime)
  if convErr != nil { 
    panic(convErr) 
  }

La función "strconv.Atoi" devuelve el valor convertido y una estructura que en caso de error es diferente a nulo (nil), que de ser así contiene la información del error. Ni la variable "minutes" ni "convErr" fueron previamente declaradas, estas son inferidas con el uso de ":=".

Finalmente, después de compilar la fuente "shutme.go" se produce el ejecutable "shutme", y para utilizarlo en otra PC solamente tengo que copiar el archivo "shutme" y ejecutarlo con  permisos de administrador para que apague la PC:
$ sudo shutme 60
Apaga la PC después de 60 minutos

En la PC donde fue copiado no tuve necesidad de instalar intermediarios, frameworks o runtimes, el único requisito es que el sistema operativo donde se va a ejecutar sea el mismo con el que se compiló, en este caso fue Linux (Ubuntu).

Conclusión

Go, o Golang, es idóneo en el contexto de microservices, donde los programas son muchos pero muy pequeños, el hecho de ser un binario puro hace que los programas sean ligeros y muy portables.

Go también es idóneo en el contexto de IoT, puesto que los dispositivos pueden ser muy escasos en recursos y montar un Framework puede ser contraproducente.

Vale la pena darle un vistazo, y por mi parte creo iré dejando por un lado a Python, mi lenguaje preferido para mis proyectos personales,  y estaré creando mis nuevas aplicaciones en GO.

Posdata

Dato curioso: GO no es un lenguaje orientado a objetos, es un lenguaje de programación imperativa.

Referencias

Comentarios

Publicar un comentario