Project

General

Profile

Statistics
| Branch: | Revision:

automacao-labi / documento.tex @ c912c63a

History | View | Annotate | Download (19.2 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
\part{GNU Build System}
98
\label{part.gnu}
99
\chapter{GNU}
100
\label{chap.gnu}
101
\section{Apresentação}
102
\subsection{O que é?}
103
\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.
104
\section{GNU Build System}
105
\label{s.gnubs}
106
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}. 
107
\subsection{GNU Make}
108
\label{ss.gnumake}
109
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}.
110
\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. 
111
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}.
112
\subsubsection{Exemplo}
113

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

    
118
all: $(files)
119

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

    
131
Neste exemplo muito básico, podemos verificar que:
132
\begin{enumerate}
133
\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}
134
\item Existem regras e dependências. Neste caso, para gerar qualquer ficheiro do tipo .class é preciso que existam ficheiros fonte .java.
135
\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).
136
\item Além de comandos \textit{bash}, os \textit{Makefile} têm instruções e sintaxe própria como por exemplo \$, *. etc.
137
\end{enumerate}
138
As possibilidades são muito mais extensas podendo um \textit{Makefile} conter livrarias ou até métodos próprios.
139
\subsection{GNU Autotools}
140
\label{ss.gnuautotools}
141
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:
142
\begin{enumerate}
143
\item \textit{Autoconf}
144
\item \textit{Automake}
145
\end{enumerate}
146
Existem, porém, mais conceitos associados mas para o nosso caso será suficiente explorar estes dois, como por exemplo \textit{Autoscan} ou \textit{Libtool}.
147
\subsubsection{\textit{Autoconf}}
148
\label{sss.autoconf}
149
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.
150
\subsubsection{\textit{Automake}}
151
\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}). 
152
\subsubsection{Gerar \textit{Makefiles} utilizando \textit{Autotools}}
153
Em primeiro lugar, é necessário saber quais são os ficheiros que o programador vai modificar manualmente:
154
\begin{enumerate}
155
\item \textit{configure.ac}
156
\item \textit{Makefile.am}
157
\end{enumerate}
158
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). 
159
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}).
160
\begin{figure}[h]
161
\includegraphics[scale=0.5]{Imagem1.png}
162
\caption{Pasta com o projecto e os ficheiros configure.ac/Makefile.am}
163
\end{figure}
164
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).
165
\begin{figure}[h]
166
\includegraphics[scale=0.5]{Autotools.png}
167
\caption{Diagrama do funcionamento das \textit{Autotools}}
168
\end{figure}
169

    
170

    
171
%
172
%
173
%
174
%
175
%
176
%
177

    
178
\part{ANT Tools}
179
\label{part.ant}
180
\chapter{Apache Ant}
181
\label{chap.ant}
182
\section{Apresentação}
183
\subsection{O que é?}
184
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}.
185

    
186

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

    
189
É uma ferramenta também \textit{open-source} que serve para compilar projectos de programação. Como é natural, tem diferenças relativamente ao \textit{make}:
190
\begin{enumerate}
191
\item Apache Ant usa a linguagem Java e é especializada em compilar projectos em Java. 
192
\item Utiliza \textit{build files} em \textit{XML} nquanto que o \textit{make}, como descrito em \autoref{ss.gnumake}, depende dos \textit{Makefiles}. 
193
\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. 
194
\item Os \textit{Makefiles} tinham problemas de compatibilidade com sistemas Windows enquanto que os \textit{build files} são mais independentes das plataformas.
195
\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.
196
\end{enumerate}
197

    
198
\subsection{Contras à utilização do \textit{Ant}}
199
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}.	
200
\subsubsection{Exemplos}
201
\begin{figure}[h]
202
\includegraphics[scale=0.5]{ANT.png}
203
\caption{Exemplo de condicional utilizado num \textit{build file}}
204
\end{figure}
205
\begin{verbatim}[h]
206
$ cat > build.xml
207
<project default="hello">
208
  <target name="hello">
209
    <javac srcdir="."
210
           includeantruntime="false"
211
           destdir="."/>
212
  </target>
213
</project>
214

    
215
$ cat > Hello.java
216
public class Hello {
217
  public static void
218
  main(String[] args) {
219
    String msg = "Hello, World!";
220
    System.out.println(msg);
221
  }
222
}
223
\end{verbatim}
224
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. 
225
É também vísivel a  possibilidade de programar utilizando a linguagem Java dentro dum ficheiro \textit{build.xml}.
226

    
227
\subsection{Conclusão - Ant}
228
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.
229
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}. 
230

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

    
242
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.
243
\section{Cmake vs GNU Make} % Comparar com enumerate
244

    
245
Também é uma ferramente open-source à semelhança do \textit{make}, mas obviamente têm as suas diferenças:
246
\begin{enumerate}
247
\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}.
248
\item É uma ferramente mais apropriada a projectos multiplataforma, enquanto que no \textit{make} teriamos de criar um \textit{Makefile} por plataforma.
249
\item O \textit{CMake} consegue lidar bem com hierarquias de directórios complexas e aplicaçoes que dependem de várias librarias.
250
\item Requer menos código para tarefas mais triviais.
251
\end{enumerate}
252

    
253
\subsection{Contras à utilizaçao do \textit{CMake}}
254

    
255
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.
256

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

    
263
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}.
264

    
265
\subsection{Conclusão - CMake} %Conclusão do CMake comparado com GNU
266

    
267
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.
268
%
269
\chapter{Metodologia}
270
\label{chap.metodologia}
271
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.
272
Foi frequente a utilização de fóruns informáticos e web-sites informativos.
273

    
274
\chapter{Conclusões}
275
\label{chap.conclusao}
276
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.
277
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:
278
\begin{enumerate}
279
\item Lidar com o repetitivo processo de compilação, ainda que cada uma delas tenha os seus próprios métodos.
280
\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}.  
281
\item Lidar com as dependências de cada projeto.
282
\end{enumerate}
283
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. 
284
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.
285

    
286
\chapter{Bibliografia}
287
\begin{enumerate}
288
\item \url{http://ant.apache.org}
289
\item \url{https://en.wikipedia.org/wiki/Ant}
290
\item \url{https://en.wikipedia.org/wiki/CMake}
291
\item \url{https://cmake.org}
292
\item \url{http://www.tutorialspoint.com/ant/ant_introduction.html}
293
\item Guião prático de LABI
294
\end{enumerate}
295
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
296
\chapter{Acrónimos}
297
\begin{acronym}
298
\acro{ua}[UA]{Universidade de Aveiro}
299
\acro{miect}[MIECT]{Mestrado Integrado em Engenharia de Computadores e Telemática}
300
\acro{glisc}[GLISC]{Grey Literature International Steering Committee}
301
\acro{GNU}[GNU]{GNU's Not Unix!}
302
\acro{LABI}[LABI]{Laboratórios de Informática}
303
\acro{HTML}[HTML]{\textit{HyperText Markup Language}}
304
\end{acronym}
305
\chapter{Contribuição dos Autores}
306
O trabalho foi dividido em três partes principais :  ,   e . 
307
\begin{enumerate}
308
\item \autoref{part.gnu} e \autoref{part.ant} que foram elaboradas por Manuel Costa.
309
\item \autoref{part.cmake} realizada por Henrique Ferreira.
310
\end{enumerate}
311
No restante relatório, os capítulos foram dívidos de forma igual. Cada elemento elaborou uma parte e analisou o trabalho do colega para aperfeiçoamento do mesmo.
312

    
313

    
314
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
315

    
316
\end{document}