Desmascarando o Modismo: Avaliando as Dependências do Projeto usando o Conceito de Wardley Map
Tags: typescript, javascript, wardleymap, frontend
Published: 2023-07-09 15:47:25

No mundo do desenvolvimento de software, é comum observar tendências e modismos surgindo a todo momento. Muitas vezes, os desenvolvedores se deixam levar por essas modas, adotando dependências sem uma análise cuidadosa de sua real efetividade. Neste post, vamos mergulhar no universo do TypeScript e desafiar os desenvolvedores que adotam dependências por modismo, usando o conceito do Wardley Map para avaliar suas finalidades e os problemas que elas realmente resolvem.

## Wardley Map e a análise das dependências em TypeScript

O Wardley Map é uma poderosa ferramenta que nos permite visualizar e entender o posicionamento de diferentes componentes dentro de um ecossistema. Aplicaremos esse conceito para analisar as dependências do projeto em TypeScript, questionando sua verdadeira finalidade e a necessidade de sua adoção.

## Perguntas provocativas

Vamos enfrentar a realidade de frente e fazer perguntas desafiadoras sobre as dependências que muitos desenvolvedores adotam por modismo:

### Qual é a finalidade dessa dependência?

Vamos questionar a razão pela qual essa dependência foi introduzida no projeto. Analisando o exemplo abaixo, temos uma cadeia de operações aritméticas simples. Precisamos avaliar cuidadosamente se a dependência do `pipe` realmente adiciona algum valor significativo ou se é apenas um acréscimo desnecessário.

### Quais problemas estamos enfrentando?

Ao analisar as dependências, vamos identificar os problemas reais que estamos enfrentando no desenvolvimento em TypeScript. Nesse caso, o exemplo demonstra uma sequência de transformações aritméticas aplicadas a um valor. Será que a dependência do `pipe` está abordando esses problemas de forma efetiva, ou estamos apenas seguindo o rebanho, sem obter benefícios reais para o projeto?

## Classificação das dependências

Vamos agora classificar a dependência do pipe com base em sua efetividade real. Utilizaremos a escala de avaliação previamente estabelecida com cinco níveis:

1 - `Pouco efetivo`:
A dependência não traz benefícios perceptíveis e não resolve problemas específicos do projeto em TypeScript.

2 - `Moderadamente efetivo`:
A dependência traz alguns benefícios tangíveis, mas existem desafios ou limitações que afetam sua efetividade geral no projeto.

3 - `Efetivo`:
A dependência é efetiva na resolução dos problemas do projeto em TypeScript, proporcionando melhorias significativas na produtividade, qualidade do código e colaboração da equipe.

4 - `Altamente efetivo`:
A dependência oferece vantagens substanciais, como uma sintaxe mais clara e legível, facilitando o encadeamento de operações.

5 - `Totalmente efetivo`:
A dependência é totalmente efetiva na resolução dos problemas do projeto em TypeScript, atendendo plenamente às necessidades e desafios, proporcionando um ambiente de desenvolvimento altamente produtivo, seguro e eficaz.

## Provocação aos desenvolvedores

Aos desenvolvedores que adotam dependências por modismo, desafiamos vocês a questionar a real necessidade dessas bibliotecas e frameworks adicionais. Será que elas realmente resolvem os problemas do seu projeto ou estão apenas aumentando a complexidade desnecessariamente?

### Exemplo de uso do pipe em JavaScript e TypeScript

Vamos usar o exemplo abaixo para ilustrar o uso do pipe em JavaScript e TypeScript, destacando a complexidade desnecessária no segundo exemplo em TypeScript:

**Javascript**

```js
const pipe = (value) => ({
  done: () => value,
  pipe: function (fn) {
    value = fn(value);
    return this;
  },
});

const valor = pipe(5)
  .pipe((x) => x + 2)
  .pipe((x) => x * 3)
  .done();

console.log(valor); // Saída: 21
```

**Typescript**

```js
const pipe = <T>(value: T) => ({
  done: () => value,
  pipe: function (fn: (input: T) => T) {
    value = fn(value);
    return this;
  },
});

const valor: number = pipe(5)
  .pipe((x: number) => x + 2)
  .pipe((x: number) => x * 3)
  .done();

console.log(valor); // Saída: 21
```

Nesse exemplo, o `pipe` é usado para encadear operações aritméticas em um valor. No exemplo, o valor 5 é passado pelo `pipe` e sofre uma série de transformações: primeiro, é adicionado 2, e em seguida, multiplicado por 3. O resultado final será 21, independentemente de ser escrito em JavaScript ou TypeScript.

No entanto, no exemplo em TypeScript, podemos notar a complexidade extra devido às anotações de tipo adicionais e declarações explícitas. Embora o TypeScript traga benefícios em projetos complexos, nesse caso simples, a complexidade adicional não traz benefícios significativos em relação ao exemplo em JavaScript puro.

## Conclusão

Ao avaliar as dependências do projeto utilizando o conceito do Wardley Map, podemos desmascarar o modismo e tomar decisões mais embasadas. No caso do pipe, é importante questionar a real efetividade dessa dependência adicional e a complexidade que ela pode trazer. Não se deixe levar pelo rebanho! Seja um desenvolvedor crítico e adote dependências com base em sua verdadeira necessidade e efetividade, não por mero modismo.

Lembre-se de que nosso objetivo é criar projetos eficientes e sustentáveis, utilizando as dependências certas para resolver problemas reais. Desafie o status quo e seja um agente de mudança em busca de soluções realmente efetivas.