
> For every complex problem, there's a solution that is simple, neat, and wrong. - H.L. Mencken


Complex Problems


Since ~2015 - wow, almost 10 years ago - I was using [zsh](https://www.zsh.org/) + [oh-my-zsh](https://ohmyz.sh), and it was great. But after some years it was becoming show, and since I love to try new things I decided to explore new shell options.

TL/DR: I am using [fish](https://fishshell.com/) now. Why?

- It seems faster, at least in those first days / fresh install
- I was using [oh-my-zsh](https://ohmyz.sh) mainly for aliases (e.g. [git](https://github.com/ohmyzsh/ohmyzsh/blob/master/plugins/git/README.md)), but [abbreviations are much better for history and share commands](https://www.sean.sh/log/when-an-alias-should-actually-be-an-abbr/).
- Auto complete seems to works better + syntax highlight
- Functions (super easy syntax)
- All the things that I was using continue to work as expected (e.g. [mise](/blog/posts/2024-09-24-mise), [zoxide](https://github.com/ajeetdsouza/zoxide), etc). No reason to not work, but worth to mention
- Saw others moving from zsh to fish, it seems a natural moving
- [11 reasons here](https://itsfoss.com/fish-shell-features/)

# Super quick start

```bash
# Install fish on OSX
brew install fish

# Add it to possible terminals
code /etc/shells
# Manually add /opt/homebrew/bin/fish (ok, could do it with echo but choose not to)

# Change default terminal
chsh -s /opt/homebrew/bin/fish

# Have fun
```

# Customizations

- I installed [fisher](https://github.com/jorgebucaran/fisher) to add extensions, but didn't find a need for it yet. [Auto pair](https://github.com/jorgebucaran/autopair.fish) is the only one active
  - [fish-abbreviation-tips](https://github.com/gazorby/fish-abbreviation-tips) is great, but since switched aliases for [abbreviations](https://www.sean.sh/log/when-an-alias-should-actually-be-an-abbr/) it doesn't make sense anymore.
- For themes and colors I was using [starship](https://starship.rs/). Decided to stick on it for now, configs [here](https://github.com/adamatti/dotfiles/tree/main/starship).
- [Abbreviations!](https://www.sean.sh/log/when-an-alias-should-actually-be-an-abbr/) You can create it even for parameters and can edit the commands prior to execute.

# Next

- Join [reddit group](https://www.reddit.com/r/fishshell/)
- Take a look on [fisher plugins](https://github.com/jorgebucaran/awsm.fish#readme), [github repos](https://github.com/topics/fish), etc
- Add a star in the [fish-shell](https://github.com/fish-shell/fish-shell) repo


Fish Shell


> If you’re not embarrassed by the first version of your product, you’ve launched too late - Reid Hoffman


You’ve launched too late


I saw this in a webinar:

> A Sports Illustrated article reports that 78% of NFL players and 60% of NBA players face serious financial hardships after retirement ([source](https://www.abi.org/feed-item/how-athletes-go-bankrupt-at-an-alarming-rate))

> Sports Illustrated [estimates](https://vault.si.com/vault/2009/03/23/how-and-why-athletes-go-broke) 78% of NFL players face financial trouble within two years of leaving the game, and another 60% of NBA players are in the same boat five years after retirement ([source](https://cyndeowp.com/the-five-main-reasons-professional-athletes-go-broke/))

## My take on this?

It is not how much you earn, it is about how you expend it.

You need to know the difference about active asset and passive asset.

## References

- https://vault.si.com/vault/2009/03/23/how-and-why-athletes-go-broke
- https://www.abi.org/feed-item/how-athletes-go-bankrupt-at-an-alarming-rate
- https://cyndeowp.com/the-five-main-reasons-professional-athletes-go-broke/
- https://bolavip.com/en/nba/nfl-and-nba-players-who-lost-millions-and-went-broke-after-retiring
- https://www.investopedia.com/financial-edge/0312/why-athletes-go-broke.aspx


Athletes Go Bankrupt


Today I replaced [docker-desktop](https://www.docker.com/products/docker-desktop/) by [OrbStack](https://orbstack.dev/).

Like mentioned by [OrbStack](https://orbstack.dev/):

> OrbStack is the fast, light, and easy way to run Docker containers and Linux. Develop at lightspeed with our Docker Desktop alternative

It is fully compatible, so no drastic changes.

You can check the [Docker x OrbStack comparison](https://docs.orbstack.dev/compare/docker-desktop), [Colima x OrbStack](https://docs.orbstack.dev/compare/colima) or [a review from @vortj](https://medium.com/@vortj/orbstack-review-a-game-changer-for-macos-developers-f1931a9db227).

If you want to fully uninstall docker desktop you can do it [here](https://docs.docker.com/desktop/uninstall/).

It also provides [kubernetes features](https://docs.orbstack.dev/kubernetes/), but I am using [kind](/blog/posts/2024-10-22-kind) for that.


OrbStack


Ok, let's say you need to test ingress changes and want fast feedback, and don't have access to actual k8s cluster. What would you do?

## Kind for the rescue

[Kind](https://kind.sigs.k8s.io/) is just one of the options. It could be [Minikube](https://minikube.sigs.k8s.io/), Docker Desktop, [K3s](https://github.com/k3s-io/k3s), [Microk8s](https://microk8s.io/), etc

My goal is just share the steps I did to solve my problem, to others with similar needs and my future self.

## 1. First, a node app

Nothing fancy, just the basic to test:

a. `server.js`

```javascript
const express = require('express');
const app = express();
const PORT = process.env.PORT ?? 4000;

app.get('/*', (req, res) => {
  res.json({
    date: new Date(),
  });
});

app.listen(PORT, () => {
  console.log('Server started');
});
```

b. `package.json`

```json
{
  "scripts": {},
  "dependencies": {
    "express": "^4.21.1"
  }
}
```

c. `Dockerfile`

```Dockerfile
FROM node:23

RUN mkdir -p /app
WORKDIR /app

COPY package.json ./
RUN npm install

COPY server.js ./

ENV PORT=4000
CMD ["node", "/app/server.js"]
```

Then build an image with something like `docker build --quiet . -t app:local`

## 2. The cluster

```bash
# Install kind on mac
brew install kind

# Create the cluster with custom config
cat <<EOF | kind create cluster --config=-
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
  kubeadmConfigPatches:
  - |
    kind: InitConfiguration
    nodeRegistration:
      kubeletExtraArgs:
        node-labels: "ingress-ready=true"
  extraPortMappings:
  - containerPort: 80
    hostPort: 80
    protocol: TCP
  - containerPort: 443
    hostPort: 443
    protocol: TCP
EOF

# Install nginx
kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/kind/deploy.yaml --context kind-kind

# Make sure it is working
kubectl wait --namespace ingress-nginx \
  --for=condition=ready pod \
  --selector=app.kubernetes.io/component=controller \
  --timeout=90s --context kind-kind
```

## 3. deploy the app

a. publish image to the cluster:

```bash
kind load docker-image app:local
```

b. create pod, service, ingress: just save it in a file (e.g. k8s.yaml)

```yaml
apiVersion: v1
kind: Service
metadata:
  name: node-app
  labels:
    app: node-app
spec:
  type: ClusterIP
  ports:
    - port: 80
      targetPort:
      protocol: TCP
      name: http
  selector:
    app: node-app
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-app
spec:
  replicas: 1
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 2
      maxUnavailable: 0
  selector:
    matchLabels:
      app: node-app
  template:
    metadata:
      labels:
        app: node-app
    spec:
      serviceAccountName: default
      securityContext: null
      containers:
        - name: node-app
          image: 'app:local'
          env:
            - name: PORT
              value: '80'
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: node-app
  annotations:
    kubernetes.io/ingress.class: nginx

spec:
  rules:
    - host: 'node-app.com'
      http:
        paths:
          - backend:
              service:
                name: node-app
                port:
                  number: 80
            pathType: ImplementationSpecific
```

c. apply the changes:

```bash
kubectl apply -f k8s.yaml --context kind-kind

```

## 4. Testing

a. with curl

```
curl --url http://localhost/test --header 'HOST: node-app.com'
```

or

b. with `/etc/hosts`

- Add `127.0.0.1 node-app.com` to `/etc/hosts`
- Access node-app.com on any browser

## 5. Done?

So, destroy the cluster to release memory:

```bash
kind delete cluster
```

## So...

If you tried it and worked (or not), pls let me know.

For me it worked, I hope it help others and my future self


Useful if you need to test ingress changes like me

Kind - k8s on local


I returned to use my old machine and found this screenshot - took it at 2022-02-10:

<center>
![Gardener](/assets/posts/2024-10-01-gardener.png)
</center>

Sorry, I don't know or remember the source to give credits.

But I do agree with the message. We - developers - should be more gardeners and less engineers.

This mindset also applies to parenting...


Software Gardener


The first time I saw this expression was at a [tech conference](https://thedevconf.com/palestrante/alexandre-freire-kawakami), a talk from [Alexandre Freire](https://www.linkedin.com/in/agile-cto).

If you don't know it, take a look at this video:

<center>
<iframe width="560" height="315" 
  src="https://www.youtube.com/embed/qmlYe2KS0-Y?si=54JTIezivr5vAXK4" 
  title="YouTube video player" 
  frameborder="0" 
  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" 
  referrerpolicy="strict-origin-when-cross-origin" 
  allowfullscreen></iframe>
</center>

There are more details on [Wikipedia](https://en.wikipedia.org/wiki/Cargo_cult), but TL/DR: indigenous saw planes dropping food / etc and thought it was God's gifts. When the war stopped and the army left, they repeated the same actions to keep receiving the gifts.

What message do you think we could take from this?

### If we don't know WHY we are doing something, we are not going to receive the benefits

In the agile context:

- If you don't know why we do retros, the team will not get better
- If you don't know why we do stand up / daily meetings, you may not have address communication and collaboration issues

In the tools context:

- If you don't know how "the tool" works and which problems it solves, you may introduce new issues
  - Some samples: kafka/kubernetes/microservices/graphql/etc

In the finance context:

- If you don't know how the market works, you may buy on high and sell on low
- If you don't know about Bitcoin, you may lose money

We can go on and on, about weight loss, metrics, entrepreneurship...

Using Steve Jobs shirts will not make you rich...

Neither wake up at 4 am...

Neither cold showers...


You need to know the "why" to receive the benefits from the Gods

Cargo Cult


I saw in twitter some time ago, I think it was suggested by [Akita](https://twitter.com/AkitaOnRails?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor) - disclaimer: unable to check here as [twitter still blocked in Brazil](https://www.bbc.com/news/articles/c5y3rnl5qv3o) - about [mise](https://github.com/jdx/mise), a version manager.

Previously I was using [gvm](https://github.com/moovweb/gvm) for golang, [fnm](https://github.com/Schniz/fnm) for node (it is like [nvm](https://github.com/nvm-sh/nvm), but faster), [sdkman](https://sdkman.io/) for java/jvm, some crazy tools for python/ruby, and [brew](https://brew.sh/) for the other (e.g. [bun](https://bun.sh/), [deno](https://deno.com/)).

With [mise](https://github.com/jdx/mise) I can use one tool for all. It is great because:

### 1. It does respect the other format configurations

`.ruby-version`? `.nvmrc`? We don't need to change existing projects to use it.

### 2. It is easy to install

`mise install` in an existing app, `mise use node@lts` / `mise use deno@latest` / etc to add a new dependency.

You can also install global ones, like `mise use --global opentofu@latest`

### 3. Easy to check required versions

Just run `mise ls`

### 4. Easy to upgrade all

`mise up`

### 5. It has hundreds of integrations

Check it all at [here](https://mise.jdx.dev/plugins.html)

### Others

It does integrate with bash / zsh for auto version switch (switch on cd).

It does support environment vars control and task automation, but I do prefer other tools for that.

I hope you enjoy it, let me know your thoughts in the comments.


Mise: a version manager


When people ask me about salaries working from LATAM to US companies, usually I share those links:

- https://app.comprehensive.io/benchmarking/s/jobFamily=Software+Engineering&level=IC3
- https://www.levels.fyi/2023
  - Check the [heatmap](https://www.levels.fyi/heatmap/)
- https://codesubmit.io/blog/software-engineer-salary-by-country/
- https://www.payscale.com/research/US/Job=Software_Engineer/Salary
- [Youtube - I asked developers how much MONEY they make](https://www.youtube.com/watch?v=8jRB-2AQ-mI) (note: it wasn't me)

### Oh, but I don't have a good English level

Check [this post from X-Team](https://x-team.com/blog/english-skill-as-a-developer)

Ping me if you thing I can help you to reach those positions.


Salary as software engineer


I just tried the new cloudflare worker. To create a sample and deploy there, you just need to run one single command:

```
pnpm create cloudflare@latest <project name>
```

... and of course, a lot of prompts.

I removed some dead code (editor config, prettier), added [biome](https://biomejs.dev/), added a [taskfile](https://taskfile.dev/) (I will forget the commands). Also played with [Hono](https://github.com/honojs/hono) - the web framework [suggested by Cloudflare](https://www.youtube.com/watch?v=H7Qe96fqg1M) and added an AI endpoint.

Pretty simple, reminds me the good old days with the free [Heroku](https://www.heroku.com/) tier.

For sure I will consider it for my pet projects.

My full code is available on [github](https://github.com/adamatti/learn-cf-worker).

Next, I will try it with [remix](https://remix.run/) for a full stack experience. If I got it right, it should be [super simple](https://hono.dev/examples/with-remix) (or [creating from scratch](https://developers.cloudflare.com/pages/framework-guides/deploy-a-remix-site/)).


Cloudflare workers


Hey, are you using [yarn](https://classic.yarnpkg.com)? Great tool from [Facebook](https://facebook.com), right?

But how are you installing it?

`npm install -g yarn`?

### I have a bad news to tell you...

> Yarn has not been distributed on npm since 2019 because of breaking changes that could impact deployments - Google AI

and

> Those versions entered maintenance mode in January 2020 - [yarn classic website](https://classic.yarnpkg.com/lang/en/docs/install)

### So, what should I do?

Need to consider a better/newer package manager.

It could be:

- [the new yarn version](https://yarnpkg.com/): as of today (09/06), it is on version 4.4.1
- [PNPM](https://pnpm.io/), the faster alternative
- [The NPM itself](https://www.npmjs.com/). The official tool. In 2024, it is faster than yarn classic

There are a lot of benchmarks out there, like:

- https://romanglushach.medium.com/comparing-npm-yarn-and-pnpm-package-managers-which-one-is-right-for-your-distributed-project-to-4d7de2f0db8e
- https://refine.dev/blog/pnpm-vs-npm-and-yarn
- https://www.dhiwise.com/post/pnpm-vs-npm-vs-yarn-which-javascript-package-manager

### How about me?

I am using [PNPM](https://pnpm.io/) in my latest projects, both pet and professional, but already had some issues with it.

It all case by case, but I strongly recommend to use [PNPM](https://pnpm.io/) for fast local builds and CI.


Yarn Classic


> I've learned that people will forget what you said, people will forget what you did, but people will never forget how you made them feel. - Maya Angelou


People will never forget how you made them feel


Just saw [this tweet](https://x.com/mattpocockuk/status/1825552684994457946) from [@mattpocockuk](https://twitter.com/mattpocockuk), code below:

![neverthrow](/assets/posts/2024-08-19-neverthrow.jpeg)

[neverthrow](https://www.npmjs.com/package/neverthrow) is very similar to [arrow (kotlin)](https://arrow-kt.io/learn/typed-errors/working-with-typed-errors/) and the way [golang handle errors](https://go.dev/blog/error-handling-and-go).

## Why?

Great explanation on [readme](https://github.com/supermacro/neverthrow), very bottom:

> **Throwing** and **catching** is very similar to using **goto** statements - in other words; it makes reasoning about your programs harder. Secondly, by using **throw** you make the assumption that the caller of your function is implementing **catch**. This is a known source of errors. Example: One dev **throw**s and another dev uses the function without prior knowledge that the function will throw. Thus, and edge case has been left unhandled and now you have unhappy users, bosses, cats, etc.

> With all that said, there are definitely good use cases for throwing in your program. But much less than you might think.

## Would I use it in a production code (javascript/typescript)?

Probably not as it changes the way the language was designed. A lot of frameworks/libs/integrations expect the code to throw on error (e.g. sentry, datadog, [express](https://expressjs.com/en/guide/error-handling.html)).

Use [golang](https://go.dev/) instead. 

But definitely I would use it for pet projects, to make the code more functional and avoid **goto** calls.

Typescript Lib - Neverthrow


I was trying to find an alternative to [aws-sso-creds-helper](https://www.npmjs.com/package/aws-sso-creds-helper) since it is archived/deprecated.

The "official" AWS solution is not great either (`aws sso login --profile <profile_name>`).

My coworkers are using [granted](https://docs.commonfate.io/granted/introduction). 

The [installation](https://docs.commonfate.io/granted/getting-started#installing-the-cli) was simple:

```
brew tap common-fate/granted
brew install granted
```

The [configuration](https://docs.commonfate.io/granted/usage/automatic-config-generation#all-available-aws-sso-roles) was all auto generated:

```
granted sso generate --sso-region ap-southeast-2 https://example.awsapps.com/start
```

And to use is basically `assume <role>`. I can even add it to my existing scripts.

We can also [export it to .env file](https://docs.commonfate.io/granted/usage/dotenv):

```
assume role-a --env
```

Plus, [we can access different profiles in different browser tabs](https://docs.commonfate.io/granted/usage/console):

```
assume -c <role>
```

Super useful, highly recommended.

AWS Granted


> Everything You Have Ever Wanted Is On The Other Side Of Fear - George Addair

Received it by email, but also saw it in [this blog post](https://www.forbes.com/sites/amyblaschka/2018/09/04/everything-youve-ever-wanted-is-sitting-on-the-other-side-of-fear/).



Everything You Have Ever Wanted Is On The Other Side Of Fear


Are you aware of [DORA metrics](https://cloud.google.com/blog/products/devops-sre/using-the-four-keys-to-measure-your-devops-performance)?

How is your team classified?

![Calculating the metrics](https://storage.googleapis.com/gweb-cloudblog-publish/images/Calculating_the_metrics_frOhcbp.max-2000x2000.jpg)

DORA metrics


This is intended to explain to recruiters, friends and companies that I don't want to work as CLT - and how bad I think this model is.

Starting as the simple one, and for both samples I am using a salary of 10k BRL/month to be easy to calculate.

# *Pessoa Jurídica* (PJ) or contractor

The company pays 10k BRL. 

As a developer in Brazil providing services to US companies I don't need to pay ISS. So all the taxes I have is 7%.

```
7% of 10k BRL = 700 BRL
10k BRL - 7% = 9300 BRL
```

It means 9300 BRL comes to my pocket. 

I decide my retired plan.

I decide my health insurance.

I decide my benefits.

That is it. Simple like that.

Now the bad part:

# CLT - Labor Law

For all this I am using the values from [this tool](https://utilitarios.grupodpg.com.br/utilitarios/categoria/calculo-facil/775/custo-de-contratao-pj-x-clt-x-autnomo) - in portuguese.

The company pays the same 10k.

My salary officially would be 7.560 BRL.

8% would be FGTS = 604,80 BRL. *Fundo de garantia por tempo de serviço* (FGTS) or "Service time guarantee fund" it is a money that "does not earn interest", that I can access only to buy a house or during retirement.

9% is 13º salary = 680,40 BRL. No reason to receive a piece of my salary only in the end of year, also does not earn interest.

11,97% is vacations = 904,93 BRL. I need to pay each month to be able to take vacations, 30 days, max 3 intervals.

Company also pays 40% of all my FGTS in case I am fired by them (around 241,92 BRL). It is called *seguro desemprego* or unemployment insurance.

7% is INSS = 513,01 BRL. This is the retirement plan from the government. And it is not mine, in Brazil we pay for the ones retired. And our demographic window is not getting better.

14% is IRPF = 1.068,56 BRL. *Imposto de Renda Pessoa Física* or Personal Income Tax is tax. Simple like that.

So, in the end of month what I receive is 5.978,43 BRL. 60% of what company pays. Ok, you can argue that INSS/FGTS/13 Salary/vacations is something that I received, but there are several extra steps and it is delegated to the government to manage.

# Ok, what else?

Q: "oh, but I have other benefits in CLT like gym / health insurance". 
A: there is no magic. If company is paying extra, this money could come direct to my pocket.

Q: "how about exchange rate fluctuation?"
A: do you really think Brazilian real will behave better than any other currency? Just search on google things like `1 BRL in USD` / `1 BRL in EUR` / etc and check the graphic. 

Q: "but if something bad happen? e.g. accident, fired"
A: I prefer to contract the insurances myself. I do have my emergency reserve, and unlike the one from the government mine does earn interest.

# Which tool did I use? 

Basically [this one](https://utilitarios.grupodpg.com.br/utilitarios/categoria/calculo-facil/775/custo-de-contratao-pj-x-clt-x-autnomo). 

https://numbr.dev is also great to play with it real time and share.

# Conclusion

I don't like CLT. I don't want CLT. I don't see value to pass ownership of things to government. No reason to pay 27% of taxes if I can pay 7%.

To be clear, one FAANG / MANGA (Meta / Apple / Netflix / Google / Amazon) offered me to be CLT. MANGA is a dream for almost every developer, but I said no just because I don't see a point in CLT.

And if you (LATAM developer) that have the option to choose I really hope you decide by PJ/contractor.

CLT x PJ


Ok, Make/Makefiles are great. I spoke about then in the [last post](/blog/posts/2024-04-08-makefile).

But what if:

- I want to break them in different files
- Use a better syntax (maybe yaml?)
- Cache the tasks, even the ones that don't generate artifacts (e.g. lint)
- put tasks and aliases close
- validate the task execution
- have global tasks to run in any folder (e.g. backup)
- dry run
- watch task

#### Taskfile to rescue

Just need to [install Task](https://taskfile.dev/installation/) (or go-task on [github](https://github.com/go-task/task)).

The [documentation](https://taskfile.dev/) is pretty simple IMHO, but I want to highlight some things that I do use in daily bases that I think it does a great difference.

## Show me the code

For this I will use the sample from [previous post](/blog/posts/2024-04-08-makefile) ([makefile here](https://github.com/adamatti/node-sample/blob/main/Makefile))

```yaml
# yaml-language-server: $schema=https://json.schemastore.org/taskfile.json
---
version: '3'

env:
  DATABASE_URL: postgres://postgres:sample@localhost:5432/sample

includes:
  docker-compose:
    aliases: [dc]
    taskfile: ./Taskfile-docker-compose.yaml
  prisma:
    aliases: [p]
    taskfile: ./Taskfile-prisma.yaml

tasks:
  default:
    desc: Show help
    aliases: [h]
    silent: true
    cmds:
      - task -l --sort alphanumeric

  clean:
    desc: Remove node modules
    aliases: [c]
    cmds:
      - rm -rf node-modules

  install:
    desc: Install dependencies
    aliases: [i]
    run: once
    cmds:
      - npm install
    preconditions:
      - test -f package.json
      - test -f package-lock.json
    sources:
      - package.json
      - package-lock.json
    status:
      - test -d node_modules

  run-only:
    aliases: [ro]
    interactive: true
    ignore_error: true
    dotenv: ['.env']
    cmds:
      - task: install
      - task: prisma:generate
      - npx --yes esno src/index.ts

  run:
    desc: Run the project
    aliases: [r]
    cmds:
      - task: docker-compose:up
      - task: prisma:push
      - task: run-only
```

There are a lot of things going on here, so trying to explain some things:

1. The first line is just for auto complete on IDEs (like vscode, zed)
2. We can define global env vars in the script itself (e.g. `DATABASE_URL`)
3. We can [import](https://taskfile.dev/usage/#including-other-taskfiles) part of the scripts. You just need to have your global ones (e.g. terraform, docker-compose, prisma, git, etc). It does work with remote files.
4. You can expose/hide tasks with [internal flag](https://taskfile.dev/usage/#internal-tasks)

## Now the best part - cache

Pay a close look on the install task.

1. it only runs if `package.json` and `package-lock.json` are present ([programatic checks](https://taskfile.dev/usage/#using-programmatic-checks-to-cancel-the-execution-of-a-task-and-its-dependencies))
2. [Prevent unnecessary work](https://taskfile.dev/usage/#prevent-unnecessary-work): it caches the execution using the `source` attribute.
3. at the end it checks if the `node_modules` folder was created.
4. Even caching based on the `source`, if you remove the `node_modules` folder (check) it will run again.

So, you just need to run your daily tasks (e.g. tests, lints, run local) and the script itself will detect what is pending and run it if needed.

No more crazy issues that you forgot to update a dependency or database change.

## Ok, show me a normal day of work

At the first time, you just need to run `task r` to run the app. It will install dependencies, start database, apply db changes and run the app.

But what happen if someone changes a dependency? No problem. Taskfile will detect and will run `npm install` again.

But if someone just changes the db schema? No problem. It will generate the classes again.

If nothing changes, it will just run the app (ok, the docker part is not optimized, but you got the idea).

If need to stop the app and run again you can go direct to `task ro` (ro = run only).

## Full Project

As always, the full sample is available on [github](https://github.com/adamatti/node-sample).

## Closing thoughts

Now go to the [documentation](https://taskfile.dev/usage/).

Remove commands from `README.md` files and confluence/sharepoint. Also remove it from anemic `package.json` 😛

My global taskfiles are shared [here](https://github.com/adamatti/dotfiles/tree/main/taskfile) for reference.

My backup scripts using rsync are also on taskfiles, but this is a subject for another post.



Taskfile - an alternative for Makefiles


Imagine the follow scenario: you do have a node api with typescript, that uses a database (postgres in this sample) and an orm ([prisma](https://www.prisma.io/)). Every time someone in the team adds a new dependency, you need to run `npm install`. 

Database changes? You need to generate the classes again with `npm run prisma generate`. Oh, you also need to apply the changes with `npm run prisma db push` (note: a real world project would use migrations files, so `npm run prisma migrate dev`).

Then you moved to another service. Then moved back... oh, now need to start database again with `docker-compose up -d`. And so one... 

The steps are documented in a readme file. Or you can get it from `package.json` -> `scripts`, but there is no comments there or command order/dependence. 

What do you do? 

#### Makefile to rescue

So, Make is a build automation tool (thanks [wikipedia](https://en.wikipedia.org/wiki/Make_(software)), and it is available by default in all unix systems.

With that you can:
- create goals (tasks)
- create multi line commands
- use vars
- use conditions
- create aliases for the commands
- map task dependencies
- avoid re-running a task if artifact is already created (e.g. build). "Kind" of a cache (strong quotes here)

#### So, show me a sample!

Sure... check this one (full project [here](https://github.com/adamatti/node-sample)):

```makefile
default:
	@echo "Please specify a target to run"

clean:
	rm -rf node_modules

node_modules:
	npm install

docker-compose-up:
	docker-compose up -d

prisma-db-push:
	npx --yes wait-on tcp:5432 && \
	DATABASE_URL=postgres://postgres:sample@localhost:5432/sample npm run prisma db push

prisma-generate:
	npm run prisma generate

run-only:
	DATABASE_URL=postgres://postgres:sample@localhost:5432/sample \
	npx --yes esno src/index.ts

run: docker-compose-up prisma-generate prisma-db-push run-only

format:
	npm run prisma format
	npx --yes biome format --write ./src

# Aliases
install: node_modules
dcu: docker-compose-up
pdp: prisma-db-push
pg: prisma-generate
r: run
ro: run-only
first: clean install run
fresh: first
f: fresh
```

As you can see, a simple task is just 

```makefile
taskname: dependency1 dependency2
    my list of commands
    second command here
    etc
```

with the sample provided, I can install dependencies with `make node_modules`. 

If you run it again, it will do nothing as the `node_modules` folder is already present (task name = folder name).

If I want to run my app the first time, I just need `make fresh`, and it will:
- install dependencies
- start database
- generate orm classes
- update database
- run the app

If I want to run the app again, I don't need the full steps. I can go direct to `make run-only`.

#### Ok, I am lazy than that

With dependencies, you can create aliases. e.g.

```makefile
r: run
ro: run-only
```

Now I just need `make r` to run my app. Or `make ro` to run-only.
Note: I am lazier than that, I also [have an alias](https://github.com/adamatti/dotfiles/blob/bb23c786a3181b977874efe83530b65ec5de804a/zsh/aliases.zsh#L3) to run `make` with `m` only 😛

#### How about the default task?

It uses the first task. Or the one defined on `.DEFAULT_GOAL := help` (add it as one of the first lines).

#### Ok, but how about documentation

There is a [trick](https://marmelab.com/blog/2016/02/29/auto-documented-makefile.html) for that - just add those lines in the beginning of the file:

```makefile
.PHONY: help

help:
	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
```

...plus, `## comment` in the tasks you want comments. E.g.

```makefile
clean: ## remove dependencies
	rm -rf node_modules

prisma-generate: ## generate prisma classes
	npm run prisma generate
```

Now you just need to run `make` or `make help` to see all tasks and comments, sorted by task name, e.g.

```shell
> make help
clean                          remove dependencies
docker-compose-up              start dependencies
first                          first execution
format                         format code
fresh                          fresh execution
install                        install dependencies
prisma-db-push                 push prisma schema to database
prisma-generate                generate prisma classes
run-only                       run the project
run                            run the project + dependencies
```

#### Advanced

- How to hide the command from output? Just add `@` in the front of the command.
- call an existing task in the middle/end of my commands? `$(MAKE) your task`
- cache task? the task should match with the output folder or file name

#### Show me the full project

It is [here](https://github.com/adamatti/node-sample), and the makefile is [here](https://github.com/adamatti/node-sample/blob/main/Makefile)

#### Why post about makefile?

Because this is the [most watched video on my channel](https://www.youtube.com/watch?v=h4aV3C6BRDQ). And a lot of developers still adding commands on readme files on partially on package.json. We developers should automate things, even our daily tasks.

Makefiles - How to use them for automations


Just saw this new lib today - [Vinejs](https://vinejs.dev/). It called my attention as it is very similar to [zod](https://zod.dev/), but seems to be faster. Definitely I will consider it for my next pet projects.

#### Basic Example

```typescript
import vine from '@vinejs/vine'

const schema = vine.object({
  email: vine.string().email(),
  password: vine
    .string()
    .minLength(8)
    .maxLength(32)
    .confirmed()
})

const data = getDataToValidate()
await vine.validate({ schema, data })
```

#### Benchmarks

<div style="align:center">
  ![Benchmarks](/assets/posts/2024-04-05-vinejs/benchmark.jpg)
</div>

Vinejs - js validation lib


<div style="align:center">
  ![Caricatura](/assets/posts/2023-12-30-tdc/caricatura.png)
</div>

One more year I participated on [The Dev Conf](https://thedevconf.com/tdc/2023/future/trilha-api) as a track coordinator, API this time. One more row to [my profile there](https://thedevconf.com/palestrante/MarceloAdamatti).

We had talks about:

- Legacy of Microservices
- REST controllers
- Governance
- Contract tests
- Open Telemetry
- API Gateway
- GraphQL

We had great feedback score from the audience (lowest avg vote was 4.3 of 5).

The photos are available [here](https://thedevconf.com/tdc/2022/future/fotos).

#### To the speaker and track coordinators

Thanks a lot for all the efforts, dedication, time expended... We had a great event, it wouldn't be possible without that.

#### To event coordinators

Thanks for pick me, it is a recognition of my work.

#### To the audience

I hope everyone enjoined as the feedback scored said. TDC is a community event, we did the talk selection based on what we thought would be the best for the audience. It is not easy to pick 7 from a good amount of submissions.

#### To myself in future

It is a lot of work/coordination prior the event: people will cancel, have problems with the time of the slot, etc. But during and in the pass, the event is a great experience.

TDC - API Track


This post is more a reminder to myself, as I keep searching about happiness formulas and reasons for unhappiness / poison behaviours. 

I just watched the video bellow (`O que acontece quando pessoas desenvolvedoras de software ficam (in) felizes?`), based on [this article](https://www.sciencedirect.com/science/article/pii/S0164121218300323?via%3Dihub).

<iframe width="560" height="315" src="https://www.youtube.com/embed/1LSqxCZ-83U" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen style="text-align: center"></iframe>

Take a look on the consequences of unhappiness and happiness.

![Consequences of unhappiness](/assets/posts/2023-07-04-happiness/unhappy.jpg)

![Consequences of happiness](/assets/posts/2023-07-04-happiness/happy.jpg)

Development goes beyond code, product and methodologies. 

Different methodologies (e.g. scrum/kanban) will not address unhappiness issues.

What happens when developers are (un)happy


Today I received the [Refactoring newsletter](https://refactoring.fm/p/on-design-sweet-spot-threat-modeling) (which strongly recommend to sign in), and one of the sections caused me some reflections, the "Pyramid of Needs".

While I had previously heard of [Maslow's hierarchy of needs](https://en.wikipedia.org/wiki/Maslow%27s_hierarchy_of_needs), this pyramid is specifically relevant to one's career.

This is the image from the post:

![Pyramid of Needs](/assets/posts/pyramid-of-needs.webp)

... and I strongly recommend you (reader) to go to the [original post]((https://refactoring.fm/p/on-design-sweet-spot-threat-modeling) ) to check all the details.

- The majority of the professional that I knew were more interested (or stuck) in the *individual* layer. 
- The best ones (that I know, IMHO) passed the *Teamwork* layer.
- I was 200% in the item *I have opportunities to learn and grow*. But it doesn't work if the *teamwork* layer (and the ones bellow) aren't fulfilled.

The Pyramid of Needs


Three years ago I did some tests using [quarkus](https://quarkus.io/), to use on some microservices / pet projects. The commands to make it run using native binary are on this [gist](https://gist.github.com/adamatti/4633a7559647aaf779d60e3aad543b6b).

Today I tried it again, just registering here my steps:

### 1. Install quarkus

I am using [sdkman](https://sdkman.io/) for it - it is a java version manager, similar to [fnm](https://github.com/Schniz/fnm) (for node).

It is easy as `sdk install quarkus`.

### 2. Create a project

Just need to run:

```shell
quarkus create app adamatti.github.io:learn-quarkus --extension='resteasy-reactive' --gradle
```

Where `learn-quarkus` is the project name and `adamatti.github.io` is the main package name.

Yes, I decided to use [gradle](https://gradle.org/) instead of [maven](https://maven.apache.org/). Not willing to use XML in 2023 :-p

Then I added this extension to build inside a docker container: 

```shell
gradle addExtension --extensions=quarkus-container-image-docker
```

### 3. Run

`./gradlew quarkusDev`. I can't deny, it is amazing be able to change source files without the need to stop/start the application multiple times

### 4. Build native

```shell
./gradlew build -Dquarkus.package.type=native -Dquarkus.native.container-build=true
```

With this, you don't need to have [graalvm](https://www.graalvm.org/) on local machine.

The binary file was created on `build` folder as `learn-quarkus-1.0.0-SNAPSHOT-runner`. It took ~4mins on my machine (Apple M1), 40mb is the size.

### 5. Run the binary in a docker container

... just to make sure it doesn't need any of the dependencies in my local machine (e.g. java) and simulate a real deploy.

```shell
docker run --rm -it \
    -p "8080:8080" \
    -v ${PWD}/build/learn-quarkus-1.0.0-SNAPSHOT-runner:/app \
    centos \
    /app -Dquarkus.http.host=0.0.0.0
```

### Extra - version configuration

Just created a `.sdkmanrc` file to make sure I would use the same versions in the future: 

```shell
# Enable auto-env through the sdkman_auto_env config
# Add key=value pairs of SDKs to use below
java=11.0.11.9.1-amzn
gradle=7.5.1
quarkus=3.0.0.Alpha6
```

### Conclusion

1. Quarkus is really fast, I would love to work with it in production
2. Really loved the way the resources/controllers are created, e.g. 

```java
package adamatti.github.io;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/hello")
public class GreetingResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello from RESTEasy Reactive";
    }
}
```

3. Loved the tests created with Gherkin syntax: 

```java
package adamatti.github.io;

import io.quarkus.test.junit.QuarkusTest;
import org.junit.jupiter.api.Test;

import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.is;

@QuarkusTest
public class GreetingResourceTest {

    @Test
    public void testHelloEndpoint() {
        given()
          .when().get("/hello")
          .then()
             .statusCode(200)
             .body(is("Hello from RESTEasy Reactive"));
    }

}
```

4. It also create tests for the native version (powered by the additional annotation):

```java
package adamatti.github.io;

import io.quarkus.test.junit.QuarkusIntegrationTest;

@QuarkusIntegrationTest
public class GreetingResourceIT extends GreetingResourceTest {
    // Execute the same tests but in packaged mode.
}
```

5. [Micronault](https://micronaut.io/) is still my preferred [spring](https://spring.io/) replacement, but this is a subject for another topic.

I still curious about Quarkus usage, let's keep watching and see how does it goes.

Quarkus - a new try on native images


Just received it on [this newsletter](https://atalho.substack.com/p/597-o-prompt-dos-prompts-como-desbloquear), it is helping me a lot for better prompts:

```
I want you to become my prompt engineer. Your goal is to help me craft the best possible prompt for my needs. The prompt will be used by you, ChatGPT. You will follow the following process:

1. Your first response will be to ask me what the prompt should be about. I will provide my answer, but we will need to improve it through continual iterations by going through the next steps.

2. Based on my input, you will generate 2 sections. a) Revised prompt (provide your rewritten prompt. it should be clear, concise, and easily understood by you), b) Questions (ask any relevant questions pertaining to what additional information is needed from me to improve the prompt).

3. We will continue this iterative process with me providing additional information to you and you updating the prompt in the Revised prompt section until I say we are done.
```

Hope it does help you too. 

Go to chat gpt [here](https://chat.openai.com/chat)

How to unlock ChatGPT full potential

First blog post! 

This is more a test to make it work. Thanks [@pixegami](https://www.youtube.com/watch?v=Hiabp1GY8fA) and [@Traversy Media
](https://www.youtube.com/watch?v=MrjeefD8sac) for the great tutorials

My main goal here is to start producing content in English about programing languages, libraries, software development metodologies, leadership, culture, product, business... let's see how it goes, wish me lucky.