teleren/devto huggingface dataset:
Java Efetivo Essencial - Injeção de Dependência
Tags: java, programming, javaefetivo, dependencyinjection
Published: 2022-08-07 15:44:56

## Dê preferência à injeção de dependência para integrar recursos 

_Esta é uma série baseada no entendimento de tópicos relacionados ao livro com foco no resumo._

**Entendendo...**

O que mais temos em projetos Java são classes que acabam dependendo do comportamento de outras classes. 
É claro que quando estamos falando do mundo Spring a coisa parece ser mais simples e talvez o livro seja agnóstico ao framework então ele se concentra em como era por vezes na linguagem.
Ele cita duas formas que poderiam ser feitas mas que geraria uma implementação inflexível.

**Colocar a dependência de forma estática**

```java
public class GeradorDeRelatorioFinanceiro {
    
    private static final CalculadoraFinanceira
        calculadora = new CalculadoraFinanceira();

    public GeradorDeRelatorioFinanceiro() {
    }
}
```
**Colocar a classe que recebe a  dependência como um singleton**

```java
public class GeradorDeRelatorioFinanceiro {
    
    private final CalculadoraFinanceira
        calculadora = new CalculadoraFinanceira();

    private GeradorDeRelatorioFinanceiro() {}
    
    public static GeradorDeRelatorioFinanceiro INSTANCE =
      new GeradorDeRelatorioFinanceiro();
}
```

**Porquê?**

 As duas abordagens anteriores não permitem flexibilidade de recebimento da dependência, o que torna o código difícil de manusear e o que dificulta os testes.
Para conseguirmos atuar com dependência de maneira flexível o ideal é recebermos a dependência através do construtor da classe.
_Atenção: Usar esse argumento com a Injeção de dependência do Spring não funciona pois conseguimos injetar o objeto mesmo não recebendo ele pelo construtor._

**Modo certo**

```java
public class GeradorDeRelatorioFinanceiro {
    
    private final CalculadoraFinanceira calculadora;

    public GeradorDeRelatorioFinanceiro(CalculadoraFinanceira calculadora) {
        this.calculadora = calculadora;
    }
}
```

**Pera**

A Injeção de dependência melhora considerávelmente a flexibilidade e a testabilidade, porém sobrecarrega sistemas que possuem muitas dependências. Para essa sobrecarga o ideal é utilizar um framework que faça  a Injeção de dependência como por exemplo o Spring.
Here is what took me an hour to sort with Prisma today.
Tags: typescript, beginners, webdev
Published: 2022-08-07 15:41:44

So today I started learning a bit more about Prisma using MongoDB. But I encountered and issue that seemed mind boggling.

 `TypeError: Cannot read properties of undefined (reading 'findMany')`

**TLDR: Restart the server after changing Prisma Schemas.**

I was trying to run the following code:

```
const breakTimeLog = async (req: NextApiRequest, res: NextApiResponse) => {
  const tests = await prisma.breakTimeLog.findMany();
  res.status(200).json(tests);
};
```

The reason that it was mind boggling is that if I would replace `breakTimeLog` with `user` it worked fine. I tried renaming and regenerating the schema as I thought it was a naming issue due to camel case. That was the only thing I could see being different. But no luck ):

Here is the Schema itself
```
model User {
    id            String         @id @default(auto()) @map("_id") @db.ObjectId
    fname         String
    lname         String
    breakTimeLogs BreakTimeLog[]
}

model BreakTimeLog {
    id            String   @id @default(auto()) @map("_id") @db.ObjectId
    date          DateTime
    timeInSeconds Int
    timeOfBreak   DateTime @default(now())
    user          User     @relation(fields: [userId], references: [id])
    userId        String   @db.ObjectId
}
```
Every place I looked suggested to generate the schema again or that there is a spelling issue. After an hour on the google rabbit hole I gave up and started hacking at it with random stuff.

Here is the twist I **did not restart** the server after I created the new model after doing so everything is working fine!
ICON CONVERTER
Published: 2022-08-07 15:40:00

Most computer imaging software provides several formats for images, including .ico files. These are regular icons, typically used for Applications, sites, or games. These .ico files can be used for print advertising as well. If you wish to utilize an image as an icon on a device or computer screen, you must first convert it to the icon format. There are several ico converter tools available to assist in the creation of the icon.

## Use Photoshop

Adobe Photoshop can be used to create pictures and edit pictures, but as an icon editor, it is not as intuitive as it could be. The solution is to download a [free plugin](https://www.mediacollege.com/adobe/photoshop/plugins/ico/) that is easy to acquire and simple to install. To install the plugin, download the zipped package and, when requested, place it in the Photoshop Plugins folder. When the installation is finished, restart Photoshop. Open the JPG picture file that you wish to use as an icon. To create the icon, simply save the file with the file extension.ico using the plugin.

## Use an Online Converter

[ICO Converter](https://www.seosniffer.com/ico-converter) is a free online tool that will convert any picture file into an icon. Convert a PNG, GIF, or JPG into icon files. This program does not need to be downloaded, which adds security to the process of downloading web software packages onto your computer. You may use ICO Converter to convert a single image or a group of images. It can also merge PNG pictures into a single icon or divide an [icon](https://www.seosniffer.com/ico-converter) into images. To load the picture files into the application

## Build Your Code

In the last few years, I've grown to love the C# programming language; creating an ico converter is as easy as writing a few lines of code.
```
static void Main(string[] args)
        {
            string image_read_path = Directory.GetCurrentDirectory()+"\\image.png";
            string image_save_path = Directory.GetCurrentDirectory()+"\\image.ico";
            if (File.Exists(image_read_path))
            {
                using (FileStream stream = File.OpenWrite(image_save_path))
                {
                    try
                    {
                        Bitmap bitmap = (Bitmap)Image.FromFile(image_read_path);
                        Icon.FromHandle(bitmap.GetHicon()).Save(stream);
                        Console.WriteLine("File Converted");
                        Console.ReadKey();
                    }catch(Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                        Console.ReadKey();
                    }
                }
            }
            else
            {
                Console.WriteLine("File Not Found");
                Console.ReadKey();
            }
            

        }
    }
```
Java Efetivo Essencial - Singleton
Tags: java, programming, singleton, javaefetivo
Published: 2022-08-07 15:38:57

## Implemente a propriedade de um singleton com um construtor privado ou um tipo enum

_Esta é uma série baseada no entendimento de tópicos relacionados ao livro com foco no resumo._

**Entendendo...**

Singleton é um design pattern utilizado para instanciar uma única vez uma classe durante o ciclo de vida da aplicação.
Exemplos de objetos tipo singleton que utilizamos no dia a dia em aplicações Java são Enum e os Beans do Spring que por padrão são criados como singleton.
 Singletons representam um objeto sem estado na aplicação, com a função de executar tarefas / funções.

**Como?**

 Duas formas mais comuns de se criar um Singleton envolvem manter seu construtor privado e ter seus atributos como estáticos publicos para que seja permitido o acesso a instância única.

Exemplo A

```java
public class CalculadoraDeMateriais {
  public static final CalculadoraDeMateriais INSTANCE = new CalculadoraDeMateriais();

  private CalculadoraDeMateriais() {
  }
}
```

**Atenção**

 Apesar de garantirmos que somente uma única instância seja invocada no exemplo A, um cliente com privilégios pode utilizar o método AccessibleObjet.setAccessible para acessar o construtor privado então para nos precavermos para essa possibilidade utilizamos o exemplo B, onde garantimos que caso já exista a instância que seja lançada Exception.

Exemplo B

```java
public class CalculadoraDeMateriais {

  private static final CalculadoraDeMateriais INSTANCE=
          new CalculadoraDeMateriais();

  private CalculadoraDeMateriais() {
    if (INSTANCE != null) {
      throw new IllegalStateException();
    }
  }

  public static CalculadoraDeMateriais getInstance() {
    return INSTANCE;
  }
}
```

**Mais informações...**

- A abordagem do campo público deixa bem claro que o objeto é um singleton.
- Podemos utilizar junto com o static factory pois isso permite flexibilidade futura caso não queira mais que seja um singleton. 
- Mas a maioria dos casos onde queremos usar um objeto como singleton podemos utilizar Enums que são classes que possuem atributos e métodos e possuem uma única instância em tempo de execução.
- Utilizar Singleton como mostrado nos exemplos acima é pouco usual hoje em dia e é mais difícil de testar.
- Quando estamos falando do uso de Beans do Spring por exemplo que tem como padrão serem criados com escopo de Singleton conseguimos testar.
- Casos mais comuns hoje em dia que utilizamos no código e que funciona super bem são os Enums.
Fonts Resources
Tags: fonts, design, resource, ux
Published: 2022-08-07 15:34:39

👋Hello Guys
Today we will see some of awesome fonts RESOURCES

✨There is no doubt that fonts doesnt matter in Design. In fact Font make a lot of Difference and Make your Design Awesome When used Correctly

🏆 So to make you Design Awesome here Are Font Resources 
 
📌[fonts.com](https://www.fonts.com/)
📌[fontbundles.net](https://fontbundles.net/free-fonts)
📌[behance.net](https://www.behance.net/search/projects/?sort=appreciations&time=week&search=free%20font)
📌[dribbble.com](https://dribbble.com/tags/free_font)
📌[dafont](https://www.dafont.com/)
📌[urbanfonts.com](https://www.urbanfonts.com/)
📌[fontspace.com](https://www.fontspace.com/)
📌[fontsquirrel.com](https://www.fontsquirrel.com/)
useNavigate,Navigate and useLocation in React Router v6
Tags: react, javascript, webdev, beginners
Published: 2022-08-07 15:33:02

## What is useLocation?
useLocation is hook that allows us to get the current location(or URL) of the web app.

```
const currentLocation = useLocation()
console.log(currentLocation)
```

!["console-results"](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3ciqf87i1yvvbse718j8.png)
 


## What is useNavigate?
useNavigate is a hook that allows to create a function that'll help a user navigate to a particular page (based on an action). You can customize it to redirect the user to the login page or user Dashboard.

```
import React from "react";
import { useNavigate } from "react-router-dom";

const Home = () => {
  const navigate = useNavigate();

  return (
    <div>
      <h2>Visit my profile</h2>
      <button
        onClick={() => {
          console.log("redirecting.....");
          navigate("/profile");
        }}
      >
        My Profile
      </button>
    </div>
  );
};

export default Home;

```
Now what if you want to go back to the Home page without clicking the browser "Back" button? We provide a button.

```
import React from "react";
import { useNavigate } from "react-router-dom";

const Profile = () => {
  const navigate = useNavigate();

  return (
    <div>
      <h2>You are awesome!</h2>
      <button
        onClick={() => {
          console.log("redirecting.....");
          navigate(-1);
        }}
      >
        Home
      </button>
    </div>
  );
};

export default Home;

```

## What is Navigate?
Navigate is basically useNavigate() converted into a React component. This makes it easy to implement in our React apps.

props it takes -

- state - optional -> stores state and can be used to store the location of the current or previous page
- replace - optional -> helps in redirecting to the location specified in the state.

```
 return (
    <BrowserRouter>
      <Container maxWidth="lg">
        <Navbar />
        <Routes>
          <Route exact path="/"  element ={<Home/>} />
          <Route path="/auth"  element={<Auth/>} />
          <Route path="/posts" exact element={<Home/>} />
{/*
the Navigate component redirects the user to posts section on getting rendered.
This happend IF the user is logged in(user object is present).
*/}
          <Route path="/auth" exact element={() => (!user ? <Auth /> : <Navigate to="/posts" />)} />
        </Routes>
      </Container>
    </BrowserRouter>
  )
};
```
Java Efetivo Essencial- Builder
Tags: java, builder, javaefetivo, programming
Published: 2022-08-07 15:20:00

## Cogite o uso de um Builder quando se deparar com muitos parâmetros no construtor

_Esta é uma série baseada no entendimento de tópicos relacionados ao livro com foco no resumo._

**Entendendo...** 

Quem nunca precisou construir um objeto que tinha muitos parâmetros? Aliás o que será muitos? Bom existem muitas discussões de quanto seria essa quantidade, eu costumo a usar o nº 5 como fator decisivo  e analisar se o objeto tem perspectiva de crescimento, se sim eu já cogito criar um Builder.

**Por quê?**

 Quando construimos um objeto com muitos parâmetros estamos sujeitos a passarmos parâmetros errados, especialmente se o tipo deles for semelhante.
Além de ser difícil de escrever, é difícil de ler construtores com muitos parâmetros.

**O que é?**

 Builder é um padrão de design de código do tipo criacional. 
No java podemos criar um Builder dentro de nossa classe e tornar a criação do objeto mais simples e a leitura do código melhor, principalmente quando envolve muitos parâmetros e parâmetros opcionais, o que evita termos sobrecarga de construotres, quem nunca viu objetos com vários tipos de construtores?

**Principais Vantagens**

- Esse padrão se adequa bem a heiraquia de classe;
- Facilidade em lidar com parâmetros obrigatórios e não obrigatórios;
-  É flexível, uma implementação de Builder nos permite criar várias instâncias diferentes da mesma classe;


**Desvantagens** 

- Sempre teremos que criar um Builder para criar um objeto, embora de que talvez não seja algo que impacte em um alto custo de performance;
- É um padrão mais verboso;
- É uma implementação mais difícil que uso de construtores e o padrão telescoping;

**Conclusão** 

- Verifique se realmente vale a pena utilizar esse padrão;
- Nada impede de você começar com construtor e em caso de seu objeto  crescer com o tempo que ajuste o código para utilizar esse pattern;
How to make 3 composable function "communicate" with each other
Tags: vue, composable
Published: 2022-08-07 15:18:40

Hi devs! 
I am trying to do something simple with Vue.js and not sure if my approach is ok. 
So.. I'm trying to make 3 composable functions to "communicate". 
I'm just not sure how. 

```
export default useServer = (serverSettings) => {
    let connect = () => {...}
    let write = (command) => {
        // Gets a command from the users GUI @click
        // then passes it to the gateway.write(command)
    }
    let read = (data) => {
        // gets data from the gateway and prints data. 
    }
}

export default useDevice = (deviceSettings) => {
    let connect = () => {...}
    let write = (command) => {
        // executes command on device
    }
    let read = (data) => {
        // reads data from the device. 
    }
}

export default useGateway = (gwSettings, device, server) => {
    let connect = () => {...}
    let write = (command) => {
        // passes the command to the device write() method
    }
    let read = () => {
        // reads the data from the device and send it to the server
    }
}

let server = useServer(serverSettings)
let device = useDevice(deviceSettings)
let gateway = useGateway(gwSettings, device, server)
``` 

im not sure how to apply event listeners for this case. Since these are variables and not events. 
I thought of using the `watch` api for the read/write variables, instead of the current methods.
example: inside the `useGateway()` composables, to have some kind of a watcher: 
```
// note: the `write` variable should be changes to a regular variable and not a method

watch(
  () => server.write, // <-- watch this
  read // <-- trigger this
);
```
How to keep the HTTP cache fresh
Tags: javascript, http, cache, cli
Published: 2022-08-07 10:59:22

---
title: How to keep the HTTP cache fresh
published: true
description: 
tags: 
  - JavaScript
  - HTTP
  - Cache
  - CLI
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
---
HTTP caching is divided into two types, but for static resources, I think most people open the mandatory cache, right?

But there is a disadvantage of forced caching that there is no way to guarantee the **freshness (latest)** of the resources, you can only wait for the cache time to expire to get the latest resource content

So I wrote a library [Cache-Hash](https://github.com/Lete114/cache-hash) that specifically deals with HTTP cache busting

> I've used it on my blog: [https://blog.imlete.cn](https://blog.imlete.cn)

## Principle

By adding a hash version number to the resources introduced to the website, once the content changes, the hash will change, so that the cache can be broken by changing the url address, which ensures that the resources referenced by the website are up to date.

For example, the following form
```html
<script src="https://demo.com/js/main.js?v=5e74b42bf5"></script>
```

## Usage

You can use **CLI (command line tool)** or **JavaScript API** to generate hash for references to static resources

can be installed globally using

```bash
npm install cache-hash -g

cache-hash --target source --output public

# abbreviated

cache-hash -t source -o public
```

If you don't want to install it globally, you can use npx

```bash
npx cache-hash --target source --output public
```

## How does it work? 

It reads your given **target** directory, detects all html, css, js in the directory, and generates an **AST (Abstract Syntax Tree) for these files**, and then compiles the source code back through the ast syntax tree after modifying the contents of the ast syntax tree.
Java Efetivo Essencial - Static Factory
Tags: java, effectivejav, staticfactory, programming
Published: 2022-08-07 15:14:00

## Prefira utilizar métodos static Factory em vez de contrutores

_Esta é uma série baseada no entendimento de tópicos relacionados ao livro com foco no resumo._

**Porquê**

Ter os contrutores privados e utilizar um método estático como fábrica para criar seu objeto garante que apenas a classe saberá como criar o objeto, evitando problemas futuros. Podemos perceber que muitas classes do Java utilizam essa abordagem.

**Principais Vantagens **

- Nome e assinatura do método mais claro do que utilização direta do construtor;
- Permite a reutilização de objetos evitando que se crie sempre uma nova instância do objeto;
- Pode retornar um objeto de qualquer subtipo do próprio tipo de retorno( classes que implementam a mesma interface);

**Desvantagens**

- Classes sem construtores públicos ou protegidos não podem ter subclasses;
- Acabam sendo difíceis de serem encontrados pelos programadores;
- Dependendo da biblioteca que você utilize de banco de dados ou conversão de dados não irá funcionar sem construtor publico;

**Nomes comuns para métodos static factory **

- from
- of
- valueOf
- create
- getInstance
- getType
Criando DLQ no SQS
Tags: sqs, dlq, messaging, aws
Published: 2022-08-07 15:05:00

**O que é?**

Filas de mensagens mortas, acaba sendo uma fila, mas com um objetivo diferente. Esta fila irá receber as mensagens que não foram processadas em sua fila de origem.

**Contextualizando**

Normalmente quando um consumidor tenta por vezes processar uma mensagem e por algum motivo não conseguem essa mensagem retorna para a fila. E o ciclo de tentativa de leitura se repete e para que as demais mensagens da fila sejam processadas o ideal é redirecionarmos as mensagens que estão com algum problema.

Um exemplo clássico pode ser no modelo da mensagem, o produtor da mensagem gerou o modelo de forma diferente do que o consumidor espera. 

No SQS podemos fazer o controle desse redirecionamento através da configuração de qual seria a fila utilizada como DLQ e qual a quantidade máxima de tentativas de leitura máxima para que então seja redirecionada a mensagem.

O uso de DLQ varia muito de acordo com o Broker/ MOM que estamos utilizando, esse artigo via explicar apenas como proceder utilizando o SQS.

**EXEMPLO**

Exemplo de como realizamos via comando do AWS CLI a criação da DLQ, o exemplo abaixo estou utilizando Localstack localmente:

Vamos primeiramente criar uma fila usando a AWS CLI que será a nossa DLQ:

``` shell
aws --endpoint-url=http://localhost:4566 sqs create-queue --queue-name aviso_dlq
```

Agora vamos criar a fila principal para receber as mensagens e então vamos configurar os parâmetros de DLQ dela:

``` shell
aws sqs create-queue --queue-name aviso \
    --attributes '{"RedrivePolicy": "{\"deadLetterTargetArn\":\"arn:aws:sqs:sa-east-1:000000000000:aviso_dlq\",\"maxReceiveCount\":\"4\"}"}' \
    --endpoint-url=http://localhost:4566
```

Vejam que configuramos o deadLetterTargetArn e o maxReceiveCount, o primeiro parâmetro indica o endereço ARN da fila que criamos para ser a DLQ e o segundo parâmetro irá indicar a quantidade máxima que podemos fazer a tentativa de leitura da mensagem .

Exemplo do comando que fiz para consultar via AWS CLI o endereço ARN, para também serve para consultar qualquer outro atributo da fila:

``` shell
aws --endpoint-url=http://localhost:4566 sqs get-queue-attributes --queue-url http://localhost:4566/000000000000/aviso_dlq --attribute-names All
```

**Redrive allow policy**

O AWS SQS tem um recurso que permite que sejam redirecionadas mensagens da fila DLQ para a fila de origem ou outra para que estas sejam processadas de fato pelo consumidor.
Este recurso ainda esta limitado somente ao console da AWS mas evita que sejam criados processamentos adicionais para realizar este fluxo.
What are the little things that regularly annoy you or slow you down?
Tags: community, culture
Published: 2022-08-07 13:58:58

I'll admit it, being a software engineer doesn't come short of annoying little things once in a while. 

We're all built differently, some of us find those annoyances in little technical things that we may often forget or wish we knew better, organisational or at a deeper personal level, or perhaps external, like how annoying some rituals can be in some big and/or small orgs (not speaking just for myself).

Mine would be:
 1. Technical, that I almost always wish I had time to cleanup my shell profiles and easily sync those across different shells (zsh, fish etc.), there's always something more important to do - someday I will thou. 

If you have a solution to this, please help a friend out!

 2. Organisational, from time to time I work with agile teams. I'm not a fan of Agile, I've consistently delivered arguably what is considered high quality software throughout the years for customers that still use it or keep it updated to date, with one or two meetings of about 1 hour each, roughly every two weeks, meetings for me are useless and I am aware that some may disagree completely. 

The key here is to really listen and focus during those one or two meetings and apply solid communication and critical thinking skills to really understand the given problem space.

From there on, solid engineering principles would get you out of muddy situations, not politics or more meetings.

What I've found is that some founders do tend to get caught up in what they think it works and then ~~enforce~~ (recommend) some rituals usually found in the "holy book" of Agile. 
There is good software beyond Agile too, trust me!


How do you manage to navigate your complex day-to-day landscape?

What are your little annoyances that you would like to help increase awareness on?