DEV Community: Leonardo Oliveira

_01_ Descomplicando Docker - O que é Docker

Leonardo Oliveira — Wed, 03 Sep 2025 23:44:53 +0000

Salveee, Devs! Como cês tão, tudo certo?

Bem-vindos a bordo! Quem fala aqui é o *Lim4 Mik3.

Hoje a gente dá início a uma mini-série sobre Docker: vamos entender essa ferramenta, revisar alguns fundamentos, colocar a mão na massa e, no final, fazer o deploy de uma aplicação usando Docker e AWS!

O objetivo para essa mini-série é além de compartilhar o conhecimento, ser um material de ensino e apoio aos devs iniciantes, os que já tem experiencia ou até mesmo aquele que já são experts e querem revisar alguns conceitos.

Depois de ver toda a série tenho certeza que não terão medo ou calafrios ao ouvirem a palavra "Docker" kkk... vamos construir juntos uma base sólida e prática de conhecimento em Docker!

Então primeiro de tudo, vamos entender oq é esse bendito Docker e a baleia.

O que é o DOCKER - Fundamentos

Certamente não tem ninguém melhor para definir o que é o Docker se não os próprios criadores dele, vejamos abaixo a definição do Docker em sua própria documentação:

Pronto, entendemos o que é o Docker, podemos passar para os próximos passos.

... Não? Claro que não! Se voce assim como eu, não se contenta com meras explicações rasas, fique calma pois vamos mais fundo.

Verdadeiramente entendo o Docker

O Docker é uma ferramenta para seu software, e como qualquer outra ferramenta, ela veio para resolver um problema, com isso, vamos primeiro entender o problema para então entender a aplicabilidade e o cenário onde o Docker brila.

Em tempos não tão distantes era comum vermos os profissionais de tecnologia enfrentarem alguns problemas ou fazerem queixas como os listados abaixo:

Na minha máquina funciona
Dificuldade em replicar ambientes
Conflito de dependências
Complexidade no deploy
Escalabilidade difícil
Custo com infraestrutura pesada (VMs)
Integração complicada entre sistemas
Portabilidade limitada
Dificuldade em testes automatizados
Entrega contínua demorada

Acho que deu pra entender que haviam algumas lacunas e dores reais nos processos de desenvolvimento, integração e deploy de softwares.

Para resolver todos esses problemas é para que o Docker veio ao mundo, ele consegue de uma maneira inteligente e performática isolar um único computador/hardware e criar ambiente exclusivos com suas configurações e com suas

Meet, Multi SSH Profile/Host 🔑

Leonardo Oliveira — Mon, 24 Feb 2025 15:42:01 +0000

Handle multiple SSH client and connections more easily.

Have you ever needed to work on multiple projects at the same time? Or do you often access a remote device and not remember its address by heart?

Today, I’ll show you guys a wonderful feature that can help us solve this, and as a bonus, we’ll become more productive and happier at work.

A good practice in the workday of IT professionals is using SSH as a communication protocol between systems. But sometimes, we need to handle two, three, or more clients in our work routine.

I mostly see people handling this "obstacle" simply by writing the access information manually into the terminal. This works, but it is not the ideal solution.

Now, I'm going to show you a nice solution for this.

I'll create a problem case. Let's suppose that you have a software house that works on two different projects. These projects are stored in two different GitHub repositories, and you can only access them via SSH.

You could simply enter the access command and information in the terminal, and it would work. Okay, that’s fine, but... you can also create a config file for the SSH agent and use the Multi-Hosts (aka multi-profiles) feature to achieve the same results.

Woooooooowwww, how does that work??

You must create a config file in the SSH agent directory, declare some hosts, give them a specific name, and every time you need to access any of them, you just need to type their names.

That's all. Seems like magic!

Let's stop shooting the breeze and get to work.

If you don't know some principles of SSH connections and clients, I suggest you learn them first and then come back here.

So, we’re going to start from the point where you already have the public and private access keys linked to your repository.

If you also don't know how to get this, check out this link.

STEP 1
Open your terminal and navigate to the SSH directory (in Linux, ~/.ssh). Then, create a file called config without an extension.
As shown in the example below, I access my SSH directory and create:

STEP 2

After this point, let's understand the structure of the config file:

Every profile/host that you need to declare in the SSH-AGENT follows the pattern below:

STEP 3

As final result, now you can put all of your profiles/hosts clients that you want to have a quickly access.

And now, you can access any profile/host by using ssh <profile>, and that's its.

Example accesing the project 01 with the user wm-lim4mik3:

Example accesing the project 02 with the user Lim4Mik3:

And that's it for today, guyss!

Let me know your thoughts about this article in the comments section below.

Javascript fundamentals - The beginning

Leonardo Oliveira — Thu, 25 Jul 2024 05:06:55 +0000

Some new developers or even those experience, can face it issues or difficulties case don't have a solid knowledge of the fundamentals.

To solve this, in this series, i wanna recap the javascript fundamentals to keep it fresh and to help any dev that come here to remember any specific topic.

First of all, What we gonna talk about?

All javascript fundamentals, from scratch to hero!

The fundamentals

What is Javascript?

Javascript is a programming language rich and complex, it be able to apply in very scenarios and a wide applications range.

Here we can see some exclusive characteristics:

Is a interpreted and JIT compiled programming language;
Has dynamic types;
Based on Prototypes;
Create with First-class functions;
Has clousores;
Event loop and non-blocking I/O;
Error handling with try/catch;
Flexible objects and arrays;
Template strings;
Modularity and support for module imports;
Support to asyncronhuos programming;

And much more...

For our porpose, these characteristics that's enough. We gonna explore each one of those points, we going get a solid knowledge of them.

Intepreted and JIT compiled

Javascript was traditionallity an interpreted language, meaning code is executed line by line. Nowdays, with advanced Javascript engines most code is compiled on the fly using Just in Time techniques to improve performance.

Dynamic types

JavaScript is a dynamically typed language, allowing the same variable to store different types of data at different times. This offers flexibility, but can also lead to errors that are more difficult to track down.

Prototypes

Instead of using traditional classes found in languages like C++ or Java, JavaScript uses prototypes for inheritance. This allows inheritance of properties and methods from one object to another.

First-class functions

JavaScript treats functions as first-class objects, allowing them to be assigned to variables, passed as arguments to other functions, returned from functions, and have their own properties and methods.

Closure

JavaScript supports closures, a powerful feature that allows functions to remember and access variables in the scope where they were created, even after the outer scope has ended.

003 - TSExpert | Transform Tuple's into Object

Leonardo Oliveira — Thu, 25 Jul 2024 05:04:01 +0000

Greetings, Devs!
Here's Leonardo once again, embarking on our journey to master TypeScript.

Today, we won't be copying any built-in utilities; instead, we'll create a new and exclusive utility.

We are going to craft a type that transforms tuple types into object types.

First and foremost, let's take a quick overview of what a tuple is.

A tuple is a data structure that allows you to store more than one data type in an array. It looks something like this:

As we've seen, we can map various data types into a single array, which proves to be very helpful in numerous real-world scenarios.

However, another common and useful case is transforming this tuple declaration into another object declaration with the same properties and values. But here's where we run into a problem – the DRY principle, "DON'T REPEAT YOURSELF"; we end up with repeated code.

Fear not, TypeScript is our ally and always comes to our aid.

We can reuse this declaration by converting it into another, thus avoiding redundant type declarations.

Now it's our time to shine as we delve into how to accomplish this with excellence:

Creating Our Utility

Let's name it the TransformToObject type.

Before we get our hands dirty with code, let's explore the theory under the hood.

We need to create the type and receive a generic with the typeof the tuple. Afterward, we can iterate over this tuple. But hold on, it is an array... Bah, we got stuck!! 🤯

No worries, it's simple. We need to iterate over the tuple and, in turn, iterate over the array. How? Let's see:

DISCLAIMER: The most common way to use tuples is by declaring them as readonly, so we'll need to handle this.

Let's create this together, step by step.

First, let's create the type declaration:

Great, now we're able to receive the tuple as a generic prop.

We are going to iterate over each tuple prop and redeclare it as a key/value pair of that object. It's something like this:

But, alas, we encountered an error:

The compiler's type system has already given us a solution. This error occurred because we're trying to iterate over an unknown Type T, which can lead to an error.

To solve this, let's be specific about what the type of the T generic is, like this:

I changed the code, but I still receive an error! What the heck is going on?!!!

Hold on, dude...

TypeScript is correct; this error is caused by typing the generic as an array of strings or numbers, but we're trying to iterate over the methods of that array, not over their values.

Now that we are also going to iterate over the array, it's very simple:

By putting the number inside brackets next to T, we're iterating over that array's properties.

And with that, we're done!! Puff... this task drained all my energy lol hahaha

Let's give it a try:

Pass a tuple to this utility, and we get the following result:

Hover the mouse over the new type, and we get this:

Exactly what we wanted!

With this very simple example, we can expand our TypeScript knowledge.

🤩 That's it for today, folks! 🤩

Follow me for more content about TypeScript, JavaScript, React, and stuff related to these stacks.

002 - TSExpert | Readonly Typescript

Leonardo Oliveira — Sat, 02 Dec 2023 19:43:33 +0000

Wasup, guys...

I hope you guys are doing well

Today, one more time we're crafiting other typescript utility for studies purposes. The guy of the moment is the Readonly utility.

That built-in utility get a type N and transform all of their properties in readonly properties, creating a safe type without overrides.

Out of the box, typescript already have this utility for production uses. But we'll creating a clone of it today.

Let's see how it works in your default implementation:

Alright, let's assume that on this case for some reason, assigning this prop was not allowed, because the admin role is a security level, and cannot be changed manually.

In this case, typescript not helping us, now is the time of Readonly utility shine bright.

We can use it, for set all of these properties as readonly property, that is, we're safing lock all properties to never alter.

It looks something like this:

In our Props type declaration, we wrapped it in Readonly default built-in utility and from now on, all props are locked, their are readonly properties.

Instantly we got an error:

And typescript now, dont allow us to override an readonly prop, this is very useful in this and others cases.

🔨 As usual, now we'll create our own implementation of this utility 🔧

Why?...

"What a cannot create, i don't understand" - Feynman R.

Our own implementation

This utility is very easy to create, the only thing we need to do is create a new object with a readonly prefix in each property.

Let's call it, MyReadonly, our utility will receive a generic , and override each prop type with readonly, in this way:

Now, works as the built-in utility.

🤩 That's it for today, folks! 🤩

Follow me for more content about Typescript, Javascript, React and stuffs of these stack content.

001 - TSExpert | Pick Typescript 🔥

Leonardo Oliveira — Thu, 23 Nov 2023 06:01:00 +0000

Hello folks! 👋🏼

Once again, we're here, and today we're diving into the world of a TypeScript built-in utility—specifically, the Pick utility.

It comes pre-installed with TypeScript and is a handy tool for our daily tasks. But... what exactly is it designed for, and how does it help us?

This utility type has a semantic name because it literally picks certain types for us, provided by a primary type. I'll demonstrate it for you.

Let's suppose we have a blog application, and we create a type definition called User, as follows:

It works very well, but... now we need to implement a header with a small section that must have the name of the user and their email.

We've created the component, and let's declare the component's props. The most common approach is to create a new type for this component, but now the Pick utility shines bright!

Instead of creating a new type, we can just 'pick' some information from that User type. Let's see how:

That's it. Our new type called HeaderProps inherits the name and email props from the User type.

Don't believe me? Okay, I'll prove to you that using Pick is the same thing as if we created this new type by declaring it from scratch.

If we hover the mouse over the HeaderProps declaration, TypeScript shows us the format of this type, and voila, it looks exactly how we wanted!

It's really easy to use, and it's helpful.

⚠️ BUT NOW, I NEED TO ASK YOU A QUESTION! ⚠️

Do we really understand how the Pick utility works and how it performs this 'magic'?

As our friend Richard Feynman says:

"What I cannot create, I do not understand."

For this question, the best answer is to apply all of these principles by working on a new type, our utility-type called Just it'll be the same thing that Pick built-in utility.

The act of creating a new type with the same behaviors as the built-in utility just puts our concepts and knowledge about this utility to the test.

In summary, we need to receive a first type and the respective props that we want to keep. Let's get started.

After spending much time working on it...

Here's our own implementation of the Pick utility.

You can see that I've given some semantic names to my props. Let's check out each of them.

First, I created a type called Just, which receives two generics. The first will be the Primary type, the type from which we will filter out the specified props. The second generic represents the keys of the props that we want to keep.

After this, I simply iterate over the expected keys we want to keep, and for each key, I include it in a new object.

Working as the original pick utility:

I hope that this it will very helpful for you.

Follow me for more contents about TS stack.