DEV Community: Paulo H. R. Pinheiro

Arte generativa com fórmula simples em Go

Paulo H. R. Pinheiro — Tue, 09 Jan 2024 01:26:02 +0000

Inspiração

Essa imagem, que me persegue por várias ruas do Centro de Campinas, me faz pensar em alguma forma de desenhar através de um programa.Em outros momentos já vinha testando alguma coisa:

https://paulohrpinheiro.xyz/texts/go/2019-02-18-gerando-imagens-em-go-com-biblioteca-padrao.html

https://github.com/paulohrpinheiro/generative-art

Explorando essa fórmula, da maneira que costumo, cheguei a uma redução bem interessante:

C + C * X * Y

Em que C é uma constante qualquer, e o par X, Y, coordenadas da imagem gerada em um tamanho predeterminado (em geral 1000 pontos) a partir da origem (0,0). Mas o interessante é colorir essas imagens, para isso é usado resultado dessa conta módulo M, em que M é o máximo de cores que se deseja usar.

O programa

PS: usei range no loop for, coisa que só está disponível na versão 1.22rc1, futuramente 1.22!

    package main

    import (
        "flag"
        "image"
        "image/color/palette"
        "image/png"
        "os"
    )

    const (
        defaultImageSize = 1000
        defaultMaxColors = 150
        defaultConstant  = 10
        defaultFileName  = "formula.png"
    )

    func main() {
        fileName := flag.String("filename", defaultFileName, "filename to save image (.png)")
        imageSize := flag.Int("size", defaultImageSize, "size of image")
        constant := flag.Int("constant", defaultConstant, "constant for formula (c): c-c*x*y")
        maxColors := flag.Int("colors", len(palette.WebSafe), "number of colors")

        flag.Parse()

        rect := image.Rect(0, 0, *imageSize, *imageSize)
        img := image.NewPaletted(rect, palette.WebSafe)

        for x := range *imageSize {
            for y := range *imageSize {
                value := (*constant - *constant*x*y)
                color := uint8(value % *maxColors)

                img.SetColorIndex(x, y, color)
            }
        }

        f, err := os.Create(*fileName)
        if err != nil {
            panic(err)
        }

        defer f.Close()
        png.Encode(f, img)
}

Duas coisas que aprendi nessa empreitada, foram o pacote flag e o image/color/palette.

Ao invés de construir minha própria paleta de cores como vinha fazendo há algum tempo, agora uso a paleta palette.WebSafe. Outra opção pronta é a palette.Plan9:

https://pkg.go.dev/image/color/palette

O pacote flag permite uma maneira rápida (e não sofisticada) de capturar argumentos em linha de comando, como por exemplo:

go run formula.go -filename formula-colors:50-constant:10-size:10.png -colors 50

Em caso de parâmetro errado:

$ go run formula.go -nada-a-ver

flag provided but not defined: -nada-a-ver

Usage of /tmp/go-build942068976/b001/exe/formula:

  -colors int

        number of colors (default 216)

  -constant int

        constant for formula (c): c-c*x*y (default 10)

  -filename string

        filename to save image (.png) (default "formula.png")

  -size int

        size of image (default 1000)

exit status 2

Algumas imagens

Mudando os parâmetros tem-se resultados interessantemente diferentes (ou não) :)

colors:100 constant:10

colors:216 constant:10

colors:80 constant:10

colors:60 constant:10

colors:90 constant:10

colors:200 constant:10

colors:70 constant:10

Testando o novo mux no GO 1.22

Paulo H. R. Pinheiro — Fri, 05 Jan 2024 01:32:41 +0000

Motivação

O fato da linguagem Go me lembrar muito da linguagem C a tornou muito confortável para mim. Em todo o tempo em que estudo a linguagem por hobby, uma coisa me incomoda: o uso de bibliotecas de terceiros para tarefas triviais.

A filosofia de Go vai de encontro ao meu pensamento: quanto menos bibliotecas de terceiros eu usar, melhor. Por segurança, por comodidade, por menos coisas para me preocupar, por querer uma linguagem com o máximo de "baterias inclusas".

Então sempre me deu preguiça construir APIs em Go, pois o mais fácil é utilizar algum muxer não incluso. Isso para mim é uma tarefa básica, portanto a linguagem deveria implementar da melhor maneira. Assim, cá estou eu feliz com as promessas da versão 1.22.

Infraestrutura

É preciso ter o compilador na versão correta: 1.22rc1.

Uso o asdf para gerenciar as linguagens de programação que utilizo. Com ele, basta instalar indicando a versão desejada:

asdf install golang 1.22rc1
asdf global golang 1.22rc1
asdf reshim golang

Lembrando que se não quiser tornar essa versão a utilizada globalmente, basta entrar na pasta que queira restringir a versão e executar o seguinte comando:

asdf local golang 1.22rc1

A forma normalmente indicada para versões não definitivas, é utilizar o gotip:

go install golang.org/dl/gotip@latest
gotip download

Se utilizar o gotip, em todas as situações em que dever usar o comando go, substitua por gotip, mantendo os parâmetros.

Minhas fontes

Comecei lendo o artigo de Eli Bendersky sobre isso:

https://eli.thegreenplace.net/2023/better-http-server-routing-in-go-122/

E, conforme lá indicado, dei uma olhada na documentação da linguagem:

https://pkg.go.dev/net/http@go1.22rc1#hdr-Patterns

O programa

Adaptado das fontes acima, eis:

package main

import (
  "fmt"
  "net/http"
)

func main() {
  mux := http.NewServeMux()
  mux.HandleFunc("GET /path/", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "got path\n")
  })

  mux.HandleFunc("GET /gospel/{version}/{testament}/{book}/{chapter}/", func(w http.ResponseWriter, r *http.Request) {
    version := r.PathValue("version")
    testament := r.PathValue("testament")
    book := r.PathValue("book")
    chapter := r.PathValue("chapter")

    fmt.Fprintf(w, "handling gospel with version=%v, testament=%v, book=%v, chapter=%v\n", version, testament, book, chapter)
  })

  http.ListenAndServe("127.0.0.1:8090", mux)
}

Perceba-se que ao utilizar {book} na configuração do endpoint, pode-se acessar a variável na posição com book := r.PathValue("book"). Além de se poder indicar qual o verbo utilizado (nesse caso GET). Caso se queira vários métodos para uma URL, basta omitir o verbo.

Para executar, as possibilidades, conforme se instalou a nova versão de Go. Pelo asdf, ou instalação direta:

go run server.go

Ou pelo gotip:

gotip run server.go

Executei o programa tanto em um Debian, como em um Fedora. No Fedora rolou de boas, mas no Debian simplesmenente não foi:

$ curl localhost:8090/gospel/almeida/new/marcos/3/
404 page not found

E para o outro endpoint:

$ curl localhost:8090/path/
404 page not found

Lendo os documentos acima indicados com mais atenção, descobri um parâmetro que habilita ou desabilita essa feature. COofigurando uma variável de ambiente no terminal em que o servidor é executado, tudo funciona:

$ export GODEBUG=httpmuxgo121=0
$ go run http_server.go

Ou então, passando a variável na linha de execução:

$ curl localhost:8090/path/
got path

E o outro endpoint:

$ curl localhost:8090/gospel/almeida/new/marcos/3/
handling gospel with version=almeida, testament=new, book=marcos, chapter=3

Começando com generics em Go

Paulo H. R. Pinheiro — Wed, 27 Dec 2023 10:12:29 +0000

Motivação

Estava estudando algoritmos de ordenação, e implementando em Go. Achei chato fazer um código que só trabalhasse com inteiros, lembrando que Golang tem generics.A partir disso, muitas leituras, tentativas, até o fracasso. Implementar no algoritmo foi fácil, o problema quase incontornável foi nos testes, já que insisti em seguir o "table driven tests", para variados tipos em uma só função de teste.

Retomando o desafio, pensei em uma forma mais simples de testar a mesma estrutura, para não ficar perdendo tempo com erros e detalhes diferentes do novo objetivo de aprender generics.

Aqui segue o resultado desse experimento.

A tarefa

Nessa subtask, defini que trabalharia em uma função mais simples, que mantivesse o espírito do problema, mas que me permitisse estudar principalmente a forma de testar.

Resolvi implementar o que chamo "método de ordenação if". Dados dois números, a função deve retorná-los ordenados (ifsort.go):

package ifsort

import "golang.org/x/exp/constraints"

func Sort[T constraints.Ordered](a, b T) (T, T) {
    if a > b {
        return b, a
    }

    return a, b
}

Poderíamos ter várias funções, cada qual com um tipo diferente, mas o corpo da função seria o mesmo. Essa é a uma das belezas dos generis: reutilização de código, evitando que depois do "copia e cola", algo fique diferente em alguma dessas funções clonadas.

Poderia, por exemplo, usar as primitivas da linguagem para definir um tipo interface, como em:

type MyGenericType interface {
    int | float64 | string
}

Mas já que temos algo pronto :), bora lá, está completo e com mais possibilidades. O Ordered é definido como:

type Ordered interface {
    Integer | Float | ~string
}

Note que Integer e Float expandem para todas suas variantes. E o operador ~ usado no tipo string, significa que construções como MyStringType serão contempladas. O operador | indica a união de todas essas possibilidades.

O mais importante, com esse tipo: garantimos que nossa função só trabalha com tipos que possam ser comparados; nesse caso concreto, precisamos garantir que tenham implementado o operador >.

O pacote constraints nos traz vários tipos, que garantem certas propriedades:

https://pkg.go.dev/golang.org/x/exp/constraints#section-documentation

Uma boa introdução sobre generics pode ser encontrada no próprio site da linguagem:

https://go.dev/blog/intro-generics

Testando

Óbvio que numa situação real, não precisamos testar cada tipo para cobrir o espectro do generics que estivermos usando. Mas, como se tratava de um experimento, prefiro sempre escrever testes do que criar uma função main e ficar alterando e testando manualmente.

Eis o arquivo de teste (ifsort_test.go):

package ifsort

import (
    "testing"

    "github.com/stretchr/testify/assert"
    "golang.org/x/exp/constraints"
)

func runAssertEqual[T constraints.Ordered](t *testing.T, input []T, output []T) {
    a, b := Sort(input[0], input[1])
    assert.Equal(t, a, output[0])
    assert.Equal(t, b, output[1])
}

type TestIntType struct {
    input  []int
    output []int
}

func TestBubbleInt(t *testing.T) {
    for _, test := range []TestIntType{
        {[]int{1, 2}, []int{1, 2}},
        {[]int{50, -101}, []int{-101, 50}},
    } {
        runAssertEqual(t, test.input, test.output)
    }
}

func TestBubbleFloat64(t *testing.T) {
    runAssertEqual(t, []float64{22.2, 11.1}, []float64{11.1, 22.2})
}

func TestBubbleString(t *testing.T) {
    runAssertEqual(t, []string{"z", "a"}, []string{"a", "z"})
}

Não é uma prática recomendada, reutilização de código em um teste, e nem eu gosto muito disso, mas para o objetivo aqui, tratava-se de mais uma oportunidade para brincar com generics:


func runAssertEqual[T constraints.Ordered](t *testing.T, input []T, output []T) {
    a, b := Sort(input[0], input[1])
    assert.Equal(t, a, output[0])
    assert.Equal(t, b, output[1])
}

Mais uma vez, independente do tipo, chamamos a função de ordenação, e então verificamos o resultado. E para facilitar a leitura do código, usa-se o pacote testify:

https://github.com/stretchr/testify

Usando essa abordagem, facilita-se a execução dos testes específicos. Tarefa para o fim de ano, voltar ao problema original dos algoritmos de ordenação, que requerem uma abordagem levemente diferente, por conta dos slices, que serão usados, no lugar de parâmetros individuais.

Publicado originalmente em https://paulohrpinheiro.xyz/texts/go/2023-12-22-comecando-com-generics-em-go.html