Por que usar Docker?

Vinícius Aarão Caldas da Costa — Thu, 02 Jan 2025 23:40:41 +0000

Porque você deve aprender Docker o quanto antes

O melhor amigo de DevOps é a padronização, isto é fato, e utilizar container é uma das melhores maneiras de fazer isso aliado a agilidade que é fundamental no desenvolvimento.

E de antemão já quero mostrar as vantagens de usar Docker, sem enrolações:

a. Resolve conflitos de dependência
Sem contêineres, as dependências e arquivos ficam todos juntos em um servidor, se quisermos atualizar 1 dependências, terá que atualizar em todo o restante.

b. Permite fácil expansão
Quando um aplicativo de servidor precisa lidar com o uso maior do que um único servidor, a solução é colocar um proxy reverso e duplicar quantas vezes forem necessárias. Como os contêineres são baseados em imagens, podemos executar quantos contêineres desejar a partir de uma única imagem. Ou melhor ainda, usar um orquestrador, aonde eu só preciso declarar quantos contêineres desejo a partir de uma única imagem.

c. Permite atualizações contínuas
Com o Docker, podemos facilmente dizer ao orquestrador que atualiza as dependências do container em questão.

d. Outras vantagens listadas

cadeia de construção comum
armazenamento de imagem comum
maneira comum de implementar e expandir
hospedagem comum de contêineres
controle e monitoramento comum

Conceitos básicos entender :

a. Container: é o que queremos executar e hospedar no Docker, como se fosse uma máquina isolada. Do ponto de vista conceitual, container roda dentro do host Docker com tudo o que precisa para funcionar como SO, pacotes, tempos de execução, arquivos, variáveis de ambiente, entrada padrão e saída.

b. Imagem: qualquer container é criado a partir de uma imagem, descreve tudo o que é necessário para o container ser criado.

c. Registro: Onde são armazenadas as imagens.

Espero ter ajudado :)
Vinícius Aarão

Algorithm to determine if brackets are balanced

Vinícius Aarão Caldas da Costa — Tue, 24 Sep 2024 19:31:00 +0000

I start to post a serie of algorithms for help us, I learn the code, english and reinforce about this. And I expected to help you and contribute for the community.

This algorithm is to easy to understand because your problem is to easy, but it's a excellent example to see how we can get the solution with simples steps.

The first step is see the problem:

"we’re going to determine whether or not a set of brackets are balanced or not by making use of the stack data structure that we defined in the previous lesson.

Let’s first understand what a balanced set of brackets looks like.

A balanced set of brackets is one where the number and type of opening and closing brackets match and that is also properly nested within the string of brackets." (educative.io)

Examples of Balanced Brackets
{ }
{ } { }
( ( { [ ] } ) )
Examples of Unbalanced Brackets
( ( )
{ { { ) } ]
[ ] [ ] ] ]

What is your first thought to solve this?

My second step to solve problems like this is to put pen to paper (I like to use simple diagrams) every variable that we might use and all data we have (It's similar to solve physics problems).

Show this new example "}]"

Array = ["}", "]"]

We need to compare the caracters and when we see over the examples, It's clarely that we can use the array to compare?

def is_match(p1, p2):
    if p1 == "(" and p2 == ")":
        return True
    elif p1 == "{" and p2 == "}":
        return True
    elif p1 == "[" and p2 == "]":
        return True
    else:
        return False


def is_paren_balanced(paren_string):
    s = Stack()
    is_balanced = True
    index = 0

    while index < len(paren_string) and is_balanced:
        paren = paren_string[index]
        if paren in "([{":
            s.push(paren)
        else:
            if s.is_empty():
                is_balanced = False
                break
            else:
                top = s.pop()
                if not is_match(top, paren):
                    is_balanced = False
                    break
        index += 1

    if s.is_empty() and is_balanced:
        return True
    else:
        return False

Our step to declare that is balanced or not is verify the number of the Array (never works in % 2 != 0), and discover if exist a opening brackets for input in our array and find using is_match the closing brackets.
When over the looping, is declared balanced or not.

That's it!

OBS: We need to use the Stack Data Structure. I believe that you know about this methods.

class Stack():
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)             

    def pop(self):
        return self.items.pop()

    def is_empty(self):
        return self.items == []

    def peek(self):
        if not self.is_empty():
            return self.items[-1]

    def get_stack(self):
        return self.items

@vinycxuz

DEV Community: Vinícius Aarão Caldas da Costa

Por que usar Docker?

Porque você deve aprender Docker o quanto antes

Conceitos básicos entender :

Algorithm to determine if brackets are balanced