DEV Community: Fabiano Santos Florentino

A interface Write

Fabiano Santos Florentino — Wed, 20 Nov 2024 18:39:51 +0000

Em Go, interfaces são fundamentais para promover polimorfismo e abstração. Elas atuam como contratos que especificam um conjunto de métodos que um tipo deve implementar, permitindo que diferentes tipos sejam tratados de maneira uniforme e flexível.

Interfaces

Em Go, uma interface é um tipo que define um conjunto de métodos, sem implementá-los. Ela especifica apenas as assinaturas dos métodos que um tipo deve possuir para satisfazer a interface. Isso permite que diferentes tipos possam ser tratados de forma uniforme, desde que implementem os métodos definidos pela interface. Interfaces promovem polimorfismo e abstração, facilitando a criação de código flexível e reutilizável.

io.Writer

A interface io.Writer é uma das mais utilizadas em Go. Ela define o método Write, que recebe um slice de bytes ([]byte) e retorna um inteiro (int) e um erro (error). Diversos tipos implementam essa interface, incluindo os.File, bytes.Buffer e net.Conn. Isso permite que diferentes tipos de destinos de escrita sejam tratados de maneira uniforme e flexível.

// Writer é a interface que encapsula a operação básica de escrita.
type Writer interface {
    Write(p []byte) (n int, err error)
}

Write: é o método que recebe um slice de bytes ([]byte) como argumento e retorna dois valores.
- n: é o número de bytes escritos.
- err: é um valor do tipo error que indica se ocorreu algum erro durante a escrita.

Qualquer tipo que implemente o método Write com a assinatura correta será considerarado um io.Writer.

Por que o `io.Writer`?

Abstração: permite tratar diferentes tipos de destinos de escrita de forma uniforme.
Flexibilidade: facilita a criação de métodos genéricos que aceitam qualquer tipo que implemente a interface io.Writer.
Reutilização de código: utilizando o io.Writer pode ser reutilizado com diferentes tipos de destinos, como arquivos, sockets, buffers, etc.
Teste: permite criar mocks e stubs para testar código de forma isolada.

Exemplo

package main

import (
  "fmt"
  "os"
  "io"
)

func main() {
  var w io.Writer = os.Stdout // w é do tipo io.Writer

  n, err := w.Write([]byte("Hello, World!"))
  if err != nil {
    fmt.Println("Erro:", err)
  }

  fmt.Printf("\bBytes escritos: %b", n)
}

/tmp ➜ go run example_io_writer.go
Hello, World!
Bytes escritos: 1101

Conclusão

A interface io.Writer é uma das interfaces mais comuns em Go. Ela é usada para abstrair a operação de escrita de dados, permitindo que diferentes tipos de destinos de escrita sejam tratados de forma uniforme. Isso facilita a reutilização de código, a criação de métodos genéricos e a escrita de testes. Além disso, a interface io.Writer promove polimorfismo, permitindo que diferentes tipos que implementam a interface sejam usados de maneira intercambiável. Ela é amplamente implementada em vários pacotes padrão da linguagem Go, como os, bytes, net, entre outros, demonstrando sua versatilidade e importância no ecossistema Go.

Referências

https://pkg.go.dev/io#Writer
https://pkg.go.dev/os@go1.23.3#File.Write
https://pkg.go.dev/log/slog/internal/buffer#Buffer.Write
https://pkg.go.dev/net@go1.23.3#Conn

Programação Orientada a Objetos: Polimorfismo

Fabiano Santos Florentino — Wed, 30 Oct 2024 20:08:43 +0000

A programação orientada a objetos (POO) é amplamente utilizada para criar sistemas modulares e reutilizáveis. Dentro desse paradigma, um dos pilares mais importantes é o polimorfismo, que, em Golang, pode ser implementado através de interfaces. Este artigo explora o conceito de polimorfismo em Golang e como ele pode ser aplicado para criar sistemas flexíveis e expansíveis.

O que é Polimorfismo?

Polimorfismo, derivado do grego poli (muitos) e morfos (formas), é um conceito fundamental na programação orientada a objetos (POO). Ele permite que diferentes tipos de objetos respondam ao mesmo conjunto de operações de maneiras específicas. Em termos práticos, isso significa que podemos definir um método com o mesmo nome em várias classes diferentes, e cada classe pode ter sua própria implementação desse método. Isso facilita a criação de código flexível e reutilizável, pois podemos tratar objetos de diferentes tipos de maneira uniforme, sem precisar conhecer suas implementações específicas.

Como funciona em Golang?

Em Golang, o polimorfismo é alcançado através do uso de interfaces. Diferente de linguagens orientadas a objetos tradicionais que utilizam herança, Golang permite que tipos diferentes implementem a mesma interface, desde que eles definam os métodos especificados pela interface.

O que é uma Interface?

Uma interface em Golang é um tipo que especifica um conjunto de métodos. Qualquer tipo que implemente esses métodos é considerado como implementando a interface.

Para ilustrar, imagine que estamos desenvolvendo um sistema de pagamentos capaz de processar diferentes métodos, como pagamentos via cartão de crédito e boleto bancário. Podemos definir uma interface chamada PaymentProcessor que declara um método ProcessPayment().

package main

import "fmt"

// Definindo a interface PaymentProcessor que declara o método ProcessPayment
type PaymentProcessor interface {
  ProcessPayment(amount float64)
}

// Struct para pagamento via cartão de crédito
type CreditCard struct{}

// Implementação do método ProcessPayment para CreditCard
func (c CreditCard) ProcessPayment(amount float64) {
  // Taxa de 2% aplicada no valor original
  finalAmount := amount * 1.02
  fmt.Printf("Processando pagamento via cartão de crédito. Valor original: R$%.2f, Valor final com taxa: R$%.2f\n", amount, finalAmount)
}

// Struct para pagamento via boleto bancário
type Boleto struct{}

// Implementação do método ProcessPayment para Boleto
func (b Boleto) ProcessPayment(amount float64) {
  // Desconto de 5% no valor original
  finalAmount := amount * 0.95
  fmt.Printf("Processando pagamento via boleto. Valor original: R$%.2f, Valor final com desconto: R$%.2f\n", amount, finalAmount)
}

// Função que aceita qualquer tipo que implemente a interface PaymentProcessor
func ProcessarPagamento(p PaymentProcessor, amount float64) {
  p.ProcessPayment(amount)
}

func main() {
  cartao := CreditCard{}
  boleto := Boleto{}

  valor := 100.00 // Exemplo de valor de pagamento

  // Utilizando polimorfismo para processar diferentes tipos de pagamento
  ProcessarPagamento(cartao, valor) // Saída: Processando pagamento via cartão de crédito. Valor original: R$100.00, Valor final com taxa: R$102.00
  ProcessarPagamento(boleto, valor) // Saída: Processando pagamento via boleto. Valor original: R$100.00, Valor final com desconto: R$95.00
}

Aqui, temos dois tipos (CreditCard e Boleto), cada um com sua própria implementação do método ProcessPayment(). A função ProcessarPagamento() pode aceitar qualquer tipo que implemente a interface PaymentProcessor, o que nos dá flexibilidade para adicionar novos métodos de pagamento sem modificar o código existente.

Polimorfismo em Tempo de Execução

Em Golang, o polimorfismo ocorre principalmente em tempo de execução, pois o tipo exato que implementa a interface é resolvido dinamicamente. Em outro exemplo onde novos tipos de pagamentos podem ser facilmente adicionados.

Imagine que queremos suportar um novo método de pagamento, como o Pix. Basta criarmos uma nova struct Pix e implementar o método ProcessPayment().

package main

import "fmt"

// Definindo a interface PaymentProcessor que declara o método ProcessPayment
type PaymentProcessor interface {
  ProcessPayment(amount float64)
}

// Struct para pagamento via Pix
type Pix struct{}

// Implementação do método ProcessPayment para Pix
func (p Pix) ProcessPayment(amount float64) {
  // Desconto de 1% no valor original
  finalAmount := amount * 0.99
  fmt.Printf("Processando pagamento via Pix. Valor original: R$%.2f, Valor final com desconto: R$%.2f\n", amount, finalAmount)
}

// Função que aceita qualquer tipo que implemente a interface PaymentProcessor
func ProcessarPagamento(p PaymentProcessor, amount float64) {
  p.ProcessPayment(amount)
}

func main() {
  pix := Pix{}
  valor := 100.00 // Exemplo de valor de pagamento

  // Processando o novo tipo de pagamento via Pix
  ProcessarPagamento(pix, valor) // Saída: Processando pagamento via Pix. Valor original: R$100.00, Valor final com desconto: R$99.00
}

Sem precisar alterar a função ProcessarPagamento, podemos facilmente integrar o novo tipo de pagamento, mostrando o poder do polimorfismo em Golang.

Benefícios do Polimorfismo em Golang

Flexibilidade: O polimorfismo permite que novos comportamentos sejam adicionados sem modificar o código existente. Adicionamos novos tipos como Pix, sem precisar alterar a função ProcessarPagamento.
Expansibilidade: Podemos adicionar quantos tipos forem necessários que implementem a interface PaymentProcessor, criando um sistema que pode crescer de forma orgânica.
Reutilização de código: A lógica principal pode ser reutilizada para diferentes tipos, evitando duplicação de código.
Manutenção simplificada: Como a lógica está centralizada na interface, a manutenção se torna mais fácil, já que o código não depende de implementações específicas.

Conclusão

O polimorfismo permite que diferentes tipos sejam tratados de forma uniforme através de interfaces. Isso promove a flexibilidade e a extensibilidade do código, permitindo que novos tipos sejam adicionados sem modificar o código existente que depende da interface.

Ao entender e utilizar o polimorfismo, você poderá desenvolver software mais flexível e preparado para crescer com as necessidades do seu projeto, criando soluções eficientes e escaláveis.

Referências

Programação Orientada a Objetos: Herança

Fabiano Santos Florentino — Thu, 27 Jun 2024 17:39:01 +0000

Herança

Herança é um dos pilares da programação orientada a objetos, e é uma das formas de reutilização de código. A herança é um mecanismo que permite que uma classe herde atributos e métodos de outra classe, chamada de superclasse ou classe base. A classe que herda os atributos e métodos é chamada de subclasse ou classe derivada.

Principais Conceitos

Superclasse (Classe Base): A classe cujos atributos e métodos são herdados por outras classes. É a classe “pai”.
Subclasse (Classe Derivada): A classe que herda atributos e métodos da superclasse. É a classe “filha”.
Herança Simples: Quando uma subclasse herda de uma única superclasse.
Herança Múltipla: Quando uma subclasse herda de mais de uma superclasse. Nem todas as linguagens de programação suportam herança múltipla devido à sua complexidade.
Sobrescrita de Método: A subclasse pode fornecer uma implementação específica de um método que já existe na superclasse.

Herança & Composição não são a mesma coisa

Composição e herança são duas formas de reutilização de código em programação orientada a objetos. A herança é uma forma de reutilização de código que permite que uma classe herde atributos e métodos de outra classe. A composição é uma forma de reutilização de código que permite que uma classe contenha objetos de outras classes. A composição é geralmente preferida à herança, pois é mais flexível e menos propensa a problemas de design.

Como funciona em Go

Go não possui herança como em linguagens orientadas a objetos clássicas. Ao invés de herança, Go utiliza composição e interfaces para alcançar o mesmo comportamento. Geralmente, a composição é feita através de structs (estruturas) e interfaces.

package main

import "fmt"

// Veiculo é uma interface que define um método dados que retorna uma string
type Veiculo interface {
    dados() string
}

// Carro é uma struct que representa um carro
type Carro struct {
    marca  string
    modelo string
}

// dados é um método que retorna uma string com os dados do carro
func (c Carro) dados() string {
    return fmt.Sprintf("Marca: %s, Modelo: %s", c.marca, c.modelo)
}

// Hatch é uma struct que representa um carro do tipo hatch
type Hatch struct {
    Carro
    portas int
}

// dados é um método que retorna uma string com os dados do carro hatch
func (h Hatch) dados() string {
    return fmt.Sprintf("Marca: %s, Modelo: %s, Portas: %d", h.marca, h.modelo, h.portas)
}

// Sedan é uma struct que representa um carro do tipo sedan
type Sedan struct {
    Carro
    portaMalas int
}

// dados é um método que retorna uma string com os dados do carro sedan
func (s Sedan) dados() string {
    return fmt.Sprintf("Marca: %s, Modelo: %s, Porta Malas: %d", s.marca, s.modelo, s.portaMalas)
}

type Conversivel struct {
    Carro
    capota bool
}

func (c Conversivel) dados() string {
    return fmt.Sprintf("%s, Capota: %t", c.Carro.dados(), c.capota)
}

// imprimirDados é uma função que recebe um veículo e imprime os dados do veículo
func imprimirDados(v Veiculo) {
    fmt.Println(v.dados())
}

func main() {
    // Acessando atributos
    hatch := Hatch{Carro{"Chevrolet", "Onix"}, 4}
    sedan := Sedan{Carro{"Honda", "Civic"}, 500}

    // Acessando métodos dados da struct Carro de forma explícita
    conversivel := Conversivel{Carro{"Fiat", "Spyder"}, true}

    imprimirDados(hatch)
    imprimirDados(sedan)
    imprimirDados(conversivel)
}

heranca main 29m ➜ go run main.go
Marca: Chevrolet, Modelo: Onix, Portas: 4
Marca: Honda, Modelo: Civic, Porta Malas: 500
Marca: Fiat, Modelo: Spyder, Capota: true

Neste exemplo, temos uma interface Veiculo que define um método dados que retorna uma string. Temos também uma struct Carro que representa um carro e um método dados que retorna uma string com os dados do carro. As structs Hatch e Sedan representam carros do tipo hatch e sedan, respectivamente. Ambas as structs Hatch e Sedan incorporam a struct Carro através da composição. Cada uma das structs Hatch e Sedan tem um método dados que retorna uma string com os dados do carro do tipo hatch ou sedan. A função imprimirDados recebe um veículo e imprime os dados do veículo.

Com a composição você pode acessar tantos os atributos quanto os métodos da struct incorporada. No entanto, se houver um método com o mesmo nome ele será sobrescrito.Você pode acessar o método da struct incorporada de forma explícita c.Carro.dados().

func (h Hatch) dados() string {
    return fmt.Sprintf("%s, Portas: %d", h.Carro.dados(), h.portas)
}

Conclusão

A herança é um mecanismo importante da programação orientada a objetos que permite a reutilização de código. No entanto, a herança pode levar a problemas de design, como acoplamento excessivo e hierarquias de classes profundas. Em Go, a linguagem não possui herança como em linguagens orientadas a objetos clássicas. Em vez disso, Go utiliza composição e interfaces para alcançar o mesmo comportamento. A composição é geralmente preferida à herança, pois é mais flexível e menos propensa a problemas de design.

Projeto

Github

Referências

Wikipédia (Herança)
Wikipédia (Composição, herança e delegação)
Go: Composição vs Herança (Vinicius Pacheco)
Effective Go
The Go Programming Language Specification
Go by Example

Programação Orientada a Objetos: Encapsulamento

Fabiano Santos Florentino — Thu, 27 Jun 2024 00:41:39 +0000

Encapsulamento

é um dos princípios fundamentais da programação orientada a objetos (POO). O encapsulamento consiste em ocultar os detalhes internos de um objeto e expor apenas a interface necessária. Essa prática tem como objetivo proteger o estado interno do objeto contra acessos diretos e não autorizados, promovendo a modularidade e facilitando a manutenção do código.

Principais Conceitos

Atributos Privados: Variáveis que armazenam o estado interno de um objeto e são acessíveis apenas dentro da classe onde são definidas. Em linguagens como Java e Python, usa-se o modificador de acesso private ou o prefixo _ para denotar atributos privados.

Métodos Públicos: Funções que permitem a interação com o objeto e seu estado de forma controlada. Estes métodos expõem a funcionalidade do objeto sem revelar os detalhes de implementação.

Getters e Setters: Métodos específicos para acessar e modificar atributos privados. Um getter permite ler o valor de um atributo privado, enquanto um setter permite modificá-lo.

Como funciona em Go

Campos e Funções não Exportados: Em Go, se um campo ou uma função começa com uma letra minúscula, ele é acessível apenas dentro do pacote onde foi definido. Esse é o modo como Go implementa encapsulamento.

Campos e Funções Exportados: Se um campo ou uma função começa com uma letra maiúscula, ele é exportado e pode ser acessado de outros pacotes.

package main

import "fmt"

// Conta é uma estrutura que representa uma conta bancária.
type Conta struct {
    numero int
    saldo  float64
}

// Depositar é um método que adiciona um valor ao saldo da conta.
func (c *Conta) Depositar(valor float64) {
    c.saldo += valor
}

// Sacar é um método que subtrai um valor do saldo da conta.
func (c *Conta) Sacar(valor float64) {
    c.saldo -= valor
}

// Saldo é um método que retorna o saldo da conta.
func (c *Conta) Saldo() float64 {
    return c.saldo
}

func main() {
    // Cria uma nova conta com saldo inicial de 100.0.
    conta := Conta{numero: 123, saldo: 100.0}

    // Tell, Don't Ask - Princípio de design de software.
    // Depositar e Sacar são métodos que informam a conta sobre as ações a serem realizadas.
    conta.Depositar(50.0)
    conta.Sacar(25.0)

    fmt.Println(conta.Saldo())
}

encampulamento ➜ go run main.go
125

Neste exemplo, a estrutura Conta possui dois campos privados (numero e saldo) e três métodos públicos (Depositar, Sacar e Saldo). Dessa forma, o estado interno da conta é protegido contra acessos diretos e não autorizados, garantindo que as operações de depósito e saque sejam realizadas de forma segura.

Tell, Don't Ask

Tell, Don't Ask é um princípio de design de software que sugere que os objetos devem ser responsáveis por realizar ações e não por fornecer informações. Em vez de perguntar a um objeto sobre seu estado interno e tomar decisões com base nesse estado, o princípio Tell, Don't Ask recomenda que o objeto seja informado sobre o que deve ser feito e tome as ações necessárias.

Afirmando o Princípio

No mesmo exemplo acima, a estrutura Conta possui três métodos públicos (Depositar, Sacar e Saldo) que permitem interagir com o objeto sem acessar diretamente seu estado interno. Dessa forma, o princípio Tell, Don't Ask é seguido, pois o objeto Conta é informado sobre as ações a serem realizadas (depósito e saque) e toma as ações necessárias.

Conclusão

O encapsulamento é um conceito fundamental da programação orientada a objetos que visa proteger o estado interno de um objeto contra acessos diretos e não autorizados. Em Go, o encapsulamento é implementado por meio de campos e funções não exportados, que são acessíveis apenas dentro do pacote onde foram definidos. Dessa forma, é possível garantir a integridade e a segurança do objeto, promovendo a modularidade e facilitando a manutenção do código.

Projeto

Github

Agradecimento

Deixo aqui meu agradecimento ao @moretoend (fala comigo!), como sempre ajudando a melhorar o conteúdo dos meus artigos, e nesse em especial, me ajudando a entender melhor o conceito de Tell, Don't Ask. vlw!

Referências

Programação Orientada a Objetos: Abstração

Fabiano Santos Florentino — Thu, 13 Jun 2024 20:36:03 +0000

Abstração

Em ciência da computação, abstração é a habilidade de se concentrar nos aspectos essenciais de um contexto, ignorando características menos importantes ou acidentais. Em programação orientada a objetos, uma classe é uma abstração de entidades existentes no contexto de uma aplicação. Como exemplo, uma classe Usuario pode representar um usuário de um sistema que pode se dividir em subclasses como UsuarioAdministrador, UsuarioComum, UsuarioVisitante, etc.

Principais Conceitos

Uma classe abstrada é criada para representar entidades e conceitos abstratos. A classe abstrata é sempre uma "Super classe" que não possui instâncias, que implementa métodos que são de uso comum a todas as subclasses. As subclasses são classes que herdam os métodos e atributos da classe abstrata, podendo implementar métodos específicos.

Como funciona em Go

Em Go, não existe o conceito de classes, mas podemos alcançar a abstração por meio de interfaces. Uma interface é um tipo abstrato que define um conjunto de métodos que um tipo deve possuir. Em Go, a implementação das interfaces é implícita, o que significa que qualquer tipo que tenha os métodos exigidos por uma interface automaticamente a implementa, sem a necessidade de uma declaração explícita. Isso permite que um tipo concreto seja tratado como uma interface, sem a necessidade de conhecer a implementação específica do tipo.

package usuario

type Usuario interface {
    Nome() string
    Email() string
}

package usuario

// Struct que representa um usuário administrador
type UsuarioAdministrador struct {
    nome  string
    email string
}

// Método que retorna o nome do usuário administrador
func (ua UsuarioAdministrador) Nome() string {
    return ua.nome
}

// Método que retorna o email do usuário administrador
func (ua UsuarioAdministrador) Email() string {
    return ua.email
}

// Função que registra um usuário administrador
func RegistraUsuarioAdministrador(nome, email string) Usuario {
    return UsuarioAdministrador{nome, email}
}

package usuario

// Struct que representa um usuário comum
type UsuarioComum struct {
    nome  string
    email string
}

// Método que retorna o nome do usuário comum
func (uc UsuarioComum) Nome() string {
    return uc.nome
}

// Método que retorna o email do usuário comum
func (uc UsuarioComum) Email() string {
    return uc.email
}

// Função que registra um usuário comum
func RegistraUsuarioComum(nome, email string) Usuario {
    return UsuarioComum{nome, email}
}

package usuario

import "fmt"

// PrintUsuarioComum imprime os dados de um usuario
func PrintUsuario(u Usuario) {
    fmt.Printf("Nome: %s, Email: %s\n", u.Nome(), u.Email())
}

package main

import "abstracao/usuario"

func main() {
    // Registra um usuário comum
    usuario_comum := usuario.RegistraUsuarioComum("Usuario Commum", "usuario_comum@email.com")

    // Registra um usuário administrador
    usuario_administrador := usuario.RegistraUsuarioAdministrador("Usuario Administrador", "usuario_administrador@email.com")

    // Imprime os dados dos usuários
    usuario.PrintUsuario(usuario_comum)
    usuario.PrintUsuario(usuario_administrador)
}

abstracao ➜ go run main.go
Nome: Usuario Commum, Email: usuario_comum@email.com
Nome: Usuario Administrador, Email: usuario_administrador@email.com

Neste exemplo, temos uma interface Usuario que define os métodos Nome e Email. As structs UsuarioAdministrador e UsuarioComum implementam a interface Usuario, fornecendo suas próprias versões dos métodos Nome e Email. As funções RegistraUsuarioAdministrador e RegistraUsuarioComum são responsáveis por criar instâncias de UsuarioAdministrador e UsuarioComum, respectivamente. No arquivo main.go, instanciamos objetos de UsuarioAdministrador e UsuarioComum, e chamamos os métodos Nome e Email de cada um para demonstrar a implementação da interface.

Conclusão

A abstração é fundamental no design de software, permitindo a definição de contratos de comportamento independentes das implementações específicas. Em Go, embora não existam classes como nas linguagens orientadas a objetos tradicionais, a abstração é alcançada eficientemente através de interfaces. Interfaces permitem a criação de tipos que aderem a um conjunto de métodos, promovendo flexibilidade e reutilização de código. Ao separar a definição de comportamento da implementação concreta, interfaces simplificam a manutenção de sistemas complexos e permitem que novos tipos possam ser integrados com facilidade, melhorando a modularidade e a extensibilidade do código.

Projeto

Github

Referências

Melhorando a Compreensão de Slices Multidimensionais em Golang

Fabiano Santos Florentino — Wed, 12 Jun 2024 13:06:23 +0000

Olá mundo!

Faz tempo desde o último artigo, mas estou de volta! Neste artigo, vou tentar explicar e aprimorar o entendimento sobre slices multidimensionais em Golang.

O que é um slice multidimensional?

Um slice multidimensional é um slice que contém outros slices. Em outras palavras, é uma matriz de slices. Isso é útil quando você precisa de uma matriz de tamanho variável.

Como funciona em Golang?

Conceitos básicos

Array multidimensional: um array multidimensional é um array que contém outros arrays como elementos. Em Go, você pode declarar um array de duas dimensões (por exemplo, uma matriz) como var slice [3][3]int.
Slice: Uma fatia é uma referência a um segmento contínuo de um array. Fatias em Go têm uma capacidade (cap) e um comprimento (len) e podem ser redimensionadas.

1. Criando um slice 2D

Primeiro, criamos uma matriz 2D e a inicializamos com alguns valores. Em seguida, criamos um slice 2D e atribuímos a matriz 2D a ele.

package main

import (
    "fmt"
)

func main() {
    matrix := [3][4]int{
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
    }

    fmt.Println("Matriz 2D original:")
    printMatrix(matrix)
}

Neste exemplo, criamos um slice multidimensional de inteiros. Cada elemento do slice principal é um slice de inteiros. Podemos acessar os elementos individuais da matriz usando a notação de colchetes duplos.

2. Fazendo Slice de Linhas Específicas

Criamos uma fatia para acessar partes específicas da matriz.

func main() {
    matrix := [3][4]int{
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
    }

    fmt.Println("Matriz 2D original:")
    printMatrix(matrix)

    // Fatia da primeira linha
    firstRow := matrix[0][:] // Equivalente a matrix[0][0:4]
    fmt.Println("\nPrimeira linha como fatia:", firstRow)

    // Fatia da segunda linha, mas apenas os dois primeiros elementos
    secondRowPartial := matrix[1][:2]
    fmt.Println("Parte da segunda linha:", secondRowPartial)
}

Neste exemplo, acessamos os elementos individuais da matriz usando a notação de colchetes duplos. O primeiro índice refere-se ao índice do slice principal e o segundo índice refere-se ao índice do slice interno.

3. Fazendo Slice de Colunas

Para acessar colunas, você precisa iterar pelas linhas e criar fatias das colunas desejadas.

func main() {
    matrix := [3][4]int{
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
    }

    fmt.Println("Matriz 2D original:")
    printMatrix(matrix)

    // Fatia da primeira coluna
    var firstCol []int
    for i := range matrix {
        firstCol = append(firstCol, matrix[i][0])
    }
    fmt.Println("\nPrimeira coluna como fatia:", firstCol)

    // Fatia da segunda coluna
    var secondCol []int
    for i := range matrix {
        secondCol = append(secondCol, matrix[i][1])
    }
    fmt.Println("Segunda coluna como fatia:", secondCol)
}

4. Função auxiliar para imprimir a matriz

func printMatrix(matrix [3][4]int) {
    for _, row := range matrix {
        fmt.Println(row)
    }
}

Código completo

package main

import (
    "fmt"
)

func main() {
    matrix := [3][4]int{
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
    }

    fmt.Println("Matriz 2D original:")
    printMatrix(matrix)

    // Fatia da primeira linha
    firstRow := matrix[0][:]
    fmt.Println("\nPrimeira linha como fatia:", firstRow)

    // Fatia da segunda linha, mas apenas os dois primeiros elementos
    secondRowPartial := matrix[1][:2]
    fmt.Println("Parte da segunda linha:", secondRowPartial)

    // Fatia da primeira coluna
    var firstCol []int
    for i := range matrix {
        firstCol = append(firstCol, matrix[i][0])
    }
    fmt.Println("\nPrimeira coluna como fatia:", firstCol)

    // Fatia da segunda coluna
    var secondCol []int
    for i := range matrix {
        secondCol = append(secondCol, matrix[i][1])
    }
    fmt.Println("Segunda coluna como fatia:", secondCol)
}

func printMatrix(matrix [3][4]int) {
    for _, row := range matrix {
        fmt.Println(row)
    }
}

Conclusão

Compreender o conceito de slices multidimensionais é essencial para qualquer desenvolvedor que deseja manipular estruturas de dados complexas de forma eficiente. Esse conhecimento não apenas aprimora a capacidade de lidar com arrays em várias linguagens, mas também simplifica a execução de operações complexas, aumentando a clareza e a manutenibilidade do código. Ao dominar o uso de slices multidimensionais, você ganha uma ferramenta poderosa para enfrentar desafios em áreas como processamento de imagens, ciência de dados e outras que exigem a manipulação de grandes volumes de dados. Essa habilidade se traduz em código mais eficiente e expressivo, capacitando você a resolver problemas de maneira ágil e eficaz, e a criar soluções mais robustas e escaláveis.

Referências

Autorização no Ransack, Permitindo ou Negando operações de pesquisa e ordenação

Fabiano Santos Florentino — Sun, 28 Jan 2024 15:44:08 +0000

Por padrão, o Ransack autoriza a pesquisa e a ordenação em todos os campos do modelo e não autoriza quaisquer escopos de classe. No entanto, podemos personalizar essa autorização usando quatro métodos específicos que podem ser redefinidos em nossos modelos: ransackable_attributes, ransackable_associations, ransortable_attributes e ransackable_scopes. Vamos explorar como podemos utilizar esses métodos para controlar precisamente quais operações de pesquisa e ordenação são permitidas em nossa aplicação.

Permitindo ou Negando Operações de Pesquisa

O método ransackable_attributes determina quais atributos de um modelo podem ser usados para pesquisa. Por padrão, ele retorna todos os nomes de colunas do banco de dados e quaisquer ransackers definidos. Esse método pode ser redefinido para permitir apenas pesquisas em determinados campos.

def ransackable_attributes(auth_object = nil)
  %w[name email] # Apenas 'nome' e 'email' são permitidos para pesquisa
end

No exemplo, apenas os campos nome e email podem ser usados para pesquisa.

Controlando as Associações Permitidas

O método ransackable_associations determina quais associações de um modelo podem ser usadas para pesquisa. Por padrão, ele retornas os nomes de todas as associações definidas no modelo. Podemos redefinir as associações através desse método.

def ransackable_associations(auth_object = nil)
  %w[posts] # Apenas 'posts' pode ser usado para pesquisa
end

No exemplo, apenas as associações posts podem ser usadas para pesquisa.

Permitindo ou Negando a Ordenação

O método ransortable_attributes determina quais atributos de um modelo podem ser usados para ordenação. Por padrão, ele retorna os mesmos atributos definidos em ransackable_attributes. Podemos redefinir esse método para permitir ou negar a ordenação em determinados atributos.

def ransortable_attributes(auth_object = nil)
  %w[name email] # Apenas 'nome' e 'email' podem ser usados para ordenação
end

No exemplo, apenas os campos nome e email podem ser usados para ordenação.

Controlando os Escopos Autorizados

O método ransackable_spoces determina quais escopos de classe (método de classe) de um modelo podem ser usados para pesquisa. Por padrão, ele retorna uma lista vazia, o que significa que nenhum escopo de classe está autorizado. Podemos redefinir esse método para permitir ou negar a pesquisa em determinados escopos de classe.

def ransackable_scopes(auth_object = nil)
  [:active] # Apenas o escopo 'ativo' pode ser usado para pesquisa
end

Isso significa que apenas o escopo de classe active do modelo pode ser usado em operações de pesquisa.

Conclusão

Ao personalizar esses métodos em nossos modelos Rails, podemos controlar precisamente quais operações de pesquisa e ordenação são permitidas em nossos modelos. Isso nos dá maior flexibilidade e segurança ao lidar com consultas em nossas aplicações, garantindo que apenas as operações autorizadas sejam executadas em campos e associações específicas.

Sabia Mais

Ransack Documentation: Authorization (allowlisting/denylisting)

Ransack

Fabiano Santos Florentino — Sun, 28 Jan 2024 02:45:23 +0000

Ransack uma Query Language em Rails

No contexto do desenvolvimento web com Rails, o Ransack oferece uma maneira conveniente e flexível de construir consultas dinâmicas em bancos de dados. Funcionando como uma "linguagem de consulta" embutida, o Ransack simplifica a tarefa de filtrar, ordenar e pesquisar registros em modelos ActiveRecord

Filtrando Registros

Uma das funcionalidades principais do Ransack é permitir que os desenvolvedores filtrem registros com base em critérios específicos. Isso pode ser útil em cenários como uma página de administração onde o usuário deseja ver apenas os registros que correspondem a determinados critérios.

# No controlador
def index
  @q = Post.ransack(params[:q])
  @posts = @q.result
end

Neste exemplo, Post.ransack(params[:q]) cria um objeto Ransack com base nos parâmetros recebidos da solicitação HTTP. Os parâmetros geralmente vêm de um formulário na interface do usuário, onde o usuário pode especificar os critérios de filtro desejados.

Ordenando Registros

Outra característica útil do Ransack é a capacidade de ordenar os registros recuperados. Isso é feito adicionando os parâmetros de ordenação adequados à solicitação HTTP.

# No controlador
def index
  @q = Post.ransack(params[:q])
  @posts = @q.result.order(created_at: :desc)
end

Aqui, @q.result.order(created_at: :desc) garante que os registros sejam ordenados por created_at em ordem decrescente. Isso pode ser personalizado conforme a necessidade da aplicação.

Pesquisando Registros

Além de filtrar e ordenar, o Ransack também facilita a realização de pesquisas de texto completo em registros. Isso pode ser especialmente útil em interfaces de pesquisa onde os usuários podem buscar registros com base em palavras-chave. Para deixar a pesquisa mais especifica, você pode utilizar as colunas do banco de dados combinado a uma lista de predicados do ransack para filtrar os resultados.

/route?q[title_cont]=title

/route?q[title_cont]=tittle&q[author_eq]=author

No primeiro exemplo, o Ransack recebe como parametro os filtro title_cont, com o valor title. title_cont é a combinação do nome da colune title com o predicado *_cont, o controlador recebe esse parametro como params[:q] e realiza a busca com o valor title.

No segundo exemplo, o Ransack recebe como parametro os filtros title_cont e author_eq, com os valores title e author, respectivamente. Da mesma forma como no primeiro exemplo o controlador recebe esses parametros para realizar a busca com os valores title e author.

Conclusão

O Ransack é uma ferramenta poderosa que simplifica a construção de consultas dinâmicas em aplicativos Rails. Com sua sintaxe amigável e recursos abrangentes, ele permite que os desenvolvedores criem interfaces de usuário poderosas e flexíveis para interagir com bancos de dados. Ao usar o Ransack como sua Query Language em Rails, você pode construir aplicativos mais eficientes e fáceis de usar para seus usuários.

Sabia Mais

Ransack Documentation

Query Language

Fabiano Santos Florentino — Sun, 28 Jan 2024 02:39:16 +0000

Uma "Query Language" (QL), em tradução literal "Linguagem de Consulta", é uma linguagem de programação projetada especificamente para interagir com bancos de dados e recuperar informações deles. Essas linguagens são fundamentais para o desenvolvimento de aplicativos que precisam armazenar e manipular dados de maneira eficiente.

O que é uma Query Language?

Uma Query Language é uma linguagem de programação usada para realizar operações em um banco de dados. Ela permite que os desenvolvedores definam e executem consultas para recuperar, inserir, atualizar ou excluir dados de um banco de dados relacional ou não relacional. As consultas são escritas em uma sintaxe específica que é interpretada pelo sistema de gerenciamento de banco de dados (SGBD).

Principais Características

Estruturada:

Uma Query Language geralmente é estruturada em termos de sua sintaxe e gramática. Isso ajuda a garantir consistência e compreensibilidade ao escrever consultas.

Declarativa

Em muitos casos, uma QL é declarativa, o que significa que você descreve o que deseja alcançar e não precisa se preocupar com os detalhes de como isso será feito. O SGBD cuida da implementação das consultas.

Tipos de Operações:

Uma QL permite realizar uma variedade de operações, como seleção (recuperação de dados), inserção, atualização e exclusão de registros.

Exemplos de Query Languages:

SQL (Structured Query Language):

SQL é a linguagem de consulta mais comum e amplamente utilizada para bancos de dados relacionais. Permite realizar operações como SELECT, INSERT, UPDATE e DELETE em tabelas. NoSQL Query Languages: Existem várias Query Languages associadas a bancos de dados NoSQL, como MongoDB Query Language (MQL) para MongoDB e Couchbase Query Language (N1QL) para Couchbase.

GraphQL:

GraphQL é uma linguagem de consulta poderosa e flexível que permite aos desenvolvedores solicitar exatamente os dados necessários em uma API web. Diferentemente de abordagens tradicionais de API, onde os clientes têm acesso a endpoints predefinidos que retornam dados fixos, o GraphQL permite que os clientes especifiquem exatamente quais dados precisam, o que resulta em consultas mais eficientes e em respostas mais enxutas.

OData:

OData é um protocolo de padrão aberto desenvolvido pela Microsoft que permite a criação e consumo de APIs RESTful de forma mais eficiente e consistente. Ele define um conjunto de regras para criar consultas avançadas, filtrar, ordenar e paginar dados em APIs RESTful.

Conclusão

Uma Query Language é uma parte fundamental do desenvolvimento de aplicativos que interagem com bancos de dados. Seja SQL para bancos de dados relacionais ou uma QL específica para um banco de dados NoSQL, entender e dominar a linguagem de consulta apropriada é essencial para desenvolver aplicativos robustos e eficientes.

Ruby on Rails

Fabiano Santos Florentino — Thu, 27 Jul 2023 16:09:22 +0000

Ruby on Rails é um framework popular de desenvolvimento web em Ruby, que adota o padrão arquitetural MVC para separar a aplicação em Model, View e Controller. Com ênfase em "Convenção sobre Configuração", o Rails permite desenvolver rapidamente com menos código. Oferecendo operações CRUD simplificadas, suporte a Gemas para adicionar funcionalidades extras e Scaffolding para prototipagem ágil. Além disso, o framework conta com Active Record para mapear dados do banco de dados em objetos Ruby e Rake para executar tarefas importantes. O Rails ainda garante segurança integrada e possui uma comunidade ativa para suporte e aprendizado.

Os principais pontos para entender melhor o Ruby on Rails. Dominar esses pontos ajudará você a entender melhor o funcionamento do Ruby on Rails e a tirar o máximo proveito desse poderoso framework de desenvolvimento web.

MVC (Model-View-Controller)

O Ruby on Rails segue o padrão arquitetural Model-View-Controller, que separa a aplicação em três componentes principais. O Model representa a camada de dados e a lógica de negócios, o View é responsável pela interface do usuário e o Controller manipula as interações do usuário e coordena as ações.

Imagine que estamos criando um aplicativo de lista de tarefas (to-do list). O Model seria a classe que representa uma tarefa, contendo atributos como título, descrição e status. O View seria a interface do usuário, onde ele verá a lista de tarefas e poderá adicionar novas tarefas. O Controller seria responsável por manipular as requisições do usuário, como adicionar uma nova tarefa à lista.

https://guiarails.com.br/getting_started.html#mvc-e-voce

Convenção sobre Configuração

O Rails segue o princípio de "Convenção sobre Configuração", o que significa que ele possui uma série de convenções bem definidas que permitem que os desenvolvedores escrevam menos código para configurar a aplicação. Isso torna o desenvolvimento mais rápido e fácil.

Ao criar um novo projeto Ruby on Rails, o Rails já define a estrutura de diretórios e arquivos padrão para o projeto. Por exemplo, os modelos devem ser colocados na pasta "app/models", os controladores em "app/controllers" e as visualizações em "app/views".

https://guiarails.com.br/getting_started.html#criando-a-aplicacao-blog

Arquivo/Pasta	Objetivo
app/	Contém os controllers, models, views, helpers, mailers, channels, jobs, e assets para sua aplicação. Você irá se concentrar nesse diretório pelo restante desse guia.
bin/	Contém o script rails que inicializa sua aplicação e contém outros scripts que você utiliza para configurar, atualizar, colocar em produção ou executar sua aplicação.
config/	Contém configurações de rotas, banco de dados entre outros de sua aplicação. Este conteúdo é abordado com mais detalhes em Configuring Rails Applications.
config.ru	Configuração Rack para servidores baseados em Rack usados para iniciar a aplicação. Para mais informações sobre o Rack, consulte Rack website.
db/	Contém o schema do seu banco de dados atual, assim como as migrations do banco de dados.
Gemfile
Gemfile.lock	Esses arquivos permitem que você especifique quais dependências de gem são necessárias na sua aplicação Rails. Esses arquivos são usados pela gem Bundler. Para mais informações sobre o Bundler,
lib/	Módulos extendidos da sua aplicação.
log/	Arquivos de log da aplicação.
public/	Contém arquivos estáticos e assets compilados. Quando sua aplicação está rodando esse diretório é exposto como ele está.
Rakefile	Este arquivo localiza e carrega tarefas que podem ser rodadas por linhas de comando. As tarefas são definidas nos componentes do Rails. Ao invés de editar o Rakefile, você deve criar suas próprias
README.md	Este é um manual de instruções para sua aplicação. Você deve editar este arquivo para informar o que seu aplicativo faz, como configurá-lo e assim por diante.
storage/	Arquivos de armazenamento ativo do serviço de disco. Mais informações em Active Storage Overview.
test/	Testes unitários, fixtures, e outros tipos de testes. Mais informações em Testing Rails Applications.
tmp/	Arquivos temporários (como cache e arquivos pid).
vendor/	Diretório com todos os códigos de terceiros. Em uma típica aplicação Rails inclui vendored gems.
.gitignore	Este arquivo diz ao Git quais arquivos (ou padrões) devem ser ignorados. Acesse GitHub - Ignoring files para mais informações sobre arquivos ignorados.
.ruby-version	Este arquivo contém a versão padrão do Ruby.

CRUD Simplificado

O Rails oferece operações CRUD (Create, Read, Update, Delete) de forma simples e direta. Com apenas algumas linhas de código, é possível criar interfaces para interagir com bancos de dados.

Para criar as operações CRUD para a nossa lista de tarefas, basta executar o seguinte comando no terminal Rails

rails generate scaffold Task title:string description:text status:boolean

https://guiarails.com.br/getting_started.html#operacoes-crud

Gemas (Gems):

As Gemas são pacotes de código Ruby que podem ser facilmente adicionados à aplicação para adicionar funcionalidades extras. O Ruby on Rails possui uma grande quantidade de gemas disponíveis, o que facilita a incorporação de recursos adicionais à sua aplicação.

Suponha que precisamos adicionar um calendário à nossa aplicação de lista de tarefas. Podemos pesquisar uma gema existente para isso, como a 'simple_calendar'. Então, adicionamos essa gema ao arquivo "Gemfile" e executamos "bundle install" para instalá-la. O Gemfile é o arquivo que contém todas as gemas que serão utilizadas na aplicação com a versão definida. O Gemfile.lock força as versões de cada gem que estão sendo utilizadas no seu projeto. Isso é pra evitar que o projeto fique com verões de gems diferentes em outros lugares.

Em seguida, podemos seguir a documentação da gema para integrá-la às nossas visualizações e controladores para exibir um calendário de tarefas.

gem install simple_calendar

https://rubygems.org/

Scaffolding

O Scaffolding é uma ferramenta do Rails que permite gerar automaticamente partes básicas de uma aplicação, como modelos, controladores e visualizações. Isso é útil para criar rapidamente protótipos de funcionalidades.

Como mencionado no exemplo anterior, o comando "rails generate scaffold" cria rapidamente todas as partes básicas necessárias para um recurso (no exemplo, "Task"), incluindo o modelo, o controlador e as visualizações para as operações CRUD.

https://www.rubyguides.com/2020/03/rails-scaffolding/

rails generate scaffold books

This example creates:

A BooksController
A Book model
A new resources :books route added to your config/routes.rb file
A set of testing-related files
View files under app/views/books (five in total)

Active Record

O Active Record é a camada de ORM (Mapeamento Objeto-Relacional) do Rails. Ele mapeia os registros do banco de dados para objetos Ruby e vice-versa, permitindo que você trabalhe com dados do banco de dados de forma orientada a objetos.

O Active Record permite que você defina facilmente um modelo e use-o para interagir com o banco de dados. Por exemplo, com o modelo "Task" criado pelo scaffolding, podemos criar uma nova tarefa e salvá-la no banco de dados desta forma:

task = Task.new(title: 'Comprar mantimentos', description: 'Ir ao supermercado', status: false)
task.save

https://guiarails.com.br/active_record_basics.html

Rake

Rake é uma ferramenta de linha de comando que vem com o Rails e permite executar tarefas como migrações de banco de dados, execução de testes, entre outras operações úteis.

O Rake permite que você execute tarefas definidas no Rakefile do projeto. Por exemplo, podemos criar uma tarefa personalizada para imprimir todas as tarefas no console:

# No Rakefile
task :list_tasks do
  tasks = Task.all
  tasks.each do |task|
    puts "#{task.title} - #{task.description} (#{task.status})"
  end
end

# No terminal
rake list_tasks

https://guiarails.com.br/command_line.html

Rotas (Routes)

O Rails usa um sistema de roteamento para direcionar as solicitações HTTP para os controladores adequados. Isso permite que você defina facilmente as URLs da aplicação.

Podemos definir rotas no arquivo "config/routes.rb". Por exemplo, para definir uma rota para exibir uma lista de tarefas, faríamos o seguinte:

# No config/routes.rb
Rails.application.routes.draw do
  resources :tasks
end

Isso criará as seguintes rotas:

GET /tasks (index)
GET /tasks/new (new)
POST /tasks (create)
GET /tasks/:id (show)
GET /tasks/:id/edit (edit)
PATCH /tasks/:id (update)
PUT /tasks/:id (update)
DELETE /tasks/:id (destroy)

O Rails gera automaticamente essas rotas e as mapeia para as ações correspondentes no controlador.

Para fixar a rota você pode usar asssim:

# No config/routes.rb
Rails.application.routes.draw do
  resources :tasks, only: [:index]
end

https://guiarails.com.br/configuring.html#initializers

Segurança

O Rails possui recursos integrados para ajudar a proteger a aplicação contra ameaças comuns, como ataques de injeção de SQL, ataques CSRF (Cross-Site Request Forgery) e mais.

O Rails possui recursos de segurança integrados, como proteção contra ataques CSRF. Isso é feito automaticamente através do uso de um token de autenticidade em formulários gerados pelo Rails.

https://guiarails.com.br/getting_started.html#seguranca

Comunidade e Documentação

O Ruby on Rails possui uma comunidade ativa e solidária, com muitos recursos de aprendizado, fóruns e documentação disponíveis online. É fácil encontrar ajuda e respostas para dúvidas através da comunidade Rails.

A comunidade Rails é bastante ativa, e você pode encontrar muita documentação e recursos online. Por exemplo, você pode visitar o site oficial do Ruby on Rails (https://rubyonrails.org/) para encontrar a documentação oficial e o GitHub (https://github.com/rails/rails) para acessar o código-fonte e recursos adicionais.

O Ruby on Rails é uma ferramenta poderosa e eficiente para o desenvolvimento web, permitindo aos desenvolvedores criar aplicações de forma ágil e produtiva. Ao seguir o padrão MVC e adotar a "Convenção sobre Configuração", o framework simplifica a estruturação e configuração do projeto, acelerando o processo de desenvolvimento. Com recursos como Gemas, Scaffolding, Active Record e Rake, o Rails oferece ferramentas práticas e integradas para lidar com diversas tarefas com facilidade. Além disso, a preocupação com a segurança e a presença de uma comunidade ativa tornam o Ruby on Rails uma escolha popular e confiável para desenvolvedores em todo o mundo. Se você deseja construir aplicações web de forma eficiente e segura, dominar os principais conceitos do Ruby on Rails é essencial para obter resultados bem-sucedidos e satisfatórios.

Empresas que usam Ruby: https://www.google.com/search?q=ruby+on+rails+plataforms&oq=ruby+on+rails+plataforms&aqs=edge..69i57j0i22i30l2j0i390i650l3j69i64l2.7987j0j1&sourceid=chrome&ie=UTF-8

https://rubyonrails.org/

Microserviços Desafios e Desvantagens

Fabiano Santos Florentino — Fri, 02 Jun 2023 16:53:59 +0000

A arquitetura de microserviços ganhou popularidade devido à sua capacidade de oferecer escalabilidade, flexibilidade e agilidade no desenvolvimento de software. No entanto, sua implementação apresenta desafios significativos que precisam ser enfrentados para garantir o sucesso do sistema. Neste contexto, se destaca os seguintes pontos no desafio de implementar essa arquitetura.

Desafios

Decomposição do sistema

Dividir um sistema monolítico em microserviços requer uma análise cuidadosa para definir os limites corretos e garantir a coesão entre os serviços. Isso envolve identificar as funcionalidades que pode ser encapsuladas em microserviços independentes.

Gerenciamento de comunicação

A comunicação entre os microserviços deve ser eficiente e confiável. É necessário escolher os mecanismos adequados de comunicação síncrona e assíncrona, como mensagens ou chamadas de API, e garantir a tolerância a falhas e a escalabilidade na troca de informações entre eles.

Controle de transações distribuidas

Em um ambiente de microserviços, quando várias operações precisam ser realizadas de forma transacional, garantir a consistência dos dados se torna um desafio complexo. É necessário adotar padrões e técnicas como compensação, consistência eventual ou uso de barramento de eventos.

Gerenciamento de configuração

Com grande número de microserviços, o gerenciamento de configurações e variáveis de ambiente se torna difícil e propenso a erros. É necessário estabelecer uma estratégia de armazenar, distribuir e atualizar as configurações dos serviços de forma consistente.

Monitoramento e rastreamento

Rastrear e monitorar o fluxo de solicitações entre os microserviços é essencial para solucionar problemas de desempenho e identificar possíveis gargalos. É necessário implementar ferramentas e técnicas de monitoramento e observabilidade, como logs distribuídos, métricas e rastreamento de solicitações.

Gerenciamento de versões

Manter várias versões dos microserviços e coordenar as atualizações e migração entre eles requer um processo cuidadoso para evitar incompatibilidade e interrupções no sistema. É necessário adotar boas práticas de versionamento, testes de regressão e estratégias de rollout controlado.

Garantia de disponibilidade

A falha de um microserviço não pode comprometer todo o sistema. É necessário implementar mecanismos de recuperação de falhas, como replicações, balanceamento de carga e estratégias de fallback e circuitbreak, para garantir a disponibilidade contínua do sistema.

Segurança

Cada microserviço deve ser protegido contra ameaças de segurança. É necessário adotar medidas como autenticação, autorização, criptografia de dados e auditoria de acesso para garantir a integridade e confidencialidade dos dados em um ambiente distribuído.

Testes e deploy

A complexidade dos testes aumenta com o número de microserviços envolvidos. A abordagem de teste deve ser automatizado e eficiente, como testes de unidade, integração e contrato, além de investir em pipeline de entrega contínua para facilitar o deploy dos serviços.

Governança e cultura organizacional

A adoção de uma arquitetura de microserviços muitas vezes requer uma mudança cultural significativa na organização, bem como a definição de padrões de governança para garantir a consistência e o alinhamento dos serviços. É necessário estabelecer práticas de colaboração, comunicação e documentação entre as equipes.

A arquitetura de microserviços tem sido amplamente adotada devido às suas vantagens de escalabilidade, flexibilidade e agilidade. No entando, é importante reconhecer que essa abordagem também apresenta desvantagens significativas. Ao optar por uma arquitetura de microserviços, as organizações devem estar cientes dos desafios que podem surgir ao longo do caminho. A decomposição do sistema em vários microserviços aumenta a complexidade geral do sistema, tornando o entendimento a manutenção e o gerenciamento mais complexos. Além disso, a comunicação entre os microserviços requer uma implantação cuidadosa e pode resultar em problemas de desempenho e integridade do sistema. A garantia da consistência dos dados em transações distribuídas também é um desafio, exigindo o uso de técnicas específicas. O gerencimaneto de configuração, monitoramento, versões, segurança, testes e governança são áreas adicionais que se tornam mais complexas com a arquitetura de microserviços. Embora essas desvantagens possam ser superadas com planejamento adequado, adoção de boas práticas e ferramentas adequadas, é essencial estar ciente delas para tomar decisões informadas ao adotar essa arquitetura.

Desvantagens

Complexidade do sistema

A decomposição de um sistema monolítico em microserviços introduz uma maior complexidade ao ambiente. Com múltiplos serviços interconectados, entender e manter a arquitetura como um todo pode se tornar um desafio. Cada microserviço possui sua própria lógica de negócio, requisitos de comunicação e dependências externas, o que aumenta a complexidade geral do sistema. A coordenação e a resolução de problemas que envolvem múltiplos serviços podem exigir um esforço adicional devido à natureza distribuída da arquitetura.

Gerenciamento de comunicação

A comunicação entre os microserviços é fundamental para o funcionamento correto do sistema. No entanto, coordenar essa comunicação de forma eficiente pode ser desafiador. É necessário escolher os protocolos, formatos de mensagem e estratégias de troca de dados adequados. Além disso, problemas de desempenho, latência e perda de dados podem surgir, afetando a integridade e o desempenho geral do sistema.

Controle de transações distribuídas

No ambiente de microserviços, garantir a consistência dos dados em transações distribuídas pode ser complexo. Diferentes microserviços podem precisar se comunicar e coordenar suas operações para manter a integridade dos dados. A implementação de transações distribuídas requer técnicas avançadas, como compensação, consistência eventual ou o uso de um barramento de eventos.

Gerenciamento de configuração

Com um grande número de microserviços, o gerenciamento de configuração se torna mais desafiador. Cada serviço pode ter suas próprias configurações, variáveis de ambiente e dependências externas. Manter e atualizar essas configurações de forma consistente em um ambiente distribuído requer uma estratégia adequada, evitando erros e inconsistências.

Monitoramento e rastreamento

Rastrear e monitorar o fluxo de solicitações entre os microserviços é essencial para identificar problemas de desempenho, depuração e análise de erros. No entanto, em uma arquitetura de microserviços, o rastreamento e o monitoramento podem se tornar mais complexos devido à naturaza distribuída dos serviços. É necessário implementar ferramentas e técnicas apropriadas, como logs distribuídos, métricas e rastreamento de solicitações, para obter insights valiosos sobre o sistema como um todo.

Gerenciamento de versões

Manter várias versões dos microserviços e coordenar as atualizações entre eles pode ser um desafio. À medida que os serviços evoluem independentemente, diferentes verões podem coexistir, resultando em possíveis incompatibildiades e complexidades de integração. É necessário adotar práticas sólidas de versionamento, testes de regressão e estratégias de rollout controlado para minimizar interrupções e garantir a compatibilidade entre os serviços.

Impacto na disponibilidade

A falha de um único microserviço pode ter um impacto direto na disponibilidade geral do sistema. Uma vez que os microserviços são independentes, se um serviço enfrentar problemas, pode afetar a funcionalidade de outros serviços que dependem dele. É necessário implementar estratégias de resiliência, como circuit breaker e fallbacks, para lidar com falhas e garantir a continuidade do serviço.

Segurança

A segurança em uma arquitetura de microserviços é um desafio complexo. Com várias partes do sistema em execução independetemente, é necessário proteger cada microserviço individualmente e garantir a segurança das comunicações entre eles. A implementação de autenticação, autorização e proteção de dados sensíveis em um ambiente distribuído requer uma abordagem cuidadosa e o uso de práticas de segurança adequadas.

Complexidade dos testes de deploy

Com o aumento do número de microserviços, a complexidade dos testes e do processo de deploy também aumenta. É necessário garantir que cada microserviço seja testado individualmente, além de realizar testes de integração para verificar a interação correta entre eles. Além disso, a implamtação dos serviços em um ambiente distribuído requer estratégias de implantação eficiente e automatizadas para garantir um processo suave e consistente.

Desafios de governança e cultura organizacional

A adoção da arquitetura de microserviços pode exigir mudanças culturais e estabelecimento de governança para garantir a consistência e o alinhamento dos serviços. É necessário estabelecer práticas de colaboração, comunicação e documentação entre as equipes de desenvolvimento e operações. Além disso, a definição de padrões de governança é essencial para garantir a conformidade e a compatibilidade entre os microserviços.

Então...

a arquitetura de microserviços apresenta desafios significativos, incluindo a complexidade do sistema, o gerenciamento da comunicação, o controle de transações distribuídas, a administração da configuração, o monitoramento e rastreamento, o gerenciamento de versões, o impacto na disponibilidade, os desafios de segurança, a complexidade dos testes e implementações, e os desafios de governança e cultura organizacional. No entanto, essas dificuldades podem ser superadas por meio de um planejamento criterioso, a adoção de melhores práticas e a utilização de ferramentas adequadas. Ao enfrentar essas desvantagens, as organizações podem aproveitar os benefícios da arquitetura de microserviços, criando sistemas escaláveis, flexíveis e resilientes.

Algumas referências

microservices.io

What is Microservice Architecture?

128 - Microserviços, este é uma série de 6 epsódios de podcast em PT-BR.

Microsserviços Prontos Para a Produção: Construindo Sistemas Padronizados em uma Organização de Engenharia de Software

Arquitetura de microsserviços

Projeto de Software

Fabiano Santos Florentino — Sun, 21 May 2023 15:37:23 +0000

O processo de projeto de software desempenha um papel crucial no desenvolvimento de sistemas eficientes e confiáveis. A seguir está uma introdução aos principais pontos envolvidos nessa fase, desde a compreensão da modelagem do sistema até a elaboração dos diagramas necessários para a implementação. Modelos de análise de software, como análise estruturada e orientação a objetos, e a importância de documentar a visão do projeto.

Entender a fase de projeto de um sistema (modelagem)

Antes de começar a projetar um sistema de software, é essencial compreender os requisitos e as necessidades dos usuários. A fase de modelagem envolve a criação de representações abstratas do sistema, como diagramas, para ajudar a visualizar e estruturar a solução. Isso inclui identificar os principais componentes, suas interações e fluxos de dados.

Ao projetar um sistema de reservas de hotéis, a modelagem envolveria a identificação dos atores principais (usuários, administradores, etc.), as funcionalidades necessárias e as informações que devem ser armazenadas (quartos, reservas, etc.).

Modelo de análise de software (Análise estruturada)

A análise estruturada é uma abordagem que divide o sistema em componentes hierárquicos, como módulo de funções. É baseada em técnica como fluxogramas, diagramas de fluxo de dados e especificações de processo. Essa abordagem permite uma compreensão clara da lógica do sistema e dos fluxos de informação.

Um diagrama de fluxo de dados seria usado para mostrar como as informações fluem em um sistema de vendas, desde o momento em que um pedido é feito até a sua entrega.

Modelo de análise de software (Orientação a objetos)

A análise orientada a objetos é uma abordagem de modelagem que enfoca a identificação de objetos e suas interações para resolver problemas. Ela envolve a criação de classes, atributos, métodos e relacionamentos entre os objetos. Essa abordagem permite a reutilização de código e facilita a compreensão e a manutenção do sistema.

Em um sistema de biblioteca, seriam identificados objetos como livros, usuários e empréstimos, e suas iterações seriam representadas por meio de relacionamentos como associação, agregação e herança.

Projetar a solução

Com base na modelagem e nas técnicas de análise escolhidas, o próximo passo é projetar a solução para o sistema de software. Isso envolve tomar decisões sobre a arquitetura, a divisão em módulos e a escolha das tecnologias adequadas. O objetivo é criar uma estrutura sólida e eficiente que atenda aos requisitos do sistema.

Um sistema de gerenciamento de tarefas, pode-se decidir usar uma arquitetura de três camadas (Apresentação, lógica de negócio e persistência), com a utilização de um banco de dados relacional para armazenar as informações.

Documentar a visão do projeto

A documentação é essencial para garantir que a visão do projeto seja claramente comunicada e compreendida por todas as partes envolvidas. Isso inclui descrever os objetivos, requisitos, restrições e decisões tomadas durante a fase de projeto. A documentação também serve como uma referência útil para futuras manutenções e melhorias no sistema.

A documentação do projeto de um sistema de comércio eletrônico pode incluir a descrição dos requisitos funcionais (como de usuários e realização de pedidos) e não funcionais (como desempenho e segurança).

Elaborar o diagrama de casos de uso

O diagrama de casos de uso é uma representação visual das funcionalidades do sistema a partir da perspectiva dos usuários. Ele identifica os atores envolvidos e as interações entre eles, fornecendo uma visão geral dos principais recursos do fluxo do sistema.

Um sistema de reservas de passagens áreas, um caso de uso seria "realizar reservas" envolvendo interações entre o usuário, o sistema de reservas e o sistema de pagamento.

Elaborar o diagrama de classes

O diagrama de classes é usado na análise orientada a objetos para representar a estrutura e as relações entre as classes do sistema. Ele descreve as propriedades (atributos) e comportamentos (métodos) de cada classe, além dos relacionamentos entre elas.

Um diagrama de classes para um sistema de gerenciamento de alunos pode incluir classes como "Aluno", "Curso" e "Matrícula", com atributos como nome, idade e número de matrícula.

Elaborar o diagrama de sequência

O diagrama de sequência mostra a interação entre os objetos do sistema ao longo do tempo, representando a ordem das mensagens trocadas entre eles. Ele ajuda a compreender como o sistema responde a determinadas ações e eventos, auxiliando no projeto detalhado da funcionalidade.

Um diagrama de sequência para um sistema de pagamentos online pode mostrar a sequência de eventos desde o momento em que o usuário seleciona os itens até a confirmação do pagamento.

Por que usar projeto de software na construção de um sistema?

O uso de software está cada vez mais presente em nossas vidas, seja no trabalho, em casa ou no lazer. A cada dia, novos softwares são desenvolvidos para atender às necessidades de diferentes usuários. Mas, como esses softwares são desenvolvidos? Como garantir que eles atendam às necessidades dos usuários? Como garantir que eles sejam confiáveis e seguros? Como garantir que eles sejam desenvolvidos dentro do prazo e do orçamento? Como garantir que eles sejam desenvolvidos de forma eficiente e eficaz?

O uso de projeto de software na construção de um sistema é extremamente importante por várias razões e, por isso, é um dos principais tópicos abordados na disciplina de Engenharia de Software. Abaixo estão alguns dos principais benefícios do uso de projeto de software na construção de um sistema:

Organização e estrutura

O projeto de software permite uma abordagem estruturada e organizada para o desenvolvimento do sistema. Ele ajuda a definir uma arquitetura clara e a dividir o trabalho em tarefas gerenciáveis. Isso facilita o entendimento e a colaboração entre os membros da equipe de desenvolvimento.

Atendimento aos requisitos

O projeto de software garante que os requisitos do sistema seja compreendidos e atendidos adequadamente. Através da modelagem de documentação, é possível identificar os principais componentes e funcionalidades necessárias, evitando assim a omissão de requisitos importantes.

Redução de erros e retrabalho

Ao projetar um sistema de software, é possível identificar possíveis problemas e antecipar soluções. Através de revisões e análises, é possível detectar error e inconsistências antes de implementação. Isso ajuda a reduzir o retrabalho e os custos associados a correções posteriores.

Comunicação eficaz

O projeto de software fornece uma linguagem comum para todos os envolvidos no desenvolvimento. Através dos diagramas e documentação, é possível comunicar de forma clara e visual as funcionalidades e o comportamento do sistema. Isso facilita a compreensão mútua e evita mal-entendidos entre a equipe de desenvolvimento e os stakeholders.

Reutilização de código

Ao projetar um sistema de software de forma modular e orientada a objetos, é possível identificar oportunidades de reutilização de código. Isso significa que partes do sistema podem ser projetadas e implementadas uma vez e posteriormente utilizadas em diferentes contextos. Isso economiza tempo e esforço, além de promover a consistência e a manutenibilidade do sistema.

Facilidade de manutenção

Um projeto de software bem estruturado facilita a manutenção do sistema ao longo do tempo. Com uma documentação clara e a compreensão da estrutura do sistema, torna-se mais fácil realizar correções, melhorias e atualizações. Isso é particularmente importante em sistemas de longa duração, nos quais a manutenção pode ser uma parte significativa do ciclo de vida do software.

Então(...)

Um projeto de software bem estruturado facilita a manutenção do sistema ao longo do tempo. Com uma documentação clara e a compreensão da estrutura do sistema, torna-se mais fácil realizar correções, melhorias e atualizações. Isso é particularmente importante em sistema de longa duração, nos quais a manutenção pode ser uma parte significativa do ciclo de vida do software.

O uso de projeto de software na construção de uma sistema é essencial para garantir a organização, compreensão dos requisitos, a redução de erros, a comunicação eficaz, a reutilização de código e a facilidade de manutenção. Ele proporciona uma abordagem estruturada e colaborativa, resultando em sistemas de software mais eficientes, confiáveis e sustentáveis.

Como colocado anteriormente o projeto de software é uma etapa crucial no desenvolvimento de sistemas eficientes e confiáveis. Compreender a modelagem, escolher a abordagem de análise adequada, projetar a solução e documentar a visão do projeto são elementos fundamentais para o sucesso do projeto. A elaboração de diagramas de casos de uso, classes e sequência auxilia na visualização e comunicação das funcionalidades do sistema. Ao seguir essas práticas, os desenvolvedores podem criar sistemas robustos e fáceis de manter.

DEV Community: Fabiano Santos Florentino

A interface Write

Interfaces

io.Writer

Por que o io.Writer?

Exemplo

Conclusão

Referências

Programação Orientada a Objetos: Polimorfismo

O que é Polimorfismo?

Como funciona em Golang?

O que é uma Interface?

Polimorfismo em Tempo de Execução

Benefícios do Polimorfismo em Golang

Conclusão

Referências

Programação Orientada a Objetos: Herança

Herança

Principais Conceitos

Herança & Composição não são a mesma coisa

Como funciona em Go

Conclusão

Projeto

Referências

Programação Orientada a Objetos: Encapsulamento

Encapsulamento

Principais Conceitos

Como funciona em Go

Tell, Don't Ask

Afirmando o Princípio

Conclusão

Projeto

Agradecimento

Referências

Programação Orientada a Objetos: Abstração

Abstração

Principais Conceitos

Como funciona em Go

Conclusão

Projeto

Referências

Melhorando a Compreensão de Slices Multidimensionais em Golang

Olá mundo!

O que é um slice multidimensional?

Como funciona em Golang?

Conceitos básicos

1. Criando um slice 2D

2. Fazendo Slice de Linhas Específicas

3. Fazendo Slice de Colunas

4. Função auxiliar para imprimir a matriz

Código completo

Conclusão

Referências

Autorização no Ransack, Permitindo ou Negando operações de pesquisa e ordenação

Permitindo ou Negando Operações de Pesquisa

Controlando as Associações Permitidas

Permitindo ou Negando a Ordenação

Controlando os Escopos Autorizados

Conclusão

Sabia Mais

Ransack

Ransack uma Query Language em Rails

Filtrando Registros

Ordenando Registros

Pesquisando Registros

Conclusão

Sabia Mais

Query Language

O que é uma Query Language?

Principais Características

Exemplos de Query Languages:

Conclusão

Ruby on Rails

MVC (Model-View-Controller)

Convenção sobre Configuração

CRUD Simplificado

Gemas (Gems):

Scaffolding

Active Record

Rake

Por que o `io.Writer`?