GUIs y Frameworks en golang

Para poder hacer apps en golang, tendremos que utilizar alguna librería, toolkit, framework o como desee llamarle claro, en caso de sí no deseas hacerla desde 0 y perder tiempo.

La interfaz gráfica de usuario, conocida también como GUI (del inglés graphical user interface), es un programa informático que actúa de interfaz de usuario, utilizando un conjunto de imágenes y objetos gráficos para representar la información y acciones disponibles en la interfaz.

https://es.wikipedia.org/wiki/Interfaz_gr%C3%A1fica_de_usuario

En golang tenemos una gran variedad de GUIs para apps tanto de escritorio y movil como framework para web.

Escritorio

En esta seccion veremos las guis para escritorio y también móvil.

Fyne

Es un kit de herramientas UI(user interface) y API facil de usar escrita en Go, esta diseñada para crear aplicaciones que corran tanto en escritorio como movile.

Licencia: BSD-3-Clause License

OS: cross-platform (windows, linux, Mac OS ,andriod OS)

therecipe/qt(Qt)

Es un widget toolkit opensource para crear UIs graficas como aplicaciones cross-platform que es capaz de correr en varias plataformas de software y hardware.

Licencia: LGPL-3.0 License

OS: cross-platform

lxn/walk (Walk)

Es una kit de Libreria de aplicaciones de Windows para el lenguaje de programacion Go. Esta pensado para el desarrollo de GUIs de escritorio

License: https://github.com/lxn/walk/blob/master/LICENSE

os: windows

zserge/lorca(Lorca)

Una librería pequeña para crear apps de escritorio modernas con HTML y GO. Utiliza el navegador Chrome como capa UI.

Licencia: MIT License

OS: cross-plataform

GTKs para go(gotk3,gotk4)

Go bindings para GTK

GTK es un widgets-toolkit de código abierto y gratuita, multiplataforma, para crear interfaces de usuario gráficas.

gotk3	https://github.com/gotk3/gotk3
gotk4	https://github.com/diamondburned/gotk4

golang-ui/nuklear

Es un binding para la GUI nuckelar echa en C, si deseas ver lo que se puede hacer con nuclear ve esto :

Página oficial de golang-ui/nuklear: https://github.com/Immediate-Mode-UI/Nuklear

Wails

La verdad que la gente de esta GUI se lució, es muy buena, [lamentablemente no funciona en Windows actualmente] actualmente soporta los 3 sistemas operativos. Esta GUI es una mezcla entre Go y tecnologías de la web como HTML, JavaScript y CSS permitiéndote usar frameworks como VUE.js para el frontend de la app que crees.

Claro está que el backend será el lenguaje Go(golang).

Página Oficial: https://wails.app/

Esta es una pequeña cantidad de las GUIs que hay, hay muchas más y tal vez mejores, en mi caso he tenido la oportunidad de probar fyne y una de las gtk aunque para mí están algo verdes. Dejaré lo que he creado en fyne para poder ser descargado.

Programas creados con golang

Web Frameworks

Los siguientes framework están ordenados según el interés del público y no porque uno sea mejor que el otro, de hecho los frameworks que están valorados como mejores son Gin y Revel según entendidos.

Es posible que algunos de estos Frameworks los comparemos con Laravel(Framework de PHP), porque en sí el blog empezó siendo de PHP, y Go me parece un buen lenguaje que aprender.

Fiber

Fiber es uno de los frameworks que más interés despierta, ya que su nomenclatura es muy parecida a frameworks de node.

Código de ejemplo:

package main

import "github.com/gofiber/fiber/v2"

func main() {
  app := fiber.New()

  app.Get("/", func(c *fiber.Ctx) error {
    return c.SendString("Hello, World!")
  })

  app.Listen(":3000")
}

go run server.go

Página Oficial: https://gofiber.io/

Gin

Gin es el Framework más popular, viniendo de golang puede que te sea el más accesible, hay otro pequeño framework basado en este gin-mvc que puede interesar, ya que usa el patrón de diseño MVC

package main

import "github.com/gin-gonic/gin"

func main() {
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "pong",
		})
	})
	r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
}

$ go run example.go

Página Oficial:https://github.com/gin-gonic/gin

Actualmente(27/11/22), me encuentro probando gin-gonic el cual es muy bueno, por otra parte, la validación tendrá que hacerse de nuestra parte, ya que no le encuentro ningún módulo para validar los formularios

Por parte de seguridad en nuestra base será lo bien que sepamos usar nuestra conexión a base de datos a nuestro DBMS (MySQL, MSSQL, PostgreSQL, etc)

Para poder usar templates con múltiples partes necesitará de este paquete: «github.com/gin-contrib/multitemplate»

Echo

Buena documentación, tiene algunas similitudes con laravel(Framework de PHP), posee middlewares, rutas, manejo de CSRF y alguna otra similitud.

Un ejemplo de hello World

package main

import (
	"net/http"

	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
)

func main() {
	// Echo instance
	e := echo.New()

	// Middleware
	e.Use(middleware.Logger())
	e.Use(middleware.Recover())

	// Route => handler
	e.GET("/", func(c echo.Context) error {
		return c.String(http.StatusOK, "Hello, World!\n")
	})

	// Start server
	e.Logger.Fatal(e.Start(":1323"))
}

Pagina Oficial: https://echo.labstack.com/

Revel

Sobre Revel les puedo decir que si vienes de Laravel es probable que te adaptes muy rápido, es muy parecido a este en algunos sentidos. Esto lo puedo decir por qué estuve mirando la documentación. Buena documentación.-Patrón de diseño equivalente a MVC

Podría poner código, pero suelto, aquí no lo entendería, lo mejor es probarlo.

Página Oficial: https://revel.github.io/

Iris

Otro framework con patrón de diseño equivalente a MVC(no MVC), buena documentación.

Ejemplo de código utilizando iris:

package main

import "github.com/kataras/iris/v12"

func main() {
    app := iris.New()

    booksAPI := app.Party("/books")
    {
        booksAPI.Use(iris.Compression)

        // GET: http://localhost:8080/books
        booksAPI.Get("/", list)
        // POST: http://localhost:8080/books
        booksAPI.Post("/", create)
    }

    app.Listen(":8080")
}

// Book example.
type Book struct {
    Title string `json:"title"`
}

func list(ctx iris.Context) {
    books := []Book{
        {"Mastering Concurrency in Go"},
        {"Go Design Patterns"},
        {"Black Hat Go"},
    }

    ctx.JSON(books)
    // TIP: negotiate the response between server's prioritizes
    // and client's requirements, instead of ctx.JSON:
    // ctx.Negotiation().JSON().MsgPack().Protobuf()
    // ctx.Negotiate(books)
}

func create(ctx iris.Context) {
    var b Book
    err := ctx.ReadJSON(&b)
    // TIP: use ctx.ReadBody(&b) to bind
    // any type of incoming data instead.
    if err != nil {
        ctx.StopWithProblem(iris.StatusBadRequest, iris.NewProblem().
            Title("Book creation failure").DetailErr(err))
        // TIP: use ctx.StopWithError(code, err) when only
        // plain text responses are expected on errors.
        return
    }

    println("Received Book: " + b.Title)

    ctx.StatusCode(iris.StatusCreated)
}

Página Oficial: https://www.iris-go.com/

Beego

Es un framework para desarrollo web con patrón de diseño MVC con los modelos, las vistas y los controladores bien definidos, de todos estos framework vistos a primera vista fue el que más me gusto.

Ejemplo de código utilizando beego:

package main

import (
    "github.com/beego/beego/v2/server/web"
)

type MainController struct {
    web.Controller
}

func (this *MainController) Get() {
    this.Ctx.WriteString("hello world")
}

func main() {
    web.Router("/", &MainController{})
    web.Run()
}

Página Oficial: https://beego.vip/ – Por alguna razón aparece como insegura

Git oficial: https://github.com/beego/beego

Go-app

No sé si a go-app se le puede considerar un framework, pero sirve para crear webs y con eso me vale

Es un paquete para crear aplicaciones web progresivas(PWA) con golang y webassembly