
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.