Ricardo Dias Avelar

Henrique Lisboa de Sousa

Diógenes Vaz de Melo Oliveira
Samuel Henrique Miranda Alves
João Pedro Braga Ennes

PROJETO DE ORGANIZAÇÃO DA INFORMAÇÃO

Trabalho final apresentado à disciplina Organização e Tratamento da Informação - OTI do curso

de Sistemas de Informação

Orientadora: Profª. Dra. Célia da Consolação Dias

Belo Horizonte

Departamento de Ciência da Computação

UFMG

2022

1
 SUMÁRIO

APRESENTAÇÃO --------------------------------------------------------------------------------------------------- 4

DIAGNÓSTICO -------------------------------------------------------------------------------------------------------5
2.1 Fluxo de informação e recursos de informação existente --------------------------------------- 5
2.2 Usuários da informação e suas necessidades de informação --------------------------------- 7
2.3 Fundamentação teórica do projeto -------------------------------------------------------------------- 7

SOLUÇÃO DO PROBLEMA ------------------------------------------------------------------------------------- 9

3.1 solução proposta ------------------------------------------------------------------------------------------ 9
3.2 justificativa ------------------------------------------------------------------------------------------------- 10
3.3 Recursos necessários ---------------------------------------------------------------------------------- 10
3.4. Implementação e limitações da solução ---------------------------------------------------------- 10

CONSIDERAÇÕES FINAIS ------------------------------------------------------------------------------------- 11

REFERÊNCIAS BIBLIOGRÁFICAS -------------------------------------------------------------------------- 11

2
 1. APRESENTAÇÃO

Um grande desafio para o desenvolvimento de sistemas é a administração do

versionamento do código. Isso porque, no fundo, um sistema é armazenado em formas de
arquivos, que vão sendo atualizados na medida em que os desenvolvedores propõem mudanças
e implementações de funcionalidades novas. Como é de se imaginar, um problema recorrente é
o fato de que várias pessoas trabalhando, ao mesmo tempo, nos mesmos arquivos, geram
conflitos que tornam difícil a tarefa de um software de gerenciamento de versões. Além disso,
uma preocupação grande é que o sistema esteja sempre funcionando de maneira estável,
independente dos testes e mudanças feitas para o desenvolvimento de suas funcionalidades.

Para tornar essa tarefa possível, existem várias soluções disponíveis, sendo a mais
conhecida e amplamente utilizada delas, um sistema chamado GIT. O GIT é um sistema de
gerenciamento de versões de documentos, desenvolvido pelo criador do Linux e mantido pela
própria comunidade de desenvolvedores. Aliado a essa tecnologia, muitas empresas utilizam o
GitHub, que é um sistema para hospedar arquivos usando GIT como base. Essa junção permite
estabelecer um ambiente de desenvolvimento seguro e coletivo, além de proporcionar várias
funcionalidades que facilitam o trabalho de administração do fluxo de trabalho. Por isso, para
que se tenha maior proveito dessas ferramentas, existem padrões de projeto e de administração
de fluxo, que, se mal utilizados, acabam prejudicando o desenvolvimento e gerando conflitos
que poderiam ser evitados.

O problema que nosso grupo se propõe a resolver é o de organização da informação em

um estúdio brasileiro de jogos, uma empresa real. Atualmente, a empresa apresenta problemas
relacionados à estratégia de versionamento de código utilizada, o GIT/GitHub. Nosso trabalho
terá seu foco voltado para a estruturação e criação de um padrão de workflow de
desenvolvimento, para que a equipe de trabalho possa realizar seu trabalho de forma mais
segura e controlada. Por fim, como solução final, pretendemos identificar onde estão as fontes
de problemas e então propor maneiras para resolvê-los.

3
 2. DIAGNÓSTICO

Na empresa em questão, foi identificado um problema relacionado ao

arquivamento, organização, manutenção e recuperação de dados e objetos
desenvolvidos. A empresa trabalha com o software GitHub, e todos os problemas
encontrados são passíveis de solução por meio de um bom gerenciamento da ferramenta.
A empresa contraria princípios de workflow do GITflow, fundamentais para uma boa
organização de projeto ao utilizar o GitHub.
Temos nessa ferramenta a função de arquivar, realizar manutenção e recuperação
de dados em nuvem de qualquer projeto. O GitHub nos permite realizar a manutenção
do código por meio de cópias do projeto, que são chamadas de branchs. Ao modificar
esses branchs, podemos realizar commits e pulls, que nada mais são do que meios para
substituir arquivos do projeto principal pelas suas modificações no branch em questão.
É recomendado, pelos princípios do GITflow, que “os desenvolvedores criem
uma ramificação de recurso e atrasem a mesclagem com a ramificação de tronco
principal até que a feature em questão seja concluída. Essas ramificações de recursos de
longa duração exigem mais colaboração para mesclar e têm um risco maior de desviar da
ramificação de tronco. Eles também podem introduzir atualizações
conflitantes.”(www.atlassian.com). Na empresa em questão, no entanto, não são
utilizados branchs, causando diversos problemas diferentes.

2.1 Fluxo de informação e recursos de informação existente

A principal diferença entre o Git e qualquer outro Sistemas de Controle de

Versão é a maneira como o Git pensa sobre seus dados. Conceitualmente, a maioria dos
outros sistemas armazena informações como uma lista de alterações baseadas em
arquivo. Esses sistemas pensam nas informações que mantêm como um conjunto de
arquivos e as alterações feitas em cada arquivo ao longo do tempo.

4
 Figura 1: registro de alterações por Sistemas de Controle de Versão baseados em arquivos. Fonte:
Primeiros passos - Noções Básicas de Git.

O Git não pensa ou armazena seus dados dessa maneira. Em vez disso, o Git
pensa em seus dados mais como um conjunto de snapshots de um mini sistema de
arquivos. Toda vez que o estado de um projeto é salvo no Git, este basicamente “tira
uma foto” de como todos os seus arquivos estão naquele momento e armazena uma
referência a esse instantâneo. Para ser eficiente, se os arquivos não foram alterados, o
Git não armazena o arquivo novamente - apenas um link para o arquivo idêntico anterior
que ele já havia armazenado.

Figura 2: controle de versão realizado pelo Git. Fonte: Primeiros passos - Noções Básicas de Git

5
2.2 Usuários da informação e suas necessidades de informação

Os principais usuários dessas informações são os desenvolvedores, que precisam

ter a versão mais atual dos códigos do programa para que desenvolvam seu trabalho de
forma eficiente. Do contrário, eles poderiam ter de lidar com erros que já tenham sido
solucionados ou mudanças implementadas por outra pessoa da equipe, e isso causaria
retrabalho.
Além dos desenvolvedores, que efetivamente constroem o produto - no caso, o
jogo - é possível identificar outros stakeholders, que, apesar de não consumirem essas
informações de forma direta, possuem interesse na operação como um todo. São eles:
gerentes que acompanham a evolução e trabalho do time de programadores, investidores
da empresa, o cliente final que aguarda pelo lançamento do produto, etc.

2.3 Fundamentação teórica do projeto

Segundo Konnorate et. al. (2019), “no desenvolvimento de um software, os

problemas mais recorrentes estão relacionados às atualizações do código”. Nesse
sentido, Palestino (2018) ressalta que “um sistema que contém apenas a função de
repositório de documentos não supre as necessidades da área de TI”, sendo
imprescindível que possuam, também, a função de versionamento. Ela explica,
ainda, que o objetivo do versionamento está “na organização de projetos por meio
do gerenciamento de diferentes versões de um documento”, destacando como
vantagens a possibilidade de “desenvolver [o software] paralelamente, acompanhar
o histórico de desenvolvimento e até resgatar o sistema em um ponto que estava
estável, isso sem mexer na versão principal”.
A partir dessa necessidade, surgiram diversos Sistemas de Controle de
Versão (SCVs) com a proposta de auxiliar na tarefa de versionamento. Aquiles
(2014) cita alguns exemplos de sistemas de controle de versão mais antigos: CVS,
ClearCase, Source-Safe e SVN. Com o tempo, contudo, o par Git/GitHub ganhou
dominância, e hoje é o padrão de referência em SCVs.
Palestino (2018) estabelece que “o Git é um programa de controle de
versões de documentos que possibilita trabalhar sempre em um mesmo diretório,
fazendo alterações em seu projeto, gravando documentação e comentários”. Vale

6
detalhar um pouco mais sobre como o Git opera, quais suas vantagens sobre os
concorrentes, e sobre como o versionamento é feito:
A maioria dos outros sistemas de controle de versão armazena
informação como uma lista de mudanças por arquivo, tratando as
informações e mantendo-as como um conjunto de arquivos e as
mudanças feitas a cada arquivo. Um grande diferencial do Git em
relação à maioria dos sistemas é que ele não armazena as informações
dessa forma, pois considera que os dados são como um conjunto de
snapshots de um mini-sistema de arquivos. Para isso, no Git há a
possibilidade de criar, a qualquer momento, vários snapshots (ou
“branch”. Espécie de “cópia espelho”. Captura de algo em um
determinado instante, como em uma foto) do projeto. Pode-se supor
que em um projeto de um sistema é preciso realizar determinada
alteração no código fonte, mas não é desejável que essa alteração não
esteja disponível para mais ninguém, a não ser somente para o
desenvolvedor responsável pela alteração, até que tudo esteja certo.
Então, o snapshot é uma boa solução para esse caso, pois o
desenvolvedor pode trabalhar nesse “espelho” até acertar todos os
detalhes do sistema e quando o mesmo estiver pronto, pode-se fazer
um merge para o projeto original. Cada vez que se salva (ação
conhecida tecnicamente como “commit”) um projeto, é como se ele
tirasse uma foto de todos os seus arquivos naquele momento e
armazenasse uma referência para essa captura. Se nenhum arquivo foi
alterado, a informação não é armazenada novamente. (PALESTINO,
2018)
O GitHub, por sua vez, é um local de armazenamento em nuvem dos
arquivos enviados via Git. A vantagem de seu uso se dá uma vez que, com ele, não
é necessário instalar o Git em diversos computadores para acessar determinado
arquivo, visto que é um serviço web. (PALESTINO, 2018)

7
 3. SOLUÇÃO DO PROBLEMA

3.1 Solução proposta

De forma a solucionar os problemas destacados no primeiro tópico deste trabalho,

consideramos a utilização de boas políticas de branches, baseadas no git flow. O git flow é um
modelo de desenvolvimento que pode ser seguido durante a implementação de um projeto, de
forma a organizar melhor os branches e, portanto, permitir uma melhor utilização do Git de
maneira geral.

Dessa forma, existe uma convenção de nomear os branches a partir de suas funções
dentro do desenvolvimento do software, assim como definir o que cada um desses tipos de
branches faz, como listado a seguir e ilustrado na imagem:

● Branch master/main: branch que contém o código que realiza as tarefas do software
em produção, ou seja, aquele programa que já está disponível para os clientes utilizarem.
● Branch feature: novos branches que são criados para o desenvolvimento de novos
recursos e que serão agrupados posteriormente ao branch master.
● Branch hotfix/ bugfix: são branches puxados a partir do branch master e que são usados
para a correção de erros existentes no código original.

8
3.2 Justificativa

A prática de ter uma boa organização de branches a partir de um modelo nos oferece
inúmeros benefícios, se tem uma separação melhor das funcionalidades de cada parte do
projeto. Isso facilita, por exemplo, a correção de futuros que possam existir dentro do produto,
pois a partir do momento em que existe uma independência, pelo menos no nível abstrato, de
cada parte do código, é possível focar na correção dessa funcionalidade sem se preocupar com a
interferência nas outras partes. Essa praticidade se torna útil também para utilizar ferramentas
que automatizam o processo de colocar o código em produção, como por exemplo a cultura de
DevOps, na qual não entraremos em detalhes aqui por não ser o foco deste trabalho.

Além disso, a aplicação dessa metodologia também permite uma melhor estruturação do
projeto. Com isso, conseguimos um maior valor semântico para a documentação do projeto e
maior facilidade de descrever as novas atualizações que são produzidas.

3.3 Recursos necessários

De certa forma, não precisamos de muitos recursos para a implementação desta solução.
O ponto mais importante para a efetivação dessa prática está em um bom conhecimento por
parte da equipe por trás do desenvolvimento do projeto em boas práticas de utilização do git,
como a política do git flow citado nos tópicos anteriores. Podemos alcançar uma boa
consistência dessas partes a partir da utilização de um padrão de software durante toda a
implementação do produto, garantindo que todos que estejam mexendo no produto se entendam
na forma de trabalhar.

3.4. Implementação e limitações da solução

A parte mais necessária na implementação dessa prática está na hora da modelagem do

projeto, antes mesmo de iniciá-lo. Bons modelos podem ser atingidos utilizando ferramentas
onlines disponíveis gratuitamente para a construção de imagens e fluxogramas que possibilitem
um bom entendimento das tarefas a serem realizadas durante o decorrer do fluxo de trabalho, e
que facilitem a organização das informações.

9
 Uma limitação a se evidenciar, devido à necessidade de se pensar nessa estruturação
antes de iniciar o projeto, é que esta prática não pode ser alcançada, ou talvez sim, mas com
muita dificuldade, em trabalhos que já estão em produção e, portanto, essa separação das
funcionalidades ser uma tarefa irrealista. Por isso, destaca-se mais uma vez a necessidade de
pensar em uma modelagem das informações, sendo que isso, na maioria dos casos, como
estamos tratando de softwares, se resume à modelagem do banco de dados, onde serão
armazenados as informações das diversas partes do projeto.

4. CONSIDERAÇÕES FINAIS

Com esta atividade prática foi possível evidenciar a importância de uma

estrutura de trabalho bem construída e planejada da maneira correta, para um fluxo
eficiente de tarefas em uma empresa. Uma vez que, apesar de não precisar de soluções
de alta complexidade, em muitos dos casos, esse aspecto parece ser deixado de lado
em muitas companhias.
A partir da nossa proposta de solução, é possível que a empresa tenha um
processo de desenvolvimento mais claro e limpo, o que auxiliará a equipe em
correções de possíveis erros que possam ser lançados. Dessa forma, será possível que
a empresa ganhe agilidade em seus processos de trabalho, proporcionando assim aos
clientes, uma experiência de maior qualidade.

REFERÊNCIAS BIBLIOGRÁFICAS

Caroline Konnorate, G., Colchete Iankoski, L., Pimentel de Andrade, V. e Padilha

Moreira, J. 2019. A IMPORTÂNCIA DO CONTROLE DE VERSÕES NO
DESENVOLVIMENTO DE SOFTWARE. SEMINÁRIO DE TECNOLOGIA GESTÃO
E EDUCAÇÃO. 1, 2 (out. 2019), 1-4.

Palestino, Caroline. ESTUDO DE TECNOLOGIAS DE CONTROLE DE VERSÕES

DE SOFTWARES. Curitiba, 2018. 36p. Monografia (Graduação em Gestão da
Informação) - Faculdade de Ciências Sociais Aplicadas, Universidade Federal do
Paraná.

10
AQUILES, Alexandre e Rodrigo Ferreira. Controlando Versões com GIT e GitHub. 1ª
Edição. São Paulo. Casa do Código. 2014
HADLER, Mikael. Utilizando o fluxo Git Flow. Disponível em:
https://medium.com/trainingcenter/utilizando-o-fluxo-git-flow-e63d5e0d5e04. Acesso em: 03
jul. 2022.

MOTA, Fernando Jorge. Git Flow: Uma forma legal de organizar repositórios git.
Disponível em: https://fjorgemota.com/git-flow-uma-forma-legal-de-organizar-repositorios-git/.
Acesso em: 03 jul. 2022.

Primeiros passos - Noções Básicas de Git. Disponível em: <https://git-scm.com/book/pt

-br/v1/Primeiros-passos-No%C3%A7%C3%B5es-B%C3%A1sicas-de-Git>. Acesso em: 03 jul.
2022

11