DEV Community: feitoza

DESIGN - PADRÃO PROTOTIPO

feitoza — Fri, 08 Mar 2024 05:05:18 +0000

Quem é o infeliz?

Basicamente, este padrão proporciona a um objeto a capacidade de ser clonado e faz parte de uma categoria que chamamos de padrões criacionais, pois eles são responsáveis por gerenciar criação de componentes/objetos (alguns exemplos são o Factory, Builder, Singleton e outros).

Qual é o B.O.?

Dito isso, você deve estar se perguntando sobre o cenário em que o padrão deve ser aplicado e o motivo, então pensemos na seguinte situação: em uma parte qualquer do nosso código, temos uma função que recebe uma interface de um objeto qualquer, queremos então ter uma cópia dele e apenas fazer algumas alterações em seus atributos. Contudo, não sabemos muito sobre o que queremos clonar e isso nos traz alguns questionamentos. Será que há campos privados? Qual é a complexidade para a construção deste objeto? Isso iria nos deixar presos e dependentes deste objeto? E uma interface (entenda interface como um contrato que diz o que aquele objeto irá me fornecer), infelizmente, não consegue nos fornecer tais informações tão arraigadas ao objeto concreto (entenda concreto como a lógica que o objeto implementa dentro de si).

Imagine que você quer construir um carro que viu em uma foto, após bastante tempo você tem algo parecido, contudo faltam coisas (componentes internos) que você não consegue visualizar/acessar, devido a ter apenas uma foto para se basear, te impedindo de fazer uma reconstrução autêntica.

Alguma solução?

A solução para isso seria dar ao objeto que queremos copiar o poder de se clonar, com esta habilidade não precisamos nos preocupar com os problemas citados acima.

Se a foto que temos do carro pudesse ter um botão de clonagem junto a ela, seria muito mais fácil :P

Implementação

## 1 - interface definindo a capacidade/método de clonagem
interface IPrototipo<ObjetoGenerico>
{
    ObjetoGenerico Clonar();
}
## 2 - interface que define nosso objeto concreto
interface IFulano : IPrototipo<IFulano>
{
    string Beltrano;
    void Imprimir();
}

## 3 - nosso objeto concreto propriamente dito
public class Fulano : IFulano
{
    public string Beltrano;
    ## atributo/campo privado, que restringe o acesso
    ## podendo ser acessado apenas dentro da própria classe Fulano
    private string Siclano;

    public Fulano(string beltrano, string siclano)
    {
        this.Beltrano = beltrano;
        this.Siclano = siclano;
    }
    public void Imprimir()
    {
        Print($"\nBeltrano: {this.Beltrano}");
        Print($"\nSiclano: {this.Siclano}");
    }
    ## 4 - implementação do método de clonagem
    public IFulano Clonar()
    {
        ## observe que há um atributo/campo privado (Siclano) que não
        ## poderíamos acessar para fazer uma cópia do jeito convencional
        ## contudo, como estamos dentro do objeto, é permitido
        ## o acesso a seus atributos/campos privados
        return new Fulano(this.Beltrano, this.Siclano);
    }
}

Código do cliente definindo o objeto Fulano
e chamando o MétodoExemplo

var objetoOriginal = new Fulano("Jesse", "Feitoza");
MetodoExemplo(objetoOriginal);

Método em algum lugar do nosso código aceitando apenas
a interface do objeto Fulano

void MetodoExemplo(IFulano obj)
{
    var objetoClonado = obj.Clonar();
    objetoClonado.Beltrano = "Max";
    objetoClonado.Imprimir();
}

CACHE NO LADO DO CLIENTE

feitoza — Sat, 11 Nov 2023 10:14:13 +0000

O armazenamento no lado do cliente é crucial para evitar sobrecarga no servidor e proporcionar maior velocidade na entrega de informações ao usuário. Existem várias formas de realizar isso, considerando o contexto da web.

COOKIES

Este é um dos primeiros métodos de armazenamento no lado do cliente, sendo usado, na época, de forma geral para cache. Atualmente, é empregado para armazenar informações relacionadas a sessões de usuários, estados e outros dados menores.

WEB STORAGE

Os cookies apresentam um problema de desempenho, enviando dados a cada nova requisição do cliente de volta ao servidor para verificação. Por isso, surgiram novos métodos, como o Web Storage, que armazena dados com a estrutura de chave e valor, permanentemente ou temporariamente (os dados são apagados ao fechar o navegador). É excelente para armazenar dados simples, como nome e foto de perfil de um usuário.

INDEXED DB

Esta opção oferece um sistema de banco de dados completo, sendo facilmente utilizado para armazenar estruturas de dados mais complexas, como postagens recorrentes em uma rede social.

CACHE API

O funcionamento deste método de armazenamento é um pouco diferente, pois apenas armazena respostas HTTP do servidor. No entanto, há algo especial: os service workers. São processos diretamente relacionados ao seu domínio/site de origem, interceptando as requisições do cliente e respostas do servidor, podendo tratá-las conforme desejado pelo desenvolvedor. Assim, os service workers podem interceptar as respostas do servidor e usar o Cache API para armazenamento, permitindo um site completamente offline.

CONCLUSÕES

Claro que poderíamos nos utilizar de outras ferramentas para tal, como o Redis; contudo, temos um grande leque de soluções disponíveis no contexto de sites web, quase que nativamente (pois essas soluções são, em sua grande maioria, APIs escritas em JavaScript) para economia de recursos, melhoria de desempenho e maior satisfação do cliente. That's all, folks!

REFERÊNCIAS

https://developer.mozilla.org/pt-BR/docs/Learn/JavaScript/Client-side_web_APIs/Client-side_storage#offline_asset_storage
https://redis.io/docs/manual/client-side-caching/
https://developer.mozilla.org/pt-BR/docs/Web/API/Service_Worker_API
https://developer.mozilla.org/pt-BR/docs/Web/API/Cache
https://developer.mozilla.org/pt-BR/docs/Web/API/IndexedDB_API
https://developer.mozilla.org/pt-BR/docs/Web/API/Web_Storage_API

FUNDAMENTALS - POINTERS ARE EASY

feitoza — Thu, 12 Oct 2023 10:58:25 +0000

You could already have heard about this guy and imagined it as a Hydra from D&D. So today we gonna talk about pointers and show how easy it is.

Yes, we have to talk about Memory

But before we talk about them, let's see how our programs handle memory. When you create a variable, it is stored in a space in memory and this space has an address to identify the location of it and its value.

We can imagine memory as a set of lockers, where you store your things (variables) and the address as the number to identify the locker.

Finally, pointers!

So wtf are pointers? Pointers are just references to some space in memory that contains a variable a its values.

Analogy time! Pointers are like your locker key with the locker's number on it.

But, when we use pointers?

When you pass a variable to a function as a parameter, and your function receives that value, it doesn't receive the original variable but a copy.

// Here is a small example in C

// This function gonna receives the copy value
void change_x_value(int x) 
{
    x = 5;
}

int main()
{
    int x = 2;

    printf("Variable before change: %i\n", x);

    change_x_value(&x);

    printf("Variable after change: %i\n", x);
}

// RESULT:
 "Variable before change: 2"
 "Variable after change: 2"

So if you want to change the value of the parameters received directly, you just can't. The solution is to pass a pointer (you are just passing a variable that stores an address/reference) as a parameter to the function that tells exactly where the real value is stored in the memory.


// This function gonna receives the pointer
// to the variable x and its value 
void change_x_value(int* x)
{
    // * symbol set and get the x variable value 
   // at the specified address
    x* = 5;
}

int main()
{
    int x = 2;

    printf("Variable before change: %i\n", x);

// Now I am passing the pointer (just an address) to the function
    change_x_value(&x); // & symbol just get the address of this variable

    printf("Variable after change: %i\n", x);
}

// RESULT:
 "Variable before change: 2"
 "Variable after change: 5"

End

Did you see it? It's easy peasy lemon squeezy, don't need to be afraid of pointers anymore.

FUNDAMENTALS - CONCEITO DE INTERPRETAÇÃO

feitoza — Fri, 12 May 2023 22:58:18 +0000

Eu tive a grata e, ao mesmo tempo, a infelicidade de tentar escrever meu próprio JSON Parser(converte dados de tipo JSON em estruturas equivalentes para sua linguagem de programação e vice-versa) utilizando Elixir. Então, isso despertou a vontade de entender mais sobre o assunto e discorrer de forma simples o conceito de interpretação.

Muitas linguagens de programação são interpretadas (php, python) ou compiladas (C/C++, Erlang), ou uma mistura dos dois (Java, Kotlin, C#), mas isso não é uma lei já que dá pra compilar código fonte python, então já dá para notar que o buraco é mais embaixo. Mas no geral esses processos de interpretação/compilação passam por etapas essenciais muito parecidas.

Analise de Léxico

Levando em consideração o JSON Parser, primeiro teremos a etapa de análise de léxico ou tokenização, basicamente consiste em receber um código fonte, como um JSON:

    {“I choose love” : “s2”}

percorrer o código e dividi-lo em pequenas partes chamadas de tokens, fazendo uma lista, tal qual:

    [“{”, “I”, ”choose”, “love”, “:”, “s2”, “}”]

Nesta fase não há nenhum tipo de validação se esses tokens são realmente válidos, ou seja, eles não têm valor algum.

Fazendo um paralelo, poderíamos pegar uma sentença, como “Eu escolho o amor” e dividi-la por palavras [“Eu”, “escolho”, “o”, “amor”], essas palavras não tem uma função ou valor; claro, algumas são pronomes, verbos e substantivos, mas qual a função/valor delas em uma sentença/oração ?

Analise Sintática

Pensando em valor/função é que passamos para nossa segunda etapa, análise sintática ou parsing (analisar), onde basicamente irá, de acordo com um conjunto de regras preestabelecidas, dar valor/função a cada um desses tokens e validá-los. Exemplo, todo texto JSON começa com chaves { e termina com } e deve haver no mínimo uma key, com aspas duplas envolvendo-as, dois pontos : para identificar a atribuição de valor e um valor qualquer. Então nossos tokens são validos.

Voltando ao exemplo da nossa sentença “Eu escolho o amor”, também podemos realizar a análise sintática dessas palavras, ou seja, descobrir a função que cada uma dessas partes desempenha em nossa sentença, como: “Eu” = Sujeito [“escolho”, “o”, “amor”] = Predicado. Claro, estamos fazendo essa análise devido a regras pré-definidas.

Mas e se eu tiver um JSON com mais camadas ? Exemplo:

{
   "MyLoves":{
      "programming": "I hate u I luv u",
      "Diana": "my unique luv"
   }
}

Neste caso você terá que realizar as verificações que já são feitas so que de forma recursiva, levando em conta o ponto de partida (camada mais alta) do JSON { e o ponto de termino (camada mais baixa) }.

Este artigo foi so a pontinha do iceberg, contudo há muito conteúdo se aprofundando nessas aguas misteriosas e estarei deixando alguns aqui embaixo:

ALGORITHMS - BUSCA BINÁRIA

feitoza — Thu, 16 Mar 2023 23:52:28 +0000

Algoritmos são sequências de instruções para se resolver um determinado problema, contudo eles podem variar em efiência e perfomance para resolução do mesmo. Dito isto, seu estudo é importante para qualquer programador, pois muitas vezes ja pegamos "coisas prontas" e usamos indiscriminadamente sem entender os trade-offs das mesmas. Isso limita o programador e sua visão criativa/resolutiva, ou seja, ele é dominado pelas ferramentas que usa.

Conceitos Básicos

O algoritmo que iremos ver é o de busca binária (binary search), sendo o nome bem sugestivo podemos ter uma ideia do problema que ele resolve.

Imaginemos que você tenha que achar a pagina 567, porque por algum motivo você perdeu o marcador de novo, em um livro de 1000 paginas. Como você faria essa busca ? O mais comum a se fazer seria começar a busca pelo meio, certo ? Pois, a pagina 567 fica mais próxima do meio do livro. Com certeza, essa uma maneira bem mais rápida de buscar, do que olhar pagina por pagina.

O conceito de busca binária não é muito diferente do exemplo do livro, mas irei ilustrar com um exemplo um pouco melhor, menos livroso. Você está tentando adivinhar número de meias listradas (que é 57) que uma pessoa tem, ela irá te dizer se você disse um número muito acima ou baixo da atual quantidade, entre 1 a 100.

Há duas maneiras de resolver este problema:

Busca simples

Podemos começar pelo número 1, 2, 3, 4, 5... e assim por diante, estando essas tentativas muito abaixo do número atual de meias listradas e continuaremos a verificar item por item até o número desejado.

Busca binária

Outra opção seria começar pelo meio, no caso, o número 50 que ainda está abaixo da quantidade atual. Sabendo disso podemos eliminar a metade (1 a 50, nos restando de 51 a 100) e tentar novamente, por exemplo 58, mas ainda é um valor acima do número que procuramos, mais uma vez eliminamos a metade (de 58 a 100, nos restando de 52 a 57) e tentamos novamente. Podemos tentar agora 57 e acertamos a quantidade das benditas meias listradas. Veja o exemplo escrito em C logo abaixo:

// Bem, aqui estamos passando uma lista de inteiros e o seu tamanho (uma cortesia do C)
int binary_search(int itens[], int length)
{
    int abaixo = 0;
    int acima = length - 1;

    // O nosso intuito é iniciar nossa busca pelo meio da lista
    int meio = length - 1 / 2;

    // Item que desejamos achar
    int item_desejado = 5;

    while (abaixo <= acima)
    {
        // Atualizando o nosso "novo meio"
        meio = abaixo + acima;

        // Nosso palpite sempre será o meio da nossa lista
        int palpite = itens[meio];

        // Se nosso palpite estiver certo, retornamos o lugar onde o item está
        if (palpite == item_desejado)
            return meio;

        // Caso esteja errado, iremos verificar se o palpite está muito acima ou abaixo do esperado
        if (palpite > item_desejado)
        {
            // Estando acima do esperado, cortamos metade das possibilidades acima
            acima = meio - 1;
        }
        else
        {
            // Estando abaixo do esperado, cortamos metade das possibilidades abaixo
            abaixo = meio + 1;
        }
    }


}

Contudo o algoritmo irá funcionar apenas com lista de dados ordenados, como [1,2,3] ou ["Ana", "Bob", "Carla"].

Mas você já deve estar conseguindo sentir o cheirinho das aplicações desse algoritmo no mundo real, como consultas em banco de dados ou pesquisa de uma música na sua playlist (se ordenada).

FUNDAMENTALS - CONCEITO DE FLOATING POINT NUMBER

feitoza — Sat, 25 Feb 2023 09:09:30 +0000

Introdução

Pode parecer algo simples e cotidiano, mas os números fracionados/racionais, como 1.5, 0.25, 0.000005 eram um desafio para os computadores operarem e representarem. Então irei apresentar os conceitos básicos de como chegamos ao que conhecemos hoje como float number e as vantagens e desvantagens (ou quase).

Como computadores representam números

Quando pensamos na representação de números para computadores o sistema binário é essencial, pois 1s e 0s podem ser interpretados como "on" e "off", sendo cada um desses estados um bit de informação, perfeito para máquinas.

Então poderíamos representar os números 8 e 4 desta maneira, respectivamente, em binário 1000, 100. Agora que conseguimos representa-los para o computador, ele pode começar a realizar operações, tais como uma adição $1000 + 100 = 1100$ ou $8 + 4 = 12$ .

De fato, as máquinas não tem dificuldades na representação de números inteiros ou mesmo em realizar operações matemáticas, contudo como poderíamos fazer o mesmo com números fracionados ?

Fixed point number

Podemos representar números fracionados em binário da mesma maneira que números decimais 10.2 -> 1010.10. O principal para a representação desses números é o ponto decimal, separando a parte inteira da fracionada. Contudo, este ponto é algo "imaginário", conseguimos representar sem problemas no papel, mas com máquinas é diferente, pois há apenas 0s e 1s para se trabalhar.

Mas gigantes descobriram que os computadores poderiam representar números fracionados da seguinte maneira:

// vamos imaginar que temos 12 bits de informação
 000000000000

// separamos 8 bits para a parte inteira do número
 [00000000]0000

// e 4 bits para representar a parte fracionada
 [00000000][0000]

Logo, poderíamos representar o número 10.125, assim:

// convertemos para binário
 10.125 -> 1010.001

// adicionamos zeros até dá os 8 bits da parte inteira
 00001010

// e os 4 bits representando a parte fracionada
 00001010 0010

OBS: cada coluna dos 4 bits da parte fracionada representam os seguintes valores $12\frac{1}{2}$ , $14\frac{1}{4}$ , $18\frac{1}{8}$ , $116\frac{1}{16}$ .

Entretanto, se você necessitar de um número muito preciso, o método fixed point não será o melhor, pois a quantidade de bits limita o quão pequeno ou grande o número pode ser, logo perdendo precisão, contudo ele é ótimo para sistemas em tempo real que necessitam de velocidade e não precisão.

Floating point number

Lembram-se do conceito de notação científica ? ...não se preocupe, vou te refrescar a memória.

Temos um número real N que deve ser $1 >= N < 10$ , podemos chamar essa parte de mantissa, também temos um inteiro n, o expoente, nos informando quantas colunas/casas o ponto deve andar para representar o número de fato.

Então ficaria assim: $6.25 * 10^{9} = 6250000000$ , desta maneira conseguimos representar números colossais, como a velocidade da luz no vácuo $\frac{m}{s}$ ou mesmo a massa de um elétron $9,11 * 10^{-31} kg$ .

Flexível, né ? E é com essa mesma premissa que os floating point numbers se utilizam para representar números fracionados.

Vamos entender isso de forma simplificada, pensando em um sistema de 32 bits podemos utilizar 1 bit como sinal, positivo ou negativo, 8 bits para o expoente, que definirá onde nosso ponto irá estar, separando a parte inteira da fracionada, e 23 bits para a mantissa, o número de dígitos em si.

Com isso podemos representar o número 10.5 da seguinte maneira

// convertemos para binário 
    10.5 -> 1010.1

// passamos para notação científica 
    1010.1 -> 1.0101 e3     // colocamos o ponto após o primeiro digito e contamos
                            // quantas casas há depois do ponto até a parte fracionada
                            // onde *e* é o expoente, nos dizendo a quantidade de casas
                            // que o ponto tem que pular.


// agora vamos somar o expoente 3 com 127
// que nos permite representar números de -127 até 127
    3 + 127 = 130 -> 10000010  // agora temos o expoente

// acrescente zeros até dá os 24 bits da mantissa
    1.0101 -> 1.0101000000000000000000

// remova o digito antes do ponto, ficando 23 bits para a mantissa
    1.0101000000000000000000 -> 0101000000000000000000

Resultado

Sinal	Expoente	Mantissa
0	10000010	0101000000000000000000

Agora podemos pegar a mantissa e pular a quantidade de colunas/casas a partir do primeiro digito que o expoente nos informa.

Desta maneira, computadores conseguem representar números fracionados com maior precisão e realizar operações, como adição, subtração e entre outras.

O fato de este padrão (estabelecido pelo IEEE) se chamar numero de ponto flutuante se dá pelo fato das casas/colunas que pulamos para estabelecer o ponto imaginário que divide a parte inteira da fracionada.