DEV Community: Ronaldd Pinho

Loading dependencies in C++ projects using CMake

Ronaldd Pinho — Wed, 26 Jan 2022 14:23:54 +0000

With the modern programming languages, has turned common has a way to manage dependencies of your projects, either using npm, yarn, pip, or cargo this process is easy. However, when using C or C++ this process is not trivial. With this in mind, I thought to write this post about how I automate the download and configuration of libraries from Git repositories using the CMake.

Some solutions were created to solve this problem, such as conan and vcpkg but it loads another dependency installed on your system and requires your dependency to be indexed by its server.

The FetchContent module

CMake is a build system that automates the generation of Makefiles that define the compilation process of a source code project. It provides various modules that help with configuration in many ways. One of these modules is FetchContent, which helps to fetch external content at configuration time, ie when CMake is generating the Makefile.

It is quite simple to use it, in the example below we have added GoogleTest to our project:

include(FetchContent)
FetchContent_Declare(GoogleTest
    GIT_REPOSITORY https://github.com/google/googletest.git
    GIT_TAG        master
)
FetchContent_MakeAvailable(GoogleTest)

After that, we have the GoogleTest project as well as its libraries accessible at configuration time, so we can link any executable (or library) with GoogleTest, for example:

# create the main target for run the tests
add_executable(mytests
        test/main.cpp
        test/awesome_test.cpp)

# link with the googletest main library
target_link_libraries(mytests gtest_main)

Create a CMake function

To automate this process, I usually create a simple function that concentrates the code that uses FetchContent, this makes the CMake script more readable and easier to add new dependencies.

function(GET_DEPENDENCY D_NAME D_URL D_TAG)
    message(CHECK_START "Configuring ${D_NAME}")
    FetchContent_Declare(${D_NAME}
        GIT_REPOSITORY ${D_URL}
        GIT_TAG        ${D_TAG}
    )
    FetchContent_MakeAvailable(${D_NAME})
endfunction()

So I can use the get_dependency function passing three parameters:

D_NAME: the name to refers to this dependency.
D_URL: the link remote Git repository (example: https://github.com/...
D_TAG: the Git tag to get, may be the commit hash or version (examples: de6e5fa,v1.0.2, etc).

get_dependency(GoogleTest "https://github.com/google/googletest.git" master)

To add more dependencies...

get_dependency(spdlog "https://github.com/gabime/spdlog" v1.8.5)
get_dependency(CLI11 "https://github.com/CLIUtils/CLI11" v1.9.1)
get_dependency(GoogleTest "https://github.com/google/googletest" master)

When I use this configuration, it becomes much easier to add and remove dependencies on external libraries, especially since I use open source libraries on Github. This also helps in team design by not having to have a complex set of steps to set up the development environment on the developers' different machines. It also brings a benefit to using CI (Continuous Integration).

How it works

When you run the configuration command, such as

cmake -S . -B <build-dir>

CMake downloads the source code from D_URL and store into a directory <build-dir>/_deps. Inside the directory, FetchContent create three sub-directories: ${D_NAME}-src, ${D_NAME}-build and ${D_NAME}-subbuild.

Example with GoogleTest:

<build-dir>/
|   _deps/
|   |   googletest-src/
|   |   googletest-subbuild/
|   |   googletest-build/

src: source code of the dependency (from Git repository).
build: CMakeFiles directory of the dependency.
subbuild: created to perform the population of content.

For details, see FecthContent documentation.

Primeiros passos com a linguagem Go: Por onde começar?

Ronaldd Pinho — Wed, 26 Jan 2022 12:12:53 +0000

Ao se deparar com uma tecnologia nova, sendo alguém experiente em programação ou não, acredito que a mesma pergunta sempre passa pela cabeça de todos: "Por onde eu começo?". Particularmente, eu sempre fui um programador autodidata e, mesmo depois de iniciar uma graduação em computação eu sempre busquei informações de forma proativa e adianto para quem está iniciando na área de desenvolvimento de software que, essa é uma característica essencial para o desenvolvimento técnico de qualquer pessoa programadora.

Ao começar a estudar Go eu percebi uma grande quantidade de alternativas que na minha opinião pode deixar qualquer um confuso sobre como iniciar nos estudos da linguagem. Pensando nisso, resolvi escrever esse artigo com recomendações de por onde começar a estudar e praticar com a linguagem Go baseado na minha experiência estudando programação, com a esperança de que seja útil para qualquer pessoa interessada em aprender a linguagem independente de ter experiência em estudos de tecnologia ou não. Nas próximas seções, apresento opções de passos iniciais com a linguagem Go.

Go Tour

O Go Tour é um fluxo de aprendizado disponibilizado através do próprio site oficial da linguagem, onde você pode conhecer a linguagem Go do zero. É ideal para quem está iniciando, nele você navega por páginas onde são apresentados desde conceitos básicos de programação como variáveis e controle de fluxo, até conceitos específicos de Go como a forma como ele lida com concorrência usando goroutines e channels.

O Tour consiste de uma sequência de passos agrupados em módulos onde cada um apresenta algum conteúdo simples e a possibilidade de praticar com um exemplo pronto na própria página usando o Go Playground. Não precisa fazer nenhuma instalação e tem pouco (ou quase nenhum) pré-requisito para acompanhar. Está disponível em vários idiomas inclusive em português do Brasil e, é a melhor opção de primeiro passo para iniciantes. Mesmo pra quem já é da área, é interessante acompanhar o Tour como o contato inicial com a linguagem pois não consome muito tempo e apresenta conceitos específicos da linguagem de forma simples.

Curso: Aprenda Go

“Aprenda Go” é um canal no YouTube que disponibiliza um curso completamente gratuito apresentado pela Ellen Körbes. O curso é super completo e organizado em capítulos, cobrindo desde conceitos básicos de programação até as peculiaridades da linguagem Go com uma excelente didática o uso da linguagem na prática. Além disso, fornece muitos exercícios práticos entre um capítulo e outro.

Por se tratar de um curso de aulas em vídeo com mais de 20 capítulos, o conteúdo é um pouco mais extenso e, para pessoas que já possuem experiência com programação pode ser repetitivo no início. Ainda assim, é interessante acompanhar alguém com bastante conhecimento em Go falando sobre a linguagem, principalmente nos capítulos mais específicos sobre a mesma. Para pessoas com menos experiência, é a alternativa perfeita após terminar o Go Tour.

Go Blog

O site oficial da linguagem também possui um blog onde muitos dos core developers do projeto Go escrevem, além de muitos desenvolvedores ativos na comunidade (Gophers). O blog possui conteúdo escrito apresentando as propostas da linguagem bem como bibliotecas, sintaxe e etc, features novas que foram implementadas em versões específicas e, a maior parte do conteúdo encontrado lá é interessante para aprofundar em assuntos específicos da linguagem Go. Vale destacar que todos os artigos do blog são escritos em inglês

Abaixo seguem algumas postagens que eu julgo interessantes para quem está iniciando entender melhor a idéia do Go e como funcionam alguns conceitos. Também é interessante procurar aplicar os exemplos mostrados nas postagens de forma prática.

Go's Declaration Syntax: Escrito por Rob Pike, um dos idealizadores da linguagem, o artigo fala sobre a sintaxe declarativa do Go comparando com a linguagem C e explica o por quê Go faz as coisas do jeito que faz.
Defer, Panic, and Recover: Esse artigo explica como funcionam três comandos específicos da linguagem Go.
Go Concurrency Patterns: Timing out, moving on: Esse breve artigo mostra dicas de como trabalhar com concorrência de melhor forma em Go.
Go Concurrency Patterns: Context: Esse post apresenta a idéia da interface Context, uma interface pertencente à biblioteca padrão do Go e que é uma base do paradigma da linguagem para aplicações web.
JSON and Go: Proposta inicial e primeiro contato com o pacote encoding/json da biblioteca padrão do Go.
Using Go Modules: Um introdução aos modules, a forma como a linguagem Go gerencia conjuntos de pacotes e dependências. Essa postagem é a parte 1 de uma série de 5 postagens sobre o assunto.

[Bônus] Para quem tem interesse em entender mais afundo como trabalham os modules em Go, eu recomendo estudar o Go Modules Reference. Trata-se de uma documentação bem mais extensa e detalhada sobre módulos, e fica mais como uma dica para quem já tem experiência com programação e documentações de tecnologias e tem a intenção de se aprofundar na linguagem.

Pratique, pratique e pratique mais!

Isso não é segredo mas nunca é demais repetir, ninguém aprende nenhuma linguagem de programação somente lendo sobre ela. Então é interessante encontrar meios de praticar o uso da linguagem de forma que se possa aplicar os conceitos estudados, eu recomendo procurar aplicar qualquer conhecimento lido em postagens do blog para fixá-los e entendê-los melhor. O curso Aprenda Go ajuda bastante nesse quesito fornecendo uma boa quantidade de exercícios.

Também existem várias plataformas que podem ser usadas para exercitar programação, tais como: Codewars, HackerRank, Exercism, etc.

Invente projetos pessoais, isso com certeza vai te fazer exercitar não só o uso da linguagem de programação mas também fornece um certo exercício de criatividade que todo bom desenvolvedor deve ter para resolver os mais variados problemas.

Pra finalizar...

Minha recomendação pessoal é: acompanhar o Go Tour, depois assistir ao curso Aprenda Go procurando praticar com os exercícios (para quem já tem boa experiência em programação, recomendo avançar direto para capítulos mais específicos do curso). Em seguida fazer as leituras dos artigos de blog citados enquanto pratica o uso da linguagem através de exercícios ou mesmo projetos pessoais.

O ecossistema da linguagem Go tem ganhado cada vez mais popularidade no mercado e com isso têm surgido cada vez mais conteúdo sobre a linguagem na internet, dentre esses muito conteúdo gratuito de qualidade. Nesse post busquei apresentar as alternativas mais simples para os primeiros passos com a linguagem de forma a atender tanto pessoas com experiência em programação quanto iniciantes.

Por fim, vale lembrar que isso esses são somente passos iniciais nos estudos da linguagem. Não pare por aqui, busque mais conteúdo, pratique, estude a documentação de módulos do Go, pratique mais um pouco, dê uma olhada no Golang Developer Roadmap e busque pelas bibliotecas em alta no mercado, pratique ainda mais... E não deixe que esse loop seja quebrado.

Carregando dependências em projetos C++ usando o CMake

Ronaldd Pinho — Wed, 14 Jul 2021 13:32:41 +0000

Com as linguagens de programação modernas é muito comum possuir-se um meio de obter e gerenciar dependências, seja usando o pip, cargo, npm ou yarn, esse processo se torna extremamente simples. Contudo, quando se trata de linguagens como C e C++ isso é um pouco diferente, não existe um único meio padronizado de obter bibliotecas externas. Pensando nisso, pensei em escrever esse post mostrando como automatizo a obtenção de bibliotecas de repositórios Git remotos usando o CMake.

Existem soluções criadas pela comunidade como o conan e o
vcpkg mas elas carregam outra dependência na máquina e
requerem que a biblioteca que você quer esteja indexada por eles.

O módulo FetchContent

O CMake é sistema de build que atomatiza a geração de Makefiles que definem o processo de compilação de um projeto de código-fonte. Ele fornece vários módulos que ajudam na configuração de várias formas. Um desses módulos é o FetchContent, que ajuda a obter conteúdo externo em tempo de configuração, ou seja, quando o CMake está gerando o Makefile.

É bastante simples de usá-lo, no exemplo abaixo adicionamos o GoogleTest ao nosso projeto:

include(FetchContent)
FetchContent_Declare(GoogleTest
    GIT_REPOSITORY https://github.com/google/googletest.git
    GIT_TAG        master
)
FetchContent_MakeAvailable(GoogleTest)

Depois disso, temos o projeto do GoogleTest bem como suas bibliotecas acessíveis em tempo de configuração, então podemos vincular qualquer executável/biblioteca com o GoogleTest, por exemplo:

add_executable(mytests "test/main.cpp" "test/awesome_test.cpp")
target_link_libraries(mytests gtest_main)

Criando uma função CMake

Para automatizar esse processo, eu costumo criar uma função simples que concentra o código que usa o FetchContent, isso torna o script CMake mais legível e fácil de adicionar novas dependências.

function(GET_DEPENDENCY D_NAME D_URL D_TAG)
    message(CHECK_START "Configuring ${D_NAME}")
    FetchContent_Declare(${D_NAME}
        GIT_REPOSITORY ${D_URL}
        GIT_TAG        ${D_TAG}
    )
    FetchContent_MakeAvailable(${D_NAME})
endfunction()

Assim consigo usar a funcção get_dependecy passando o nome, a URL e a versão (ou tag) da biblioteca.

get_dependency(GoogleTest "https://github.com/google/googletest.git" master)

Para adicionar mais dependências...

get_dependency(spdlog "https://github.com/gabime/spdlog" v1.8.5)
get_dependency(CLI11 "https://github.com/CLIUtils/CLI11" v1.9.1)
get_dependency(GoogleTest "https://github.com/google/googletest" master)

Quando uso essa configuração, se torna muito mais fácil adicionar e remover dependências de bibliotecas externas, principalmente por usar bibliotecas abertas com código-fonte no Github. Isso também ajuda em projeto em equipes permitindo que não seja necessário um conjunto de passos complexos para configurar o ambiente de desenvolvimento nas diferentes máquinas dos desenvolvedores. Também traz um benefício para o uso CI (Continous Integration).

Different basic ways to undo commits on git

Ronaldd Pinho — Wed, 18 Mar 2020 23:38:25 +0000

Git is undoubtedly one of the best version control tools today. However, some features provided by it still are confusing for beginners, especially when it comes to manipulations of the directory tree and the various "status" of files in it. So, I thought about making this post talking about different ways to undoing changes in a git repository in accordance with the situation.

The "Three Trees" concept

First of all, it is necessary to understand one of the basic concepts of git called "Three Trees". Basically, the directory tree of a git repository has three states, 1) the working directory which is the current file system you are interacting with directly, 2) the staging area which are the files that were selected for the next commit and 3) the history of commits which is the file system saved in the repository through snapshots.

This is a base concept for understanding git. For a more detailed explanation, I suggest this Bitbucket tutorial.

When I need to revert changes?

Commonly we are faced with situations where we want to reverse changes committed in the project, and these situations can be quite varied. To know what command is more appropriated to undo the changes which you desire, it is important to know well your reason for you want to undo these changes on the project. Come discuss some possibilities.

Your more recent modification has caused an error or a regression of the project, so you need to only undo the recent changes discarding it.
You found a better way to solve a problem and want to redo something keeping this moment on commit history.
You committed several files, and you want to undo this commit and do a commit with fewer files.
Your commit made a snapshot of changes in a set of files, but you want to restore the content of a specific file no removing the commit.

Commands to undo changes

There are several ways to undo changes/commits with git. I tried to consider the most basic methods to make the post accessible to all levels of git users. With three simple commands, it is possible to make the most diverse manipulations in the "Three Trees" of git, these are: git checkout, git reset and git revert.

Think on the commits as steps of a ladder, where you can take steps forward and steps backward. Some commands allow you to manipulate the HEAD (the pointer that set the current structure of directory) to "walk" through the commits, undoing changes on the directory and letting you made new changes from past commits by overwriting the recent commits.

git checkout:
This command is used to change the HEAD reference. It is very used to switch for another branch, but also may be used to move the HEAD to another commit in the same branch.
Using git checkout [commit-hash], the HEAD is pointed to the commit specified by hash. This command also may be used to undo changes not stagged in one specific file using git checkout -- <file>.

git reset:
Using this command is possible made the directory "forget" all changes of the specific commits (using the --hard flag) or keep the modifications made by the commits on the staged area (using the --soft flag). The main difference between git reset and git checkout commands are the checkout move only the HEAD ref, while the reset allows moving all working tree - inclusive the current branch - to the specified commit, breaking the commit history continuity.

A simple example of usage is setting the number of commits for jump backward. Using git reset [commit-hash] HEAD~4, the state of the working directory is changed to 4 commits backward from the actual (Pointed by HEAD).

git revert:
Using this command, you reverse the changes of the last commit and create a new commit to save this reversion. So, you will keep the reversed commit in the history of your project.

Applying on the different situations

Knowing these commands and their basic operation, we will look for the most appropriate method of undoing changes for each of the situations mentioned above.

Your more recent modification has caused an error or a regression of the project, so you need to only undo the recent changes discarding it.

In this case, I use:

$ git reset --hard <commit-hash>

The --hard flag reverses all changes directly on the working directory, thus the modifications are forgotten immediately.
OBS: This command with the --hard flag is considered dangerous because you can't recovery your modifications.

You found a better way to solve a problem and want to redo something keeping this moment on commit history.

In this case, I use:

$ git revert <commit-hash>

After this command a new commit is created on the commit history, allow to identify where the changes were reversed and if I want to recovery these changes, I have them in the commit history.

You committed several files, and you want to undo this commit and do a commit with fewer files.

This is interesting for reorganizing the next commits separating the files in several commits. In this case, I use:

$ git reset --soft HEAD~2

After this command, the state of the working directory such as the current branch is changed to two steps backward, the current state (step 1) and state of the last commit (step 2), setting the state to one commit before the last commit keeping the more recent changes in the working directory (because the --soft flag) allowing to commit it as I desire.

You made a commit that made a snapshot of changes in a set of files, but you want to restore the content of a specific file no removing the commit.

In this case, I use:

$ git checkout <commit-hash> <file>

After this command, the file <file> will be reversed to its state in the commit <commit-hash> and will be staged for the next commit automatically

Remarks

It is very important to know the situation that led to the need to undo something. Here, simple examples have been shown.
I believe that looking for simple solutions to recurring problems is a good starting point for starting studies of any technology, and with git, it is no different.

However, there are always more complete and complex ways to work. For an in-depth look at git, I recommend the official git documentation and Atlassian tutorials.

I hope this post can answer someone's doubts.
Thanks for reading ;)

References used

Git Docs
Git Book
Atlassian Tutorials - Git reset