Portuguese version: https://marcosstefani.medium.com/gittool-o-git-de-maneira-simples-988244af3fdf

Hello! My name is Marcos Rosa, and I’ve been working in software development for more than 20 years. Throughout this journey, I’ve worked with Git on a daily basis, along with a variety of tools that help streamline versioning and workflow management. However, despite all this experience, I kept facing a recurring obstacle: managing multiple identities and SSH keys.

Anyone who works with multiple GitHub accounts or different repository platforms knows how inconvenient it can be to switch configurations, adjust keys, and remember specific details that — after some time without touching them — require that inevitable quick search just to make sure everything is being done correctly. On top of that, for security reasons, I’ve always had the habit of periodically renewing my SSH keys, even when using only one. Although this practice increases security, it also brings headaches, as the process has never been as intuitive as I would like.

After years dealing with these small but persistent frustrations, I realized I could turn this recurring pain into a solution. And that’s how GitToll was born — an open-source tool designed to make using Git — especially when it comes to SSH and multi-user configurations — much simpler, more intuitive, and more seamless.

In this article, you’ll get to know this tool, understand why it was created, and learn how it can make your daily Git workflow much easier. Let’s dive in!

Installing GitTool

The tool can be installed in a few different ways. The first is through Homebrew, which can be used on macOS or Linux:

brew tap ElaraDevSolutions/tools
brew install gt

You can also download it through the release files available in the Git tags: https://github.com/ElaraDevSolutions/gittool/tags

Features (so far)

Add a new SSH key

Adding a new key is simple. Just run:

gt ssh add

This command will create a new SSH key and ensure it is added to ssh-add and properly configured in ~/.ssh/config.

Add an existing SSH key (created outside of gt)

To add a key while ensuring it is correctly configured with GitTool, run:

# command: gt ssh add <name or part of the key name>
gt ssh add personal

You can provide only part of the key name. GitTool will search your keys in ~/.ssh, and if it finds more than one match, it will show a list so you can choose. If there’s only one match, it will select it automatically.

Delete a key

To remove an unnecessary key, simply run:

# command: gt ssh remove <name or part of the key name>
gt ssh remove personal-ssh

When adding a key, you specify a HostAlias. This alias is required to delete it.
To list all registered HostAliases, run:

gt ssh list

Rotate SSH keys

One of the problems I wanted to solve was key rotation. As I mentioned, I like to periodically rotate my keys for security reasons, so I created a dedicated command for that:

# command: gt ssh rotate <HostAlias>
gt ssh rotate personal-ssh

The command will rotate the key, and you can update it in your Git settings. It also creates a backup in case you need a rollback.

If you want to update the email during rotation, use:

# command: gt ssh rotate --email <new email> <HostAlias>
gt ssh rotate --email new.email@example.com personal-ssh

Select a key for the repository

If you already cloned a repository but the SSH key is outdated, go to the repository folder and run:

gt ssh select

This command lists all configured SSH keys so you can choose which one to apply. It then updates the Git configuration for the current repository.

Smart Clone

Finally, one of my favorite and most-used commands. If you work with more than one SSH key, use the clone command to clone your repository:

# command: gt clone <ssh link of your git>
gt clone git@github.com:your_user/your_repo.git

The tool will clone the repository on your machine and ask which SSH key you want to use. This is extremely convenient!

Final Considerations

GitToll was born from a real, everyday need: simplifying Git usage in scenarios where multiple accounts, SSH keys, and parallel configurations can become more complicated than they should be. It streamlines the process, reduces errors, and makes the workflow more intuitive — especially for those who manage multiple identities or periodically renew their keys.

However, it’s important to emphasize: GitToll is not a silver bullet. It doesn’t aim to replace everything that already exists in the Git ecosystem, nor to eliminate the need to understand how Git works under the hood. That was never the goal. What GitToll does is transform repetitive, error-prone tasks into something simple, accessible, and fast — and that alone already boosts daily productivity significantly.

As an open-source project, GitToll is constantly evolving. This means you are more than welcome to be part of this journey.
Found a bug? Have an improvement idea? Want to add a new feature?
Pull Requests, discussions, and issues are always welcome.

GitToll is a tool made by the community and for the community — and together we can make it even more useful and powerful.
Thank you for reading, and I hope GitToll makes your daily workflow as smooth as it made mine.

Repo: https://github.com/ElaraDevSolutions/gittool

GitTool — Git made simple was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

English Version: https://marcosstefani.medium.com/gittool-git-made-simple-223c6002aca3

Olá! Meu nome é Marcos Rosa e venho atuando há mais de 20 anos no desenvolvimento de software. Ao longo dessa jornada, trabalhei diariamente com Git e com uma série de ferramentas que facilitam o versionamento e o fluxo de trabalho. Porém, mesmo com tanta experiência, sempre enfrentei um obstáculo que insistia em reaparecer: a gestão de múltiplas identidades e chaves SSH.

Quem, como eu, trabalha com múltiplas contas do GitHub ou diferentes plataformas de repositórios sabe o quanto pode ser incômodo alternar configurações, ajustar chaves e lembrar detalhes específicos que, depois de algum tempo sem mexer, exigem aquela inevitável pesquisa rápida para evitar erros. Além disso, por uma questão de segurança, sempre tive o hábito de renovar periódicamente minhas chaves SSH — mesmo quando utilizava apenas uma. Essa prática aumentava a segurança, mas também aumentava a dor de cabeça, já que o processo nunca foi tão intuitivo quanto eu gostaria.

Depois de anos convivendo com essas pequenas frustrações, percebi que poderia transformar essa dor recorrente em uma solução. E foi assim que nasceu o GitToll, uma ferramenta open source pensada para tornar o uso do Git — especialmente no que diz respeito a SSH e configurações multiusuário — muito mais simples, intuitivo e fluido.

Neste artigo, você vai conhecer melhor essa ferramenta, entender por que ela foi criada e como ela pode facilitar (e muito) o seu dia a dia com Git. Vamos lá?

Instalando o GitTool

A ferramenta pode ser instalada de algumas formas, a primeira delas é pelo homebrew (ferramenta que pode ser utilizada em MacOS ou Linux).

brew tap ElaraDevSolutions/tools
brew install gt

Ou, por meio dos arquivos disponibilizados nas Tags do Git:
https://github.com/ElaraDevSolutions/gittool/tags

Funcionalidades (até o momento)

Adicionar nova chave ssh

Adicionar uma nova chave fica simples, basta executar o comando:

gt ssh add

Esse comando criará uma nova chave tendo a certeza que essa nova chave estará adicionada ao ssh-add e configurada em ~/.ssh/config

Adicionar uma chave ja existente (criada sem o gt)

Para adicionar uma nova chave de maneira a garantir que ela está configurada corretamente com o gt, basta executar:

# comando: gt ssh add <nome ou parte do nome da chave>
gt ssh add pessoal

Note que você pode iformar apenas parte do nome da chave. O gt vai buscar entre as suas chaves que estão em ~/.ssh e se achar mais de uma chave com aquele nome vai te mostrar uma lista de chaves para que você possa selecionar. Se tiver apenas uma, ja a seleciona sem necessidade de seleção.

Deleção de uma chave

Para excluir uma chave desnecessaria, basta executar o comando abaixo.

# gt ssh add <nome ou parte do nome da chave>
gt ssh remove pessoal-ssh

Toda vez que adicionamos uma chave, informamos o HostAlias, este HostAlias é necessário para deleção. Se você quiser listar os HostAlias cadastrados, execute:

gt ssh list

Rotacionar chaves

Um dos problemas solucionados foi a rotação de uma chave, como eu disse, gosto de rotaciona-la de tempos em tempos para manter a segurança, por isso eu criei esse comando. Para executa-lo:

# gt ssh rotate <HostAlias>
gt ssh rotate pessoal-ssh

O comando irá rotacionar a chave e vc pode atualiza-la no teu git. O comando cria um backup da chave caso queira fazer o rollback.

Se quiser atualizar o email rotacionando execute o parametro de email, veja:

# gt ssh rotate --email <novo email> <HostAlias>
gt ssh rotate --email novo.email@exemplo.com pessoal-ssh

Selecionar uma chave para o repositorio

Se você ja tiver um repositorio clonado mas a chave ssh estiver desatualizada, basta executar o comando abaixo dentro do repositorio que deseja atualizar:

gt ssh select

Esse comando lhe dará a lista de sshs configuradas para seleção. Ao selecionar a configuração do git estará correta no repositorio corrente.

Clone inteligente

E por fim, o comando que mais gosto e uso, se você trabalhar com mais de uma ssh execute o comando clone para clonar seu repositorio, veja um exemplo:

# gt clone <ssh link do seu git>
gt clone git@github.com:seu_user/seu_repo.git

O comando vai clonar seu repositorio na sua máquina mas vai lhe perguntar qual chave ssh deseja usar. Isso facilita muito!!

Considerações Finais

O GitToll nasceu de uma necessidade real e cotidiana: simplificar o uso do Git em um cenário onde múltiplas contas, chaves SSH e configurações paralelas acabam se tornando mais complexas do que deveriam. Ele facilita o processo, reduz erros e torna o fluxo de trabalho mais intuitivo — especialmente para quem gerencia várias identidades ou renova suas chaves periodicamente.

Mas é importante reforçar: o GitToll não é uma bala de prata. Ele não pretende substituir tudo o que já existe no ecossistema Git, nem eliminar por completo a necessidade de entender como o Git funciona por baixo dos panos. O objetivo nunca foi esse. O que ele faz é tornar tarefas recorrentes e cansativas em algo mais simples, acessível e rápido — e isso, por si só, já melhora muito a produtividade diária.

Como projeto open source, o GitToll está em constante evolução. E isso significa que você é mais do que bem-vindo para participar dessa jornada. Encontrou um bug? Tem uma ideia de melhoria? Quer adicionar uma nova funcionalidade?
Pull Requests, discussions e issues são sempre bem-vindos.

O GitToll é uma ferramenta feita pela comunidade e para a comunidade — e juntos podemos transformá-la em algo ainda mais útil e poderosa. Obrigado por chegar até aqui, e espero que o GitToll facilite o seu dia a dia tanto quanto facilitou o meu.

Repo: https://github.com/ElaraDevSolutions/gittool

Over the past 20 years working with Python, I’ve noticed something very characteristic in the community: the tendency to solve problems quickly, often with straightforward scripts, without much concern for architectural patterns. This pragmatism is, without a doubt, one of Python’s greatest strengths — but it can also become a weakness in larger projects, where the lack of structure eventually takes its toll.

At the same time, working with Java, I’ve always seen how the consistent use of design patterns makes systems clearer, more extensible, and easier to maintain. In Python, I feel those benefits are often overlooked — not because they’re unnecessary, but because implementing design patterns in the language can seem cumbersome or even “overkill” for the context.

That realization led me to create Pytterns an effort to bring the best of both worlds. The simplicity and elegance of Python combined with the robustness that design patterns provide.

Why Care About Design Patterns?

Design patterns aren’t just academic concepts; they are battle-tested solutions to recurring problems in software design. Using them in your projects brings several benefits:

• Organization: your code gains a clear and predictable structure.
• Reusability: you avoid reinventing the wheel.
• Communication: patterns serve as a “common language” between developers.
• Maintainability: systems become easier to understand and evolve.

The challenge is: how do you leverage these patterns without the overhead of writing repetitive boilerplate? That’s exactly where Pytterns comes in.

Installation

pip install pytterns

The Patterns Implemented in Pytterns

Strategy — choosing behavior at runtime

The Strategy pattern allows you to define a family of algorithms and switch between them dynamically.

Benefit: separates decision logic from implementation, making the code more flexible and extensible.

from pytterns import strategy, load

@strategy("payment")
class CreditCardPayment:
    def check(self, method):
        return method == "credit_card"
    
    def execute(self):
        return "Processing payment via Credit Card"

@strategy("payment")
class PayPalPayment:
    def check(self, method):
        return method == "paypal"
    
    def execute(self):
        return "Processing payment via PayPal"

payment_strategy = load.strategy("payment").check("paypal").execute()
print(payment_strategy)  # Processing payment via PayPal

Imagine being able to switch payment methods without ever touching the core business logic — that’s the power of Strategy.

Chain of Responsibility — processing requests in sequence

This pattern allows a request to pass through a chain of handlers, each responsible for a specific step in the process.

Benefit: reduces coupling and makes it easy to add, remove, or reorder steps in the flow.

from pytterns import chain, load

@chain("auth_chain", order=1)
class Authenticator:
    def handle(self, request):
        if not request.get("authenticated", False):
            print("Authentication failed!")
            return
        print("User authenticated")

@chain("auth_chain", order=2)
class Authorizer:
    def handle(self, request):
        if request.get("role") != "admin":
            print("Authorization failed!")
            return
        print("User authorized")

@chain("auth_chain", order=3)
class Logger:
    def handle(self, request):
        print(f"Logging request: {request}")

auth_chain = load.chain("auth_chain")
auth_chain.handle({"authenticated": True, "role": "admin"})

In practice, this makes it easy to build pipelines that evolve as your system grows.

Observer — reacting to events

The Observer pattern lets you register listeners for an event and notify them later.

Benefit: promotes decoupling — the event emitter doesn’t need to know who’s listening.

from pytterns import observer, load

@observer('user.created')
def send_welcome_email(user_id):
    print(f"send welcome to {user_id}")
    return 'email_sent'

@observer('user.created')
class AuditListener:
    def update(self, user_id):
        print(f"audit: created {user_id}")
        return 'audited'

results = load.observer('user.created').notify(42)
print(results)  # [(True, 'email_sent'), (True, 'audited')]

When a user is created, you can send a welcome email, log an audit, trigger metrics — all independently and without tight coupling.

Factory — creating objects dynamically

The Factory pattern centralizes the creation of objects without exposing instantiation details.

Benefit: organizes object creation logic and allows you to easily swap implementations at runtime.

from pytterns import factory, load

@factory('db')
class MyDB:
    def __init__(self, dsn):
        self.dsn = dsn

inst = load.factory('db').create('sqlite:///:memory:')
print(inst.dsn)

You can register multiple database engines and switch between them without changing business logic.

Command — encapsulating actions as objects

The Command pattern maps commands to handlers (functions or classes) that can be executed on demand.

Benefit: decouples the caller from the executor and enables features like undo/redo, queuing, or scheduling commands.

from pytterns import command, load

@command('say')
def say(msg):
    print(msg)

@command('say')
class Loud:
    def execute(self, msg):
        print(msg.upper())

load.command('say').execute('hello')

Perfect for CLIs, task queues, or bots that need flexible command execution.

Conclusion

Pytterns was born from the desire to lower the friction of using design patterns in Python.
Why waste time reimplementing well-known structures when we could focus on solving real business problems?

If you already use patterns, this library will give you productivity.
If you’re learning, it provides clear, practical examples to study and apply.

And because it’s open source, the project grows with community contributions.
If you’d like to add new patterns, suggest improvements, or open PRs, your help is more than welcome.

Useful links

👉 Check out the repository on GitHub: github.com/marcosstefani/pytterns
👉 Check Pypi project: https://pypi.org/project/pytterns

Pytterns: Making Design Patterns in Python Simple and Intuitive was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

Ah, Python! A language that captured my heart from the first “Hello, World!” Its captivating simplicity and boundless flexibility have been reliable guides on my programming journey. With each line of code, I was enchanted by the clarity of the syntax and the ease of expressing complex ideas. Python, for me, represented more than just a programming language; it was a companion that simplified challenges and transformed intricate concepts into something accessible.

The inherent flexibility of Python has always been an ally, allowing me to adapt solutions to a variety of problems. Whether developing small projects or tackling more ambitious challenges, the versatility of this language seemed boundless, as if each line of code were an extension of my thoughts.

The speed at which Python solves problems is truly remarkable; it accelerated my development process and unlocked doors to innovation. Reaching the peak of my language experience, I utilized in cloud lambda functions and Flask microservices for mathematical solutions.

However, as my passion for Python continues to burn, I can’t help but wonder: What lies ahead for Python’s future? In my view, the initial charm seems to be at a crossroads. Amid the pursuit of increasingly elegant solutions, questions linger. Are we, in our quest for sophistication, losing the essence of the simplicity that made Python so special? With so many new programming languages and concepts emerging, is Python falling behind? Does it tend towards obsolescence by not keeping up with the latest trends?

All these questions have crossed my mind, and I would like to share some of my thoughts and the conclusions I have reached. I may come to the conclusion in the future that I was completely mistaken, but it is always interesting to raise questions, and as a lover of the language, I feel compelled to do so. Join me as we delve deeper into the challenges and uncertainties that may shape the future of this beloved language.

As we immerse ourselves in the dynamic realm of the Python programming language, we find a complex interplay that not only defines the language’s functionality but also charts its course into the future. Python, renowned for its simplicity and efficiency, transcends syntax to become an ecosystem where community influence is pivotal for ongoing development.

The Python community, a diverse tapestry of programmers, reveals nuanced facets. Among its members are individuals with solid mathematical knowledge, occasionally lacking in modern programming practices. Data analysts, deeply engaged in Python’s expansive possibilities, constitute a significant contingent. There are also those adopting Python as a second language from object-oriented backgrounds, introducing unique challenges and sometimes facing resistance when proposing substantial syntax changes.

Resistance to change, a recurring challenge in any programming language’s evolution, emerges as an intrinsic dilemma within the Python community. While some advocate for the stability of the current syntax, others recognize the urgent need to evolve in order to stay relevant in a rapidly shifting technological landscape.

A personal narrative underscores the conflict between tradition rooted in the efficiency of C, Python’s development language, and the imperative to transcend these constraints to embrace modern standards. The diversity of the Python community lies not just in a range of knowledge but also in the ability to surmount challenges and embrace change when necessary.

A comparative analysis between Python, Java, and .Net offers a deeper understanding of the underlying philosophies of each language. Java, with its rigorous approach to object-oriented programming, stands out for its robust, class-oriented structure. In contrast, .Net, with its modular and open nature, provides a flexible platform tailored to the specific needs of each project.

Python, with its simplicity and efficiency inherited from C, maintains a clean and minimalist syntax. While this appeals to both novices and veterans, it challenges those seeking to expand the language beyond its C roots.

The future of Python rests in the hands of the community, which must skillfully navigate the delicate balance between deeply entrenched tradition and the constant need for innovation. Resistance to change is understandable, yet stagnation could impede progress. Integrating modern standards, acknowledging the diverse experiences within the community, is crucial to ensure that Python not only holds its ground but thrives in a dynamic and ever-evolving landscape.

In this panorama, Python’s journey transcends mere code and transforms into a human narrative — a saga reflecting the intricate relationships among programmers, programming languages, and the unyielding quest for equilibrium between the past and the future. As the Python community confronts challenges and shapes the language’s destiny, the story is far from concluded. This marks the commencement of a journey toward sustainable improvement and continuous adaptation.

An illustrative example of this dynamic can be seen in the trajectory of the PHP language. In the early years of the 21st century, when many professionals, myself included, were beginning their careers in the job market in Brazil around the 2000s, PHP emerged as a promising and exciting technology for web developers. Its simplicity and ease of learning made it an attractive choice.

However, over time, I witnessed the evolution of the experience with PHP, a journey that, at certain points, negatively impacted its upward trajectory. Resistance to adopting best practices, lack of standardization, and fragmentation in the PHP ecosystem were factors that, at a certain point, threatened to compromise its position and reputation in the web development landscape.

This experience with PHP prompted deep reflection on the influence of the community in shaping the fate of a programming language. This example serves as a warning about the dangers of resisting beneficial changes, a lesson I carry when considering the future of other languages, including Python.

The fear that similar resistances to implementing improvements may manifest in the Python universe, especially regarding innovative concepts like decorators, is a realistic concern. The experience of what happened with PHP provides valuable insight into how reluctance to embrace evolution can negatively impact the development of a language over time.

On the other hand, it is crucial to recognize that PHP, after years of challenges, has been reinventing itself and regaining its foothold in the market. However, it cannot be ignored that the long journey of recovery often results in significant losses. The PHP language lost ground over the years in its quest to recover its reputation and relevance. This highlights an important reality: a quick and certain recovery is not always possible.

This scenario serves as a warning to the Python community, emphasizing the importance of learning from past experiences. Reinvention may be possible, but it is a delicate process that requires time and effort. The fear is not just of change but also of facing a prolonged and uncertain recovery curve, illustrated by PHP’s trajectory over the years.

In conclusion, I reinforce that the considerations presented reflect my opinion as a professional with over two decades of experience in the field and a genuine love for programming. Over the years, cultivating knowledge of various languages has become a passion — a constant learning process in which I seek to understand not only syntax but also the specific purposes and nuances of each tool. The wise words of Léo Hackin resonate deeply in my daily practice: “We don’t need to know how to program in every language, but we need to know what each one is for and what its advantages and disadvantages are.” In this spirit, I persist in exploration and in-depth understanding, believing that this approach enriches not only my professional repertoire but also contributes to the constant advancement and evolution in the programming universe.

Additionally, I express the hope that these reflections will be received warmly by the Python community. My intention in sharing these ideas was not to offend but to promote constructive discussion. I firmly believe that dialogue around programming languages is essential for collective progress, and it is with the intention of positively contributing to this discourse that I share my perspectives. May this article be regarded as a contribution to reflection with the respect and affection I dedicate to the community to which I have belonged for so many years.

If you want to know a little more about me, follow my contacts:
GitHub: https://github.com/marcosstefani
Linkedin: https://www.linkedin.com/in/marcosstefani

Thank you.

Python decorators are a powerful feature that many developers underestimate or are unaware of. They offer a flexible and elegant way to modify code behavior, making it more dynamic and adaptable. In this article, we will delve deep into Python decorators, from the basics to advanced scenarios. You will discover how to create custom decorators, use them to preprocess code, and even generate code dynamically based on information contained in the decorators. Get ready to unlock the full potential of Python decorators and enhance your ability to write more efficient and versatile code.

Throughout this article, we will explore practical examples that illustrate the power of Python decorators. The best way to understand how decorators can be used is through concrete examples, which is why we will present sample code that demonstrates how to create and apply custom decorators in Python.

Simple Example

The code we will present is a simple yet illustrative example of how you can use decorators to preprocess code and generate additional code based on the information contained in these decorators. This example serves as a starting point for you to further explore the possibilities of Python decorators in your own projects.

Let’s dive into the code and discover how decorators can enhance the flexibility and functionality of your Python code.

# Define a custom decorator that takes arguments
def my_annotation(arg1, arg2):
    def decorator(func):
        def wrapper(*args, **kwargs):
            # Perform preprocessing based on the decorator arguments
            result = func(*args, **kwargs)
            # Generate additional code based on the decorator arguments
            generated_code = f"Arg1: {arg1}, Arg2: {arg2}"
            return result, generated_code
        return wrapper
    return decorator

# Use the custom decorator
@my_annotation("foo", "bar")
def my_function():
    # Your code here
    return "Function result"

result, generated_code = my_function()
print("Result:", result)
print("Generated code:", generated_code)

The code demonstrates the use of custom decorators in Python to preprocess code and generate additional information based on decorators. Let’s examine the result of this example code.

1. First, we define a custom decorator called my_annotation that accepts two arguments, arg1 and arg2. This decorator is used to wrap a function called my_function.
2. Inside the my_function function, there's nothing exceptional going on. It simply returns the string "Function result."
3. However, when we apply the @my_annotation("foo", "bar") decorator to the my_function function, something interesting happens. The custom decorator is executed and wraps the function. It performs preprocessing based on the provided arguments, which are "foo" and "bar" in this case.
4. The result of the my_function function is retained, but the decorator also generates an additional string that incorporates the decorator's arguments. In this example, the generated code is "Arg1: foo, Arg2: bar."
5. Finally, when we call my_function, it returns both the result of the function ("Function result") and the code generated by the decorator ("Arg1: foo, Arg2: bar").

Generating Methods

In the code below, we will explore a powerful technique in Python that demonstrates how it is possible to use decorators for code generation. We will create a custom decorator called @Json, which will add a special method to a class. This method will allow objects of that class to automatically generate JSON-format representations of their properties, simplifying the serialization process. This is just a glimpse of the possibilities that decorators offer for customizing the behavior of classes in Python. Let's dive into this example and discover how the @Json decorator can facilitate code generation in your own implementations.

import json

# Define a @Json decorator
def Json(cls):
    """
    Decorator to add a toJSON method to a class that returns a JSON representation
    of all object properties.
    """
    def toJSON(self):
        return json.dumps({key: getattr(self, key) for key in self.__dict__})
    
    setattr(cls, "toJSON", toJSON)
    return cls

# Use the @Json decorator
@Json
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# Create an instance of the Person class
person = Person("Alice", 30)

# Call the toJSON method to get a JSON representation of object properties
json_result = person.toJSON()
print(json_result)

Complex Example

Imagine having a Python environment rich in configurations, where you can effortlessly load properties from a YAML file into your classes, similar to the functionality provided by `@ConfigurationProperties` in Java’s Spring Boot. In this article, we will explore the creation of a custom decorator called `@Property`, which allows you to automatically load properties from a YAML file into your Python classes. This decorator will streamline configuration and customization of objects in your code, making it more flexible and reusable.

Let’s dive into the example and understand how the `@Property` decorator can be applied to load YAML configurations into Python classes, enabling you to focus your energy on developing features rather than worrying about configuration details.

Define the @Property Decorator

Start by defining the @Property decorator with a prefix parameter to specify the prefix for properties in the YAML file. For example:

from dataclasses import dataclass

@dataclass
class Property:
    prefix: str

Create a Decorator for Classes

Create a decorator that accepts a class decorated with the @Property decorator and loads values from the YAML file. Use a Python library like PyYAML to parse the YAML file. Here is a general outline of how this can be done:

import yaml
import os

def load_yaml_properties(cls):
    yaml_path = f"config/{cls.__name__.lower()}.yml"  # Define the path to the YAML file
    if os.path.exists(yaml_path):
        with open(yaml_path, "r") as yaml_file:
            yaml_data = yaml.safe_load(yaml_file)
            for key, value in yaml_data.items():
                setattr(cls, key, value)

    return cls

def Property(prefix):
    def decorator(cls):
        cls = load_yaml_properties(cls)
        return cls

    return decorator

Using the @Property Decorator

Now you can use the @Property decorator on a class, specifying the prefix to load properties from the corresponding YAML file:

@Property("app.config")
class AppConfig:
    pass

Configuration YAML File

Make sure to create a corresponding YAML file with the desired properties and the specified prefix. For example, for the above code, you would have a “config/appconfig.yml” file with the desired properties:

app:
  config:
    property1: value1
    property2: value2

Using the Properties

Now, when you create an instance of the AppConfig class, the properties will be automatically loaded from the corresponding YAML file:

config = AppConfig()
print(config.property1)  # This will print "value1"

Conclusion

In the realm of Python development, custom decorators represent a powerful tool for enhancing code flexibility and maintainability. Our journey through this article has unveiled the potential of decorators, with a focus on the creation of the @Property decorator, which streamlines configuration management by loading properties from YAML files into Python classes.

However, it’s important to recognize that decorators in Python go far beyond this single use case. They serve as a versatile mechanism for adding metadata, behavior, and customization to classes, methods, and functions. Decorators empower developers to shape the behavior of their code, enhancing its readability, reusability, and adaptability.

Whether you’re creating custom decorators to simplify configuration, documenting code, or implementing design patterns, understanding the power of decorators is a valuable asset in your Python development toolbox. They provide an elegant means of conveying your intentions to other developers and even to the Python interpreter itself.

As we conclude our exploration of decorators, remember that Python’s flexibility allows you to tailor decorators to suit your specific needs and design goals. By harnessing the potential of decorators, you can create more expressive, maintainable, and powerful Python code. Embrace the versatility of decorators as you embark on your coding journey, and you’ll find that they are a valuable asset for building exceptional Python applications.

If you want to know a little more about me, follow my contacts:
GitHub: https://github.com/marcosstefani
Linkedin: https://www.linkedin.com/in/marcosstefani

Unlocking the Power of Python Decorator was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

The Java programming language has long enjoyed a prominent place in the world of software development, thanks to its portability, robustness, and extensive developer community. However, over the years, the language has undergone a series of transformations to remain relevant and embrace emerging trends in the programming paradigm. One of the most significant of these transformations occurred with the introduction of “Functional Interfaces” in Java 8, which revolutionized how developers approach software development in Java.

Functional Interfaces represent a paradigm shift in Java, allowing for the adoption of functional programming in a more elegant and efficient manner. With the addition of features like lambda expressions and default methods in functional interfaces, Java opened the doors to a more concise, readable, and flexible programming style. This article delves deep into the world of Functional Interfaces in Java, exploring what they are, why they are important, and how they can be applied to enhance software development in Java.

In this article, we will explore Functional Interfaces in Java and how they can be used to improve code efficiency and readability. We will also discuss the benefits of embracing functional programming in Java and provide practical examples to illustrate their usage.

Enhancing Code Efficiency and Readability with Functional Interfaces in Java

One of the most notable features of Functional Interfaces in Java is the ability to utilize lambda expressions. These expressions allow developers to declare anonymous functions in a concise and straightforward manner, reducing the need to write an entire class just to implement a single functional interface. This results in more efficient code, as it eliminates the overhead of creating additional classes.

For example, prior to Java 8, if you wanted to sort a list of strings alphabetically, you would need to create a class that implemented the Comparator interface and then create an instance of that class to use it for sorting. With Functional Interfaces and lambda expressions, you can do this more efficiently:

List<String> nameList = Arrays.asList("Alice", "Bob", "Charlie");

// Pre-Java 8
Collections.sort(nameList, new Comparator<String>() {
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
});

// With lambda expressions
Collections.sort(nameList, (a, b) -> a.compareTo(b));

Improving Readability with Functional Interfaces

Another way in which Functional Interfaces enhance code quality in Java is through improved readability. With descriptive names for standard Functional Interfaces such as Predicate, Consumer, Function, and others, the code becomes more self-documenting. Developers can immediately understand the purpose of a lambda expression based on the context in which it is used.

Consider the following example where we want to filter a list of integers to find only the even numbers:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

// Without Functional Interfaces
List<Integer> evenNumbers = new ArrayList<>();
for (Integer number : numbers) {
    if (number % 2 == 0) {
        evenNumbers.add(number);
    }
}

// With Functional Interfaces
List<Integer> evenNumbers = numbers.stream()
                                    .filter(number -> number % 2 == 0)
                                    .collect(Collectors.toList());

The version that uses Functional Interfaces is more readable and closer to natural language. The expression number -> number % 2 == 0 clearly describes the intention to filter even numbers.

In summary, Functional Interfaces in Java not only make the code more efficient by reducing class overhead but also significantly improve readability, making the code easier to understand and maintain. They empower developers to embrace a more expressive functional programming style, which can result in more robust and high-quality systems.

Benefits of Functional Programming in Java

1. Code Conciseness: Functional programming encourages the writing of short and reusable functions, resulting in more concise and readable code. By adopting lambda expressions and higher-order functions, developers can eliminate much of the boilerplate, making the code clearer and focused on essential logic. This not only speeds up development but also simplifies maintenance.
2. Improved Readability: Functional programming emphasizes descriptive variable and function names, making the code easier to understand. This clarity is crucial in development teams as it allows members to quickly grasp the purpose of a function or expression. In contrast to imperative programming, where complex loops can obscure the code’s intent, functional programming promotes a more declarative and self-documenting style.
3. Immutability: Immutability is a central principle in functional programming. In Java, you can create immutable objects using the final keyword. This ensures that once an object is created, it cannot be modified, avoiding undesirable side effects. Immutability makes the code more predictable and secure, as there are no unexpected changes in object state.
4. Parallelism and Concurrency: Functional programming lends itself well to parallelism and concurrency. With the absence of mutable state and side effects, it becomes easier to write concurrent code without the risk of data races and deadlocks. Java offers libraries like the java.util.concurrent package, which work seamlessly with functional programming constructs to manage concurrent tasks efficiently.
5. Testability: Functional programming promotes pure functions, which have no dependencies on mutable state or external factors. This purity makes it easier to write unit tests because you can predict the behavior of functions without worrying about hidden side effects. Test-driven development (TDD) and unit testing are more natural in a functional codebase.
6. Code Reusability: Functional programming encourages the creation of small, reusable functions that can be composed to solve complex problems. Libraries and functions can be shared and reused across different parts of the codebase, reducing redundancy and making maintenance and updates more straightforward.
7. Safety and Reliability: Functional programming minimizes the potential for errors and bugs by reducing mutable state and side effects. This leads to more predictable and reliable code, making it easier to identify and fix issues.
8. Expressiveness: Functional programming allows for expressive and concise code. It focuses on “what” needs to be done rather than “how” it should be done, making the codebase more declarative and readable.

Practical Examples

Immutability: Creating immutable objects is a key practice in functional programming. Below is an example of an immutable class in Java:

public final class ImmutablePerson {
    private final String name;
    private final int age;

    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Recursion: Recursion is commonly used in functional programming to elegantly solve problems. Here’s an example of a recursive function that calculates the factorial of a number in Java:

public static int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

Higher-Order Functions: Higher-order functions can take other functions as arguments or return them as results. Below is an example that uses the map function to apply a function to each element of a list:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> squaredNumbers = numbers.stream()
                                       .map(x -> x * x)
                                       .collect(Collectors.toList());

Parallelism and Concurrency: Here’s an example demonstrating how Java’s parallelStream can be used with functional programming to parallelize a computation:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

int sum = numbers.parallelStream()
                 .mapToInt(Integer::intValue)
                 .sum();

This code parallelizes the summation of a list of integers, taking advantage of multi-core processors for improved performance.

Testability: Consider a pure function that calculates the square of a number:

public int square(int x) {
    return x * x;
}

Testing this function is straightforward since it relies only on its input and produces a deterministic output. You can write unit tests to validate its behavior easily.

Code Reusability: Functional programming encourages the use of higher-order functions like map, filter, and reduce. These functions can be reused across different data structures and scenarios. For example, you can use the same map function to transform elements in various collections.

Safety and Reliability: By minimizing mutable state and side effects, functional programming helps avoid unexpected behavior. It reduces the chances of null pointer exceptions, unintended state changes, and hard-to-debug issues.

Expressiveness: Functional code often reads like natural language, making it easier to understand the intent of the code. For instance, consider a Java stream pipeline that sums the squares of even numbers:

int sumOfSquares = numbers.stream()
                         .filter(number -> number % 2 == 0)
                         .mapToInt(x -> x * x)
                         .sum();

This code clearly expresses the intention to sum the squares of even numbers in the collection.

These examples demonstrate how functional programming in Java can lead to more efficient, readable, and reusable code. Adopting these principles and techniques can result in more robust and easily maintainable systems, aligning with modern trends in software development.

Conclusion

Throughout this article, we have explored the substantial benefits of adopting functional programming in Java, a language that has evolved considerably by incorporating the principles and practices of functional programming. In doing so, Java has become an even more powerful tool for developers seeking to write more efficient, readable, and secure code.

Code conciseness, improved readability, and an emphasis on immutability are just a few of the gains that functional programming brings to Java development. Lambda expressions, higher-order functions, and the stream library provide robust tools for creating more effective and scalable systems.

Furthermore, functional programming aligns perfectly with modern software development needs, such as parallelism, concurrency, and testability. It promotes the creation of safe, side-effect-free code, making it more predictable and reliable.

As illustrated through practical examples, functional programming in Java is not just a theoretical approach but a solid practice that can revolutionize how developers design, implement, and maintain their systems. Incorporating these principles into your development arsenal not only elevates code quality but also boosts productivity and responsiveness to the ever-changing demands of the software development world.

So, as you continue your journey as a Java developer, consider functional programming not just as an option but as a path that can open doors to new possibilities, significant improvements in software quality, and a more elegant approach to solving complex challenges. Make the most of this powerful and transformative approach, and allow functional programming in Java to take your projects and skills to a new level of excellence.

If you want to know a little more about me, follow my contacts:
GitHub: https://github.com/marcosstefani
Linkedin: https://www.linkedin.com/in/marcosstefani

Demystifying Functional Interfaces was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hexagon Architecture, also known as Ports and Adapters Architecture created by Alistair Cockburn, is a software architecture pattern that aims to separate the business logic of the software from technical concerns such as the user interface and data storage. The idea is that the business logic can be modified and tested independently of the external technologies that surround it.

One of the great advantages of the Hexagonal Architecture is the flexibility it offers. Because the architecture’s layers are clearly defined, it’s easy to add or modify components without affecting business logic. This makes the code more modular and easier to maintain.

Another advantage is the ease of testing the business logic. Since this layer is isolated, tests can be written without worrying about external technologies. This makes tests easier to write, faster to run, and more accurate.

Additionally, the Hexagonal Architecture facilitates the adoption of agile development practices such as continuous integration and continuous delivery. With clearly defined layers, it’s easy to automate testing and code integration.

Because I like this Design Pattern so much, I decided to write this article in order to help anyone who needs an example of development using Spring Boot and the PostgreSQL database. Sample project’s Git Repository:
https://github.com/marcosstefani/java-hexagonal-example

First of all, let’s make our docker-compose. To have a PosgtgreSQL running as a database and a RabbitMQ to exemplify a small use of MQ within this context:

About the Example:

In the example I developed, we basically have an application that provides information about weather forecasts. The data is held in a Postgres database, but the original data source is from a third party that provides us with information for a certain period. With that in hand, our application will fetch this information from the third-party API, store it in history and make the stored information available.

So, in summary, we will have a cron that will run from time to time and publish in a RabbitMQ queue a request to update data by city already registered in the database.

We will also have a RabbitListener listening to this message and updating the requested city data.

And finally, we will have a RestController to make the data available through an API to add a new city for monitoring.

Below is our structure:

Note that the structure was divided into two parts (adapter and core), where we will have the core of our application without any external components and the adapter that will contain all the content of components external to the application. The communication between these two layers will happen through the ports that are in out. What comes from the controller will be in in, this is due to the concept of inputs and outputs, in our example our only input is through a controller, RabitMQ is only being used in a task of the application itself. Access the full examplo on https://github.com/marcosstefani/java-hexagonal-example

Conclusion:

Based on the past example, it is clear that the Hexagonal Architecture is a very useful design pattern approach for separating the business logic of the software from technical concerns such as the user interface and data storage. By implementing the Hexagonal Architecture, we were able to isolate our application’s business logic into an independent layer, making it more flexible and easier to maintain.

Furthermore, implementing the Hexagonal Architecture allowed our tests to be more accurate and easier to write, as the business logic was isolated and not dependent on external technologies. This sped up our development process and ensured that our application was more reliable and robust.

It is important to emphasize that the Hexagonal Architecture is an approach that can be applied in different types of projects, from small applications to large distributed systems. It is particularly useful in projects that require high flexibility and scalability, as it allows the business logic to be easily adapted to handle changes in business requirements or underlying technologies.

In short, the Hexagonal Architecture is a powerful and flexible design pattern approach that can be applied in many software development projects. Its use makes it possible to separate business logic from technical concerns, increasing the application’s flexibility, ease of maintenance and reliability. It’s an approach worth considering in any software development project that requires high flexibility and scalability.

If you want to know a little more about me, follow my contacts:
GitHub: https://github.com/marcosstefani
Linkedin: https://www.linkedin.com/in/marcosstefani
Page: https://marcosstefani.github.io

Thank you.

Example of Hexagonal Architecture using Spring Boot+ Postgres was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

Você, como eu, já usou aquele MacOS na sua vida, aprendeu a gostar da interface e depois por meio de força maior ($$) resolveu usar o Linux, mas sempre fica aquele gostinho da usabilidade do MacOS? Ou você quer fazer com que seu Linux tenha aquela carinha bonitinha do MacOS? Então leia esse artigo até o fim. Aqui vou mostrar o passo-a-passo para que isso se torne uma realidade.

Bem, antes de mais nada gostaria deixar meu muito obrigado a todos os leitores que vem me incentivando a escrever aqui. Estou muito feliz com os feedbacks, procuro responder sempre! Vou deixar meus contatos abaixo para quem quiser trocar uma ideia:
Linkedin: https://www.linkedin.com/in/marcosstefani
GitHub: https://github.com/marcosstefani

Gostaria deixar claro, antes que me crucifiquem que tudo é uma questão de gosto, e como cada um tem o seu não me crucifique por favor. Esse tutorial é para pessoas que, como eu, AMAM o Ubuntu mas gostariam que ele tivesse aquela carinha discolada do MacOS por escolha ou por ter acostumado (como eu). Então vamos ao que interessa!

Instalação do Gnome Tweak:

A ferramenta Gnome Tweak é usada para personalizar a aparência e o comportamento do Ubuntu e servirá como ferramenta para personalizarmos nossa aparência. Para instalar, você precisa:

Adicionar o repositório:

sudo add-apt-repository universe

Com o repositório instalado, agora precisamos instalar o pacote do Tweak:

sudo apt install gnome-tweak-tool

Agora, precisaremos habilitar todas as extensões para posterior utilização:

sudo apt install $(apt search gnome-shell-extension | grep ^gnome | cut -d / -f1)

Download do Tema McMojave:

Antes de aplicar o tema McMojave, precisaremos instalar os seus pré-requisitos. Segue comando:

sudo apt install gtk2-engines-murrine gtk2-engines-pixbuf

Agora acesse a página abaixo e abra o menu Files.
https://www.gnome-look.org/p/1275087/

No meu exemplo fiz o download desse primeiro arquivo (Mojave-dark.tar.xz). Abri o terminal na pasta Downloads onde o arquivo se encontrava e digitei os seguintes comandos para descompactação do arquivo e movimentação da pasta para dentro de uma pasta .themes que será reconhecida pelo Tweak.

tar xf Mojave-dark.tar.xz
mkdir ~/.themes
mv Mojave-dark ~/.themes/

Download dos Ícones:

Agora faremos o mesmo, mas para baixar os arquivos que farão a configuração dos ícones. Para ficar igualzinho ao MacOS. Para isso, acesse a página abaixo e abra o menu Files:
https://www.gnome-look.org/p/1210856/

No meu exemplo fiz o download do segundo arquivo (Mojave-CT-Night.tar). Como no anterior, abri o terminal na pasta Downloads onde o arquivo se encontrava e digitei os seguintes comandos para descompactação do arquivo e movimentação da pasta para dentro de uma pasta .icons que será reconhecida pelo Tweak.

tar xf Mojave-CT-Night.tar.xz
mkdir ~/.icons
mv Mojave-CT-Night ~/.icons/

Download do Cursor:

Agora vamos deixar o cursor igual ao do MacOS. Para isso, acesse a página abaixo e abra o menu Files:
https://www.gnome-look.org/p/1148748/

No caso, fiz o download do único arquivo que havia disponível (macOs Cursor Set.zip). Mais uma vez abri o terminal na pasta Downloads onde o arquivo se encontrava e digitei os seguintes comandos para descompactação do arquivo e movimentação da pasta para dentro de uma pasta .icons que será reconhecida pelo Tweak.

unzip -qq macOS\ Cursor\ Set.zip
mv macOS\ Cursor\ Set ~/.icons/

Aplicação dos conteúdos baixados:

Agora, com os arquivos necessários em mãos, vamos aplicar o que temos até o momento. Para isso abra o Tweak, que se encontra no seu menu de aplicativos. Em seguida vá na opção Appearance e altere as três primeiras opções como no exemplo abaixo:

Ainda não acabou. Continue o tutorial para ter uma aparência ainda mais parecida.

Instalando o Dock igual ao do MacOS:

Agora iremos instalar um novo aplicativo chamado Plank. Ele substituirá o Dock padrão do Linux. Segue comando:

sudo apt install plank

Após instalação, abra o Plank no menu de aplicações:

Essa opção abrirá o Dock na parte inferior igual ao do MacOS.

Agora, precisamos alterar as propriedades. Para isso, com o CONTROL apertado clique com o botão direito sobre o novo Dock e selecione a opção Preferences. Esta opção abrirá a tela abaixo, onde você pode configurar seu novo Dock da maneira que achar melhor. Segue o exemplo que utilizei:

É importante colocarmos agora o novo Dock na inicialização dos programas. Para isso abriremos o Tweaks novamente e na opção Startup Applications incluiremos o Plank:

Porém, agora você estará com os dois Docks em execução (o original do Ubuntu e o novo que acabamos de instalar). Para evitar essa duplicidade, precisaremos desinstalar o antigo com o seguinte comando:

sudo apt remove gnome-shell-extension-ubuntu-dock

Após esta desinstalação, faça o logout e login que seu Dock antigo sumirá e permanecerá apenas o novo.

Alteração do Terminal:

Eu, particularmente, gosto de mudar o meu terminal para ficar mais limpo e que apresente a branch do Git quando existir. Para isso, abro o arquivo ~./bashrc e incluo a seguinte linha de comando no final do arquivo:

export PS1='\[\033[01;34m\]\w\[\033[0;93m\]$(__git_ps1 " (%s)")\[\033[01;34m\]$\[\033[00m\] '

Após salvar o arquivo, faça o logout e login novamente para aplicar a alteração. Eu também gosto de ir nas preferencias do e aplicar um pouco de transparência:

Dessa forma, tenho o seguinte resultado:

Conclusão:

Se quiser ainda pode alterar o plano de fundo. No meu caso, eu fui no Google Images mesmo, busquei por purple mac os wallpaper 1920 x 1080 e fiz o download do que mais me agradou.

Espero que tenham gostado desse resultado. Um forte abraço.

Depois do sucesso do artigo Spring Boot: Usando Propriedades da Aplicação percebi que muitas pessoas me vieram diretamente com dúvidas quanto ao uso efetivamente da propriedade em sua aplicação. Na ocasião eu fiz uma breve explicação do uso utilizando a anotação @Value do Spring Boot, e nesse artigo pretendo falar sobre o uso da aplicação utilizando classes de configuração que serão instanciadas com os valores das propriedades.

Diferente do artigo anterior, estarei utilizando Java e o padrão yml no lugar do properties apenas para fins de apresentação, porém são decisões que optei para apresentar nesse artigo e tudo isso pode ser feito por exemplo em Kotlin e/ou em arquivos yml.

Quando e Porquê usar as classes no lugar da anotação?

Penso que tudo depende da sua necessidade. Para ser sincero, prefiro evitar a anotação @Value pois além da classe facilitar bastante a questão dos testes unitários também evitamos repetição de declaração de variáveis que retornem os mesmos valores. Mas, como eu disse inicialmente, depende da necessidade, eu particularmente estou em um momento que ando preferindo utilizar classes com configurações por sentir que tudo fica muito mais organizado dessa forma.

Hands on:

Para fins de exemplo para este artigo, criaremos um arquivo application.yml para colocarmos as variáveis com valores default das minhas variáveis:

Note acima que temos duas propriedades, elas estão no ambiente default do Spring Boot, e caso executemos a aplicação sem definição de ambiente, será aplicado diretamente os valores contidos nesse arquivo.

Agora faremos um segundo arquivo que sobrescreverá o valor de apenas uma das variáveis quando o ambiente for definido, no caso escolhi o ambiente dev, para isso nomearemos nosso arquivo com o complemento “-dev”, vide exemplo abaixo.

Agora, só precisaremos criar um arquivo de configuração que fará a leitura dessas propriedades. Para isso, criaremos um @Bean do tipo @Configuration e acrescentaremos a anotação @ConfigurationProperties que conterá o valor do prefixo. Esse prefixo definirá dentro do aao nome drquivo properties qual é a segmentação que será lida por este arquivo. No nosso exemplo acima a segmentação será some.property, essa forma de leitura nos permite ter vários arquivos separados para cada segmentação.

No exemplo acima, temos duas variáveis string recebendo com o mesmo nome da nossa propriedade, não é impossível utilziar outros tipos como inteiro ou até mesmo uma lista.

Outra informação é importante é relacionada ao nome da variável. Ele deve ser o mesmo que está no arquivo. Porém, quando necessitar alguma variável com nome em camel case, ela pode ser definida no arquivo properties tanto com o próprio camel case ou separado por ífem. (meuExemplo ou meu-exemplo) e no caso, na variável do java definindo como meuExemplo receberá de uma forma ou de outra o conteúdo.

Agora vamos testar nosso código, eu apenas vou colocar um print do conteúdo para exemplificar.

Agora, ao iniciarmos sem definir o profile (ex. mvn spring-boot:run) teremos o seguinte resultado:

Note acima que o profile definido é o default e as informações são as que estão dentro do meu application.yml.

Agora, se rodarmos definindo definindo um profile (ex. mvn spring-boot:run -Dspring-boot.run.arguments=” — spring.profiles.active=dev”) teremos os valores que estão no arquivo application-dev.yml como prioridade na leitura da informação. Então, o que estiver dentro dele será considerado e o que não estiver pegará de application.yml.

Dessa forma, evitamos a utilização do @Value para ler a variável de ambiente e não necessitamos necessariamente carregar as dependencias do Spring para realização de testes.

Antes de mais nada, essa explicação é para pessoas com o mesmo cenário que eu. Tive que abrir uma empresa para prestar serviço a uma empresa do exterior e receberei mensalmente sob demanda.

Eu decidi seguir a orientação de alguns colegas que já passaram por isso e fui muito feliz até que, precisei refazer o pedido mas a forma de solicitar tinha mudado. Então, para que você não perca tempo na fila de atendimento por mais de 4 horas (como eu), a receita disponibilizou uma página para isso a partir do dia 12/03/2021 alterando assim a forma que essa solicitação é realizada. Então, segue os passos que tive que seguir de maneira detalhada:

Anexo I

Para realizar essa solicitação você precisa preencher esse documento. Ele pode ser acessado, juntamente com algumas explicações da receita federal por este link.

Com o documento em mãos, perceberá que o mesmo é dividido em três partes.

Parte 1- Identificação do Contribuinte:

Essa primeira parte deve ser preenchida por você com os dados da sua empresa (PJ). Lembrando que o campo Ramo de Atividade é o mesmo que estiver no seu contrato social, razão social e o endereço devem ser os informados no cadastro da empresa (Cartão CNPJ).

Parte 2- Rendimentos Auferidos no Exterior:

Essa segunda parte também deve ser preenchida por você e deve contar com os dados do contrato e valores contratados. Sendo eles:

Valor bruto: Valor (em moeda estrangeira. ex: “20.000 euros”) total que pretende receber durante o contrato. Por exemplo, se seu contrato for de 6 meses inteiros, você deve somar todos os valores que prevê receber nesses meses. Caso seu contrato não finalize no ano corrente, considere para cálculo o último dia do ano.

Imposto sobre Renda: Como você está trabalhando com uma previsão e emitirá notas mensais para a empresa que tens vínculo, deve colocar “A definir” nesse campo.

Período de referência: Aqui você deve preencher a data de início e término do contrato. Geralmente o contrato, mesmo que for um contrato a ser renovado tem uma data de término e é esta data que deve ser preenchida e considerada. Caso essa data vire de ano, considere o último dia do ano pois eles não aceitarão a virada de ano.

Convenção para evitar dupla tributação: Aqui colocará o país da empresa para a qual você prestará serviço.

Tipo de rendimento e artigo correspondente da convenção: Neste campo você terá que preencher de acordo com o tipo de rendimento. No meu caso, eu procurei saber com meu contador que me explicou que isso é uma convenção internacional. Procure se informar do seu, mas no meu caso preenchi com o valor “Serv. Prof. Indep. de Tecnologia da Informação Art.14”.

Nome e endereço da fonte pagadora: Aqui deves preencher os dados (nome e endereço completo) da empresa do exterior que está a contratar o seu serviço.

Número de identificação fiscal da fonte pagadora: Aqui deves preencher com o número de identificação fiscal que a empresa que está contratando seu serviço deve fornecer.

Parte 3- Declaração do contribuinte:

Esta parte deve ser preenchida e assinada por você. Nela você informará os dados da sua pessoa física juntamente com a data que está assinando o documento.

Parte 4- Declaração de autoridade tributária:

Deixar essa parte em branco para preenchimento da receita federal.

Acesso ao e-Cac:

Agora com o documento preenchido corretamente, você deve tê-lo em seu computador em formato PDF. Bem como o Contrato Social da sua empresa e o Contrato com a empresa do exterior assinado por ambas as partes.

obs. Todos os passos a seguir, fiz em um PC com Windows pois não consegui fazer com que o software da receita federal (Assinador) funcionasse no Linux.

Certificado Digital

Agora será possível enviar a documentação para assinatura da receita federal, porém você precisará adquirir (caso não tenha) um certificado digital. Recomendo adquirir o certificado digital A1 que é a versão instalada no computador, geralmente é o mais barato e foi a que eu fiz e posso garantir que dá certo. Lembrando que deve ser um certificado digital oficial (consulte seu contador e peça indicação pois deve ser emitido apenas por empresas autorizadas).

obs importante: O certificado digital tem que ser da sua empresa (PJ) e não da sua pessoa física.

Acesso à página do e-Cac.

Com o certificado em mãos e instalado na sua máquina com SO Windows, vá ao portal do e-Cac, segue link. Lá abrirá a seguinte janela. Clique em Entrar com gov.br em seguida em Certificado Digital. Se por acaso o navegador solicitar que você selecione o certificado digital, selecione o da sua empresa que você acabara de instalar no seu computador.

A parte que mudou no processo foi exatamente essa, a partir de 12/03/2021 quem abre o processo é você mesmo, sem necessidade de entrar no chat com um atendente. Isso facilita muito a velocidade. Para abrir uma solicitação, você vai selecionar a opção “Processos Digitais (e-Processo)” no menu:

Em seguida selecione a opção “Solicitar Serviço via Processo Digital”:

Esta ação abrirá um formulário para preenchimento de informações. Preencha os dados conforme a imagem abaixo, alterando o número para o seu número de contato:

Em seguida clique em “Abrir Dociê de Atendimento”. Quando o fizer, vai criar um dociê de atendimento que ficará no menu “Meus Processos”

Será exibido seu processo com os dados. Agora, vc precisa clicar no “+” que tem na coluna ações na linha que está o seu processo.

Isso expandirá as opções para seu processo. Para enviar os documentos clique em “Solicitar Juntada de Documento”.

Para cada um dos documentos, você deverá agora clicar em Adicionar Documento para Rascunho:

Você irá adicionar:

• O Anexo I preenchido, selecionar na lista dos tipos de documento como ATESTADO.
• O Contrato Social da sua empresa para comprovar vínculo da pessoa física e jurídica que estão no Anexo I. Incluir como CONTRATO SOCIAL E ALTERAÇÕES.
• O Contrato com a empresa no exterior, comprovando vínculo com a empresa no exterior informado no Anexo I. Incluir como CONTRATO-OUTROS.

Após verificação do antivirus, será liberado o botão enviar. Mas para explica-lo melhor, vou criar um novo tópico.

Enviar documentos com Assinador Serpro.

Ao clicar no botão enviar a página lhe apresentará uma mensagem informando que é necessário o Assinador da Serpro para que sejam enviados os documentos. Para isso você precisará instalar o assinador que pode ser baixado a partir da página da receita. Eu sugiro ir pelo link abaixo pois se vocẽ baixar pelo link da mensagem necessariamente baixará o exe da versão para Sistemas Operacionais 32 bits, mas se você estiver utilizando um 64 bits como eu, não entenderá porquê não está funcionando. Se você instalou o de 32, desinstale e instale o de 64. Segue link do assinador: https://www.serpro.gov.br/links-fixos-superiores/assinador-digital/assinador-serpro

Após fazer o download, instale o assinador e o inicialize. Ele ficará com um íconezinho azul perto do seu relógio do Windows.

Importante: Execute o Assinador como administrador.

Após inicializado o assinador, volte na tela de envio e clique em enviar novamente. A mensagem de orientação será exibida novamente, mas você verá que no final da mensagem você terá um “clique aqui caso tenha inicializado”. Eu só não fiz um print porquê eu já enviei os meus arquivos e para simular eu precisaria enviar novamente. Ao clicar no link que ele diz, você deverá autorizar a página a executar, após essa autorização você voltando na aba do navegador que estava enviando os arquivos verá que o envio foi realizado com sucesso.

Aguarde alguns dias (talvez vocẽ precisará limpar seus cookies para logar novamente), voltando em “Meus Processos” você vai na opção “Consultar Documentos”, veja:

Essa opção lhe exibirá o decorrer do processo, inclusive as respostas. Quando tudo der certo, você deverá receber o item “Atestado Assinado”, conforme imagem abaixo:

Selecione o mesmo e clique em “Obter Cópia Íntegra do Processo”. Isso fará você realizar o download de todo o processo em um arquivo Zip. Um dos arquivos é o seu arquivo assinado. No meu caso, o arquivo foi assinado digitalmente e não veio bem uma assinatura de punho, mas sim uma página que comprova a assinatura digital.

Espero ter ajudado de alguma forma.