Project

General

Profile

Statistics
| Branch: | Revision:

automacao-labi / documento.tex @ f950c95b

History | View | Annotate | Download (18.8 KB)

1
\documentclass{report}
2
\usepackage[T1]{fontenc} % Fontes T1
3
\usepackage[utf8]{inputenc} % Input UTF8
4
\usepackage[backend=biber, style=ieee]{biblatex} % para usar bibliografia
5
\usepackage{csquotes}
6
\usepackage{blindtext} % Gerar texto automáticamente
7
\usepackage[printonlyused]{acronym}
8
\usepackage{hyperref} % para autoref
9
\usepackage{color}
10
\usepackage{acronym}
11
\usepackage{graphicx}
12
\usepackage{verbatim}
13
\setcounter{tocdepth}{3}
14
\setcounter{secnumdepth}{3}
15

    
16

    
17

    
18
\bibliography{bibliografia}
19

    
20

    
21
\begin{document}
22
%%
23
% Definições
24
%
25
\def\titulo{Ferramentas de automação}
26
\def\data{Entregue dia 29/11/2015}
27
\def\autores{Manuel Costa, Henrique Ferreira}
28
\def\autorescontactos{manuel.alejandro@ua.pt, henriqueferreira@ua.pt}
29
\def\versao{v1.0}
30
\def\departamento{DETI}
31
\def\logotipo{UA.jpg}
32
\def\uc{LABI}
33
\def\local{Aveiro}
34
%
35
%% CAPA %%
36
%
37
\begin{titlepage}
38

    
39
\begin{center}
40
%
41
\vspace*{50mm}
42
%
43
{\Huge \titulo}\\ 
44
{\Large \uc}\\
45
%
46
\vspace{10mm}
47
%
48
{\LARGE \autores}\\ 
49
%
50
\vspace{30mm}
51
\end{center}
52
%
53
\begin{flushright}
54
\end{flushright}
55
\end{titlepage}
56

    
57
%
58
%
59
%%  Página de Título %%
60
%
61
%
62
\title{%
63
{\Huge\textbf{\titulo}}\\
64
{\Large \departamento}
65
}
66
%
67
\author{%
68
    \autores \\
69
    \autorescontactos
70
}
71
%
72
\date{\data}\\
73
%
74
\maketitle
75

    
76
\pagenumbering{roman}
77

    
78
\tableofcontents
79

    
80

    
81
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
82
\clearpage
83
\pagenumbering{arabic}
84

    
85
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
86
\chapter{Resumo}
87

    
88
Este trabalho, no âmbito da Unidade Curricular \ac{LABI} do primeiro ano do \ac{miect}, aborda 3 ferramentas de automaçao de projectos, nomeadamente as \textit{GNU Autotools}, \textit{ANT Tools} e o \textit{CMake}. As 3 ferramentes são brevemente exploradas e analisadas, apresentando-se as suas vantagens e desvantagens em relação a outras ferramentas e ao âmbito do seu uso. São ainda apresentados alguns exemplos para cada ferramenta abordada neste trabalho. Comparamos também as \textit{ANT Tools} e o \textit{CMake} ao \textit{GNU Make} uma vez que foi a ferramente que exploramos na aula de \ac{LABI}.
89
Posteriormente apresentamos as nossas conclusões sobre o tema, Ferramentas de automação.
90

    
91
\chapter{Introdução}
92
\label{chap.introducao}
93

    
94
Este trabalho surge no âmbito da Unidade Curricular \ac{LABI} do primeiro ano do \ac{miect}. Entre os temas disponíveis, optámos por este uma vez que iremos abordar, ainda este ano, estes conteúdos em outras unidades curriculares. É também um tema com várias opiniões distintas na informática, portanto achamos interessante analisar algumas das ferramentas de automação existentas para melhor entendermos as várias ferramentas.
95

    
96
Este documento está dividido em quatro capítulos. Depois desta introdução, no \autoref{chap.gnu} são aboradas as \textit{GNU autotools}, no \autoref{chap.ant} são abordadas as ferramentas \textit{Ant}, no \autoref{chap.cmake} é abordado o \textit{CMake}.
97
\label{part.gnu}
98
\chapter{GNU}
99
\label{chap.gnu}
100
\section{Apresentação}
101
\subsection{O que é?}
102
\ac{GNU} é um sistema operacional tipo UNIX que está aberto a qualquer utilizador (\textit{open-source}) iniciado por Richard Stallman em 1984. O projecto foi crescendo e eventualmente surgiram novas ferramentas associadas como compiladores, editores de texto, etc.
103
\section{GNU Build System}
104
\label{s.gnubs}
105
Uma das ferramentas mais populares associadas ao projecto \ac{GNU} é o \textit{GNU Build System}. Também conhecido como \textit{Autotools}, são uma série de utencílios de programação que permite aos utilizadores transportar mais facilmente o seu código fonte para outros sistemas UNIX. O \ac{GNU} \textit{Autotools} faz parte de um outro projecto chamado \textit{\ac{GNU} Toolchain}. 
106
\subsection{GNU Make}
107
\label{ss.gnumake}
108
Para compreender melhor o que são e qual o potencial das \textit{Autotools}, temos que perceber o conceito duma outra ferramenta: o \textit{\ac{GNU} Make}.
109
\textit{Make} é um utilitário que compila automaticamente programas e bibliotecas do código fonte através de um ficheiro \textit{Makefile} que contém uma série de instruções dadas pelo utilizador. 
110
Se tivermos um projecto de grandes dimensões torna-se um desafio compilar todos os ficheiros manualmente. É um processo repetitivo e cansativo além de estar sujeito a condicionantes dos sistemas operativos. Por exemplo, compilar um determinado projecto pode requerer variáveis do sistema que,possivelmente, variam entre sistemas operativos. Desta forma, é muito mais prático e eficaz compilar o projecto através de um \textit{Makefile}.
111
\subsubsection{Exemplo}
112

    
113
\begin{verbatim}[h]
114
.PHONY: all clean cleanall
115
files =  *.class
116

    
117
all: $(files)
118

    
119
%.class: %.java
120
	@javac $^
121
	@echo "Compiling java files..."
122
clean: 
123
	@rm -f *.tmp *.java~
124
	@echo "Cleaning temporary files..."
125
cleanall: clean
126
	@rm -f *.class
127
	@echo "Cleaning .class files..."	
128
\end{verbatim}
129

    
130
Neste exemplo muito básico, podemos verificar que:
131
\begin{enumerate}
132
\item É possível declarar variáveis dentro de um \textit{Makefile} como fazemos,por exemplo,em JAVA. No nosso caso estámos a indicar que qualquer ficheiro do tipo .class fica armazenado na variável \textit{files}
133
\item Existem regras e dependências. Neste caso, para gerar qualquer ficheiro do tipo .class é preciso que existam ficheiros fonte .java.
134
\item As instruções são dadas por comandos \textit{bash} iguais aos que são utilizados no terminal. Neste caso, para um ficheiro qualquer .java vai ser gerado um ficheiro .class com o mesmo nome através da execução do comando javac. A instrução \textit{echo} funciona como um \textit{print} para saber que a instrução está a correr (opcional).
135
\item Além de comandos \textit{bash}, os \textit{Makefile} têm instruções e sintaxe própria como por exemplo \$, *. etc.
136
\end{enumerate}
137
As possibilidades são muito mais extensas podendo um \textit{Makefile} conter livrarias ou até métodos próprios.
138
\subsection{GNU Autotools}
139
\label{ss.gnuautotools}
140
Como referido em \autoref{ss.gnumake} o processo de compilar um projecto varia entre sistema operativos. Os compiladores de C são diferentes, assim como algumas livrarias podem não estar presentes em determinados sistemas entre outras dificuldades. Podemos, ainda assim, lidar com isto: código condicional. É possível que, ao compilar um projecto, seja feita uma verificação prévia de determinados pré-requisitos nos sistemas e, caso seja necessário, é também possível ajustar o Makefile para o sistema em que está a ser corrido. Este processo já requer a introdução a dois novos conceitos fundamentais:
141
\begin{enumerate}
142
\item \textit{Autoconf}
143
\item \textit{Automake}
144
\end{enumerate}
145
Existem, porém, mais conceitos associados mas para o nosso caso será suficiente explorar estes dois, como por exemplo \textit{Autoscan} ou \textit{Libtool}.
146
\subsubsection{\textit{Autoconf}}
147
\label{sss.autoconf}
148
Com base num ficheiro configure.ac (ac de auto-config) escrito pelo programador, \textit{autoconf} irá gerar um \textit{script} chamado \textit{configure}. Quando corremos esse \textit{script} é gerado um outro \textit{script} chamado config.status que transforma ficheiros .in (de input) em \textit{Makefiles}. De seguida, \textit{make} utiliza esses \textit{Makefiles} para gerar executáveis.
149
\subsubsection{\textit{Automake}}
150
\textit{Automake} recebe um ficheiro config.h.in e outro chamado \textit{Makefile.am} (am de \textit{auto-make}) e gera o \textit{Makefile.in} mencionado em \autoref{sss.autoconf}. O \textit{automake} também faz verificações a determinadas dependências (como por exemplo \textit{header files}). 
151
\subsubsection{Gerar \textit{Makefiles} utilizando \textit{Autotools}}
152
Em primeiro lugar, é necessário saber quais são os ficheiros que o programador vai modificar manualmente:
153
\begin{enumerate}
154
\item \textit{configure.ac}
155
\item \textit{Makefile.am}
156
\end{enumerate}
157
Correndo o \textit{autoscan} são gerados dois ficheiros: \textit{autoscan.log} e \textit{configure.scan}. Altera-se o nome do \textit{configure.scan} para \textit{configure.ac} e este será um dos ficheiros no qual o programador irá escrever. Alternativamente pode-se criar o ficheiro \textit{configure.ac}, fica a critério do programador. Neste ficheiro é possível, por exemplo, introduzir ordens através de macros para verificar a existência de determinado(s) programa(s) no sistema. A macro AC\textunderscore CHECK\textunderscore PROG(variável,programa,yes) irá verificar se existe o programa. Esse resultado irá ficar armazenado numa variável com o valor especificado. Isto é, AC\textunderscore CHECK\textunderscore PROG(JAVAEX,javac,yes) irá verificar se existe o Java no sistema, fica armazenado na variável JAVAEX e esta terá valor de yes(equivalente a true) caso exista. É possível inclusive criar uma condição (if) que irá correr determinados comandos caso a variável seja true ou false. Pode-se também verificar a versão do java para garantir que o programa corre com todas as suas funcionalidades, caso o Java esteja desatualizado pode até nem correr. Existem outras macros que analisam a existência de livrarias específicas no sistema. Se um programa precisa duma determinada livraria para correr certas texturas, então essa livraria tem que estar presente no sistema para compilar o projecto. Ainda no \textit{configure.ac} é indicado onde vão ser gerados os \textit{Makefiles} (em que diretórios/sub-diretórios). 
158
Tendo o \textit{configure.ac} criado e com as devidas instruções, criam-se o(s) ficheiro(s) \textit{Makefile.am}(am de \textit{auto-make}).
159
\begin{figure}[h]
160
\includegraphics[scale=0.5]{Imagem1.png}
161
\caption{Pasta com o projecto e os ficheiros configure.ac/Makefile.am}
162
\end{figure}
163
A pasta contém \textit{configure.ac} e \textit{Makefile.am}. Ainda assim é preciso criar o \textit{Makefile.am} em todos os diretórios (neste caso nos sub-diretórios src e doc). Executa-se \textit{automake} para gerar os ficheiros restantes e o \textit{script configure}já irá gerar ficheiros \textit{Makefile} mas que ainda não fazem praticamente nada pois não tem nenhuma indicação nos ficheiros \textit{Makefile.am}. Em cada um destes ficheiros é que serão indicadas as regras para quando forem solicitados, executar determinados comandos (como por exemplo javac).
164
\begin{figure}[h]
165
\includegraphics[scale=0.5]{Autotools.png}
166
\caption{Diagrama do funcionamento das \textit{Autotools}}
167
\end{figure}
168

    
169

    
170
%
171
%
172
%
173
%
174
%
175
%
176

    
177
\part{ANT Tools}
178
\label{part.ant}
179
\chapter{Apache Ant}
180
\label{chap.ant}
181
\section{Apresentação}
182
\subsection{O que é?}
183
Da mesma forma que \textit{developers} encontraram uma solução para automatizar os processos de compilação, outras alternativas foram surgindo que, à partida, se distinguem em determinadas áreas. São um exemplo as \textit{Apache Ant Tools}, que surgem enquadradas no projecto \textit{Apache Tomcat} em 2000. Criada por James Duncan Davidson, também autor do projecto \textit{Apache Tomcat}.
184

    
185

    
186
\section{Ant vs \textit{make} - Diferenças e similaridades}
187

    
188
É uma ferramenta também \textit{open-source} que serve para compilar projectos de programação. Como é natural, tem diferenças relativamente ao \textit{make}:
189
\begin{enumerate}
190
\item Apache Ant usa a linguagem Java e é especializada em compilar projectos em Java. 
191
\item Utiliza \textit{build files} em \textit{XML} nquanto que o \textit{make}, como descrito em \autoref{ss.gnumake}, depende dos \textit{Makefiles}. 
192
\item Para projectos Java, os \textit{Makefiles} não eram 100\% portáteis. Isto é, quando se mudava entre sistemas operativos, existiam alguns problemas trabalhosos de resolver. 
193
\item Os \textit{Makefiles} tinham problemas de compatibilidade com sistemas Windows enquanto que os \textit{build files} são mais independentes das plataformas.
194
\item Para projectos Java, os \textit{Makefiles} eram demasiado complexos. Como o \textit{Ant} é orientado a projectos Java, contém processos internos que libertam o programador para este não precisar de especificar tudo ao pormenor.
195
\end{enumerate}
196

    
197
\subsection{Contras à utilização do \textit{Ant}}
198
Como todas as ferramentas, o \textit{Ant} tem as suas próprias complicações. Uma delas é o facto de os \textit{build files} serem em \textit{XML}, que por si só tem uma complexa síntaxe que torna os ficheiros menos legíveis e compreensíveis. Apesar dos IDE's (como o Eclipse ou NetBeans) gerarem automaticamente os \textit{build files}, caso a versão do IDE mude ou se queira mudar de IDE, é conveniente para o programador criar o seu próprio \textit{build file}.	
199
\subsubsection{Exemplos}
200
\begin{figure}[h]
201
\includegraphics[scale=0.5]{ANT.png}
202
\caption{Exemplo de condicional utilizado num \textit{build file}}
203
\end{figure}
204
\begin{verbatim}[h]
205
$ cat > build.xml
206
<project default="hello">
207
  <target name="hello">
208
    <javac srcdir="."
209
           includeantruntime="false"
210
           destdir="."/>
211
  </target>
212
</project>
213

    
214
$ cat > Hello.java
215
public class Hello {
216
  public static void
217
  main(String[] args) {
218
    String msg = "Hello, World!";
219
    System.out.println(msg);
220
  }
221
}
222
\end{verbatim}
223
Da mesma forma que nos \textit{Makefiles}, existe um \textit{target} e uma instrução associada. Tem semelhanças ao uso do \LaTeX ou do \ac{HTML} na medida em que é indicado um \textit{begin} e um \textit{end} para cada \textit{target/project}, etc. 
224
É também vísivel a  possibilidade de programar utilizando a linguagem Java dentro dum ficheiro \textit{build.xml}.
225

    
226
\subsection{Conclusão - Ant}
227
Para lidar com projectos Java, o \textit{Ant build} é superior ao \textit{GNU make} mas, como em tudo na Informática, existe muito debate entre os programadores. Também parece ser mais fácil lidar com dependências entre sistemas operativos utilizando o \textit{Ant build} sempre que seja relativo a projectos Java.
228
Por outro lado, a síntaxe dos \textit{build files} é mais complexa e menos legível. Em projectos muito grandes isto pode ser um grande contra à utilização do \textit{Ant build}. 
229

    
230
%
231
%
232
%
233
%
234
\part{CMake}
235
\chapter{CMake}  %Explicar quem é o pessoal do cmake
236
\label{chap.cmake}
237
\section{Apresentação} %Pegar no cmake propriamente dito e por aí fora
238
\subsection{O que é?}
239

    
240
Outra alternativa às \textit{Apache Ant Tools} e o \textit{GNU Make}, é o \textit{CMake}, software open-source, que nasceu da necessidade de um sistema de compilaçao multiplataforma e o seu autor foi Bill Hoffman, da Kitware. O \textit{CMake} é usado em conjunto com a ferramente de compilação de cada sistema.
241
\section{Cmake vs GNU Make} % Comparar com enumerate
242

    
243
Também é uma ferramente open-source à semelhança do \textit{make}, mas obviamente têm as suas diferenças:
244
\begin{enumerate}
245
\item Nao compila o código, mas sim gera os \textit{build files} de acordo com a plataforma aonde está a correr, por exemplo, \textit{Makefiles} no \textit{UNIX}.
246
\item É uma ferramente mais apropriada a projectos multiplataforma, enquanto que no \textit{make} teriamos de criar um \textit{Makefile} por plataforma.
247
\item O \textit{CMake} consegue lidar bem com hierarquias de directórios complexas e aplicaçoes que dependem de várias librarias.
248
\item Requer menos código para tarefas mais triviais.
249
\end{enumerate}
250

    
251
\subsection{Contras à utilizaçao do \textit{CMake}}
252

    
253
Uma das maiores dificuldades na utilizaçao do \textit{CMake} é o facto de ter a sua própria linguagem, não tão intuitiva como outras ferramentas como por exemplo as \textit{AutoTools}. O facto do \textit{CMake} não compilar mas sim gerar os \textit{buildfiles} também pode ser visto como uma desvantagem uma vez que continuamos a ter de executar o comando make para compilar o projecto. É necessário ainda que o sistema aonde trabalhamos tenha o \textit{CMake} instalado.
254

    
255
\subsubsection{Exemplos} %Imagens exemplo a explicar a comparação feita antes
256
\begin{figure}[h]
257
\includegraphics[scale=0.5]{cmake.jpg}
258
\caption{Exemplo de código \textit{CMake}}
259
\end{figure}
260

    
261
O código compila o ficheiro HelloWorld.java num ficheiro HelloWord.jar e executa o .jar usando o JVM. A variável CMAKE\textunderscore JAVA\textunderscore COMPILE\textunderscore FLAGS pode ser usada para especificar \textit{compile flags}.
262

    
263
\subsection{Conclusão - CMake} %Conclusão do CMake comparado com GNU
264

    
265
Podemos concluir então que, apesar de ter a sua própria linguagem, não muito intuitiva, o CMake é uma ferramenta de extrema utilidade se prentendemos que o nosso projecto seja multiplataforma uma vez que se adapta ao sistema em que está e gera os \textit{build-files} necessários à compilaçao do projecto de acordo com o sistema aonde estamos a trabalhar.
266
%
267
\chapter{Metodologia}
268
\label{chap.metodologia}
269
A pesquisa baseou-se numa primeira fase em resolver exercício do guião para compreender melhor o que são ferramentas de automação. Ao mesmo tempo, foram adquiridos conhecimentos em duas ferramentas específicas: \ac{GNU} Make e \ac{GNU} auto-tools.
270
Foi frequente a utilização de fóruns informáticos e web-sites informativos.
271

    
272
\chapter{Conclusões}
273
\label{chap.conclusao}
274
Para automatizar o processo de compilação de projetos de programação, foram aparecendo ferramentas para rentabilizar tempo ao programador e para tornar a tarefa mais eficaz e menos suscetível a erros.
275
Neste trabalho são avaliadas duas ferramentas partindo como base de comparação o \ac{GNU} \textit{Make}: \textit{Ant} e \textit{CMake}. As três têm como principais objetivos:
276
\begin{enumerate}
277
\item Lidar com o repetitivo processo de compilação, ainda que cada uma delas tenha os seus próprios métodos.
278
\item Facilitar a portabilidade dos projetos entre Sistemas Operativos. Neste ponto depende muito do tipo de projeto, por exemplo num projeto em Java é mais eficaz a utilização do \textit{Ant}.  
279
\item Lidar com as dependências de cada projeto.
280
\end{enumerate}
281
Conclui-se que estas ferramentas são fundamentais na hora da realização de um projeto em programação. Elas são utilizadas pelos programadores desde muito cedo, ainda que estes não estejam conscientes disso graças aos IDE's que estão programados para lidar com este processo. Contudo programadores mais experientes recomendam que, em projetos mais elaborados, sejam os próprios a lidar com a compilação através destas ferramentas. 
282
Não existem apenas três ferramentas de automação pois para cada uma delas existem debilidades que,posteriormente, são melhoradas e que fomentam o aparecimento de novas ferramentas.
283

    
284
\chapter{Bibliografia}
285
\begin{enumerate}
286
\item \url{http://ant.apache.org}
287
\item \url{https://en.wikipedia.org/wiki/Ant}
288
\item \url{https://en.wikipedia.org/wiki/CMake}
289
\item \url{https://cmake.org}
290
\item \url{http://www.tutorialspoint.com/ant/ant_introduction.html}
291
\item Guião prático de LABI
292
\end{enumerate}
293
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
294
\chapter*{Acrónimos}
295
\begin{acronym}
296
\acro{ua}[UA]{Universidade de Aveiro}
297
\acro{miect}[MIECT]{Mestrado Integrado em Engenharia de Computadores e Telemática}
298
\acro{glisc}[GLISC]{Grey Literature International Steering Committee}
299
\acro{GNU}[GNU]{GNU's Not Unix!}
300
\acro{LABI}[LABI]{Laboratórios de Informática}
301
\acro{HTML}[HTML]{\textit{HyperText Markup Language}}
302
\end{acronym}
303

    
304

    
305

    
306
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
307
\printbibliography
308

    
309
\end{document}