<chapter id="unixdev">

<chapterinfo>
  <authorgroup>
    <author
><firstname
>Bernd</firstname
><surname
>Pol</surname
></author>
    <!-- ROLES_OF_TRANSLATORS -->
  </authorgroup>
</chapterinfo>

<title
>Desenvolvimento em &UNIX;</title>

<indexterm zone="unixdev"
><primary
>desenvolvimento</primary
></indexterm>
<indexterm zone="unixdev">
  <primary
>&UNIX;</primary>
  <secondary
>desenvolvimento</secondary
></indexterm>

<sect1 id="history">
<title
>Algumas Notas Históricas</title>

<indexterm zone="history"
><primary
>história</primary
></indexterm>
<indexterm zone="history"
><primary
>linguagens de 'scripting'</primary
></indexterm>
<indexterm zone="history">
  <primary
>&UNIX;</primary>
  <secondary
>história</secondary
></indexterm>
<indexterm zone="history">
  <primary
>&UNIX;</primary>
  <secondary
>'pipe'</secondary
></indexterm>
<indexterm zone="history">
  <primary
>&UNIX;</primary>
  <secondary
>linha de comandos</secondary
></indexterm>
<indexterm zone="history">
  <primary
>'shell'</primary>
  <secondary
>&UNIX;</secondary
></indexterm>

<para
>Desde o início, o &UNIX; tem mantido dois paradigmas de programação bastante diferentes. Um é o mundo das <emphasis
>linguagens de programação das aplicações e do sistema</emphasis
>, onde algum código-fonte é traduzido para código-máquina por um programa de tradução, normalmente um <emphasis
>compilador</emphasis
> ou um <emphasis
>interpretador</emphasis
>. A linguagem de programação C é um exemplo. O &UNIX; foi o primeiro 'kernel' de sistema operativos a ser criado numa dessas linguagens de alto nível, em vez de ser feito em Assembly altamente orientado à máquina, como era feito antes dessa altura. (De facto, a linguagem C foi mesmo inventada para escrever o 'kernel' do &UNIX; e os programas associados num computador PDP-11 da DEC.) </para>
<para
>O outro paradigma é o mundo das <emphasis
>linguagens de 'scripting'</emphasis
>. Este mundo evoluiu com a invenção da linha de comandos do &UNIX;, que era a interface do utilizador com o sistema operativo &mdash; e ao mesmo tempo uma linguagem de programação de muito alto nível. Um 'script' da linha de comandos é criado a partir de um conjunto de pequenos programas utilitários, como p.ex. o <command
>grep</command
>, o <command
>sed</command
> ou o <command
>find</command
>. Cada um desses utilitários é desenhado para uma tarefa estritamente definida. O truque é cada utilitário pode ser ligado a outro através de um mecanismo simples de transporte, chamado de <emphasis
>pipe</emphasis
>, o qual direcciona o resultado do utilitário anterior para o canal de introdução de dados do utilitário a seguir. Isto cria uma ferramenta de programação muito poderosa e altamente flexível. </para>
<para
>À medida que o tempo foi evoluindo, também ambos os mundos foram evoluindo. Embora o C ainda seja usado principalmente como uma linguagem de programação de sistemas, o C++, como uma variante do C, enriqueceu com extensões orientadas a objectos e com genericidade e encontrou o seu lugar para o desenvolvimento de aplicações complexas nos anos 90. Existem outras linguagens de programação diversas, e mesmo algumas linguagens mais antigas ainda têm lugar &mdash; o FORTRAN77 e o Ada p.ex. ainda têm a sua força nas aplicações numéricas. </para>
</sect1
> <!-- history -->

<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

<sect1 id="unixdev-scripting-languages">
<title
>Linguagens de 'Scripting' Contemporâneas</title>
<para
>Na área do 'scripting', houve um ligeiro desvio da linha de comandos, que sofre de problemas de portabilidade, para as linguagens que unificam todas as funcionalidades comuns necessárias para as suas bibliotecas-padrão, embora sejam à mesma capazes de interagir com o exterior através de 'pipes' se necessário. </para>
<para
>Todas essas linguagens de 'scripting' têm em comum o facto de serem altamente portáveis entre as variantes de &UNIX;, &Microsoft; &Windows;, &Mac; OS ou até mesmo o VMS. Do mesmo modo, todas elas têm implementações distribuídas de forma gratuita. </para>

<sect2 id="unixdev-SL-Perl">
<title
>&perl;</title>

<indexterm zone="unixdev-SL-Perl"
><primary
>Perl</primary
></indexterm>
<indexterm zone="unixdev-SL-Perl">
  <primary
>linguagens de 'scripting'</primary>
  <secondary
>Perl</secondary
></indexterm>

<para
>O <ulink url="http://www.perl.com"
>&perl;</ulink
> tornou-se popular como uma linguagem de processamento de texto e de administração de sistemas. No início da World Wide Web, os 'scripts' CGI escritos em &perl; eram uma forma usada em grande medida para criar páginas Web dinâmicas a partir de bases de dados. Hoje em dia, este método foi substituído em grande parte pelo 'plugin' <command
>mod_perl</command
> do servidor Web &apache;. Entre as potencialidades do &perl; encontra-se o seu suporte incorporado para correspondência de expressões regulares avançado e o seu arquivo rico de módulos distribuídos gratuitamente. </para>
<para
>Para mais informações veja o 'site' Web do <ulink url="http://cpan.org/"
>Comprehensive Perl Archive Network (CPAN)</ulink
>. </para>
</sect2
> <!-- unixdev-SL-Perl -->

<sect2 id="unixdev-SL-Python">
<title
>Python</title>

<indexterm zone="unixdev-SL-Python"
><primary
>Python</primary
></indexterm>
<indexterm zone="unixdev-SL-Python">
  <primary
>linguagens de 'scripting'</primary>
  <secondary
>Python</secondary
></indexterm>

<para
>O <ulink url="http://www.python.org"
>&python;</ulink
> brilha pela elegância do seu sistema de classes e pela facilidade e flexibilidade com que as bibliotecas externas conseguem ser incorporadas, de forma a aparecerem como classes e funções normais do &python;. Em contraste com o &perl;, o &python; tem uma API embebida clara e concisa, o que o torna a linguagem de escolha para tornar os programas em C ou C++ utilizáveis em 'scripts'. </para>
</sect2
> <!-- unixdev-SL-Python -->

<sect2 id="unixdev-SL-PHP">
<title
>PHP</title>

<indexterm zone="unixdev-SL-PHP"
><primary
>PHP</primary
></indexterm>
<indexterm zone="unixdev-SL-PHP">
  <primary
>linguagens de 'scripting'</primary>
  <secondary
>PHP</secondary
></indexterm>

<para
>O <ulink url="http://www.php.net"
>&php;</ulink
> foi inventado como uma linguagem directamente incorporada nas páginas HTML e, por consequência, tem as suas utilizações principais a distribuir conteúdo dinâmico na Web. </para>
</sect2
> <!-- unixdev-SL-PHP -->
</sect1
> <!-- unixdev-scripting-languages -->

<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
<sect1 id="unixdev-hl-script">
<title
>'Scripting' de Alto-Nível</title>

<para
>As aplicações de &UNIX; de alto-nível normalmente perdem a velocidade e flexibilidade dos mecanismos de 'scripting' da linha de comandos tradicional. Isto é especialmente verdadeiro no mundo das interfaces gráficas do utilizador (&GUI;) como &eg; o &kde;. </para>
<para
>Têm existido algumas tentativas de oferecer mecanismos semelhantes que irão funcionar num nível aplicacional mais elevado, como o <link linkend="unixdev-corba"
>CORBA</link
> e, no ambiente do &kde;, o <link linkend="unixdev-dcop"
>DCOP</link
>. </para>

<sect2 id="unixdev-corba">
<title
>O Protocolo CORBA</title>

<indexterm zone="unixdev-corba"
><primary
>CORBA</primary
></indexterm>
<indexterm zone="unixdev-corba">
  <primary
>linguagens de 'scripting'</primary>
  <secondary
>CORBA</secondary
></indexterm>
<indexterm zone="unixdev-corba">
  <primary
>comunicação</primary>
  <secondary
>CORBA</secondary
></indexterm>

<para
>O <ulink url="http://www.omg.org/gettingstarted/corbafaq.htm"
>CORBA</ulink
> (<emphasis
>Common Object Request Broker Architecture</emphasis
>) é uma tentativa para permitir as aplicações informáticas trabalharem em conjunto numa rede. Foi originada pelo comité normativo, privado e independente do distribuidor da <ulink url="http://www.omg.org"
>OMG</ulink
> (Object Management Group). </para>
<para
>Os programas baseados em CORBA usam o protocolo-padrão IIOP para comunicarem. As implementações baseadas no IIOP estão disponíveis num vasto conjunto de sistemas operativos, linguagens de programação e redes, sendo assim multi-plataforma. </para>
<para
>A desvantagem principal do CORBA é a sua velocidade relativamente baixo. Embora isto possa ser suportável em redes, é um grande entrave para as comunicações entre aplicações num ambiente sem rede, como por exemplo o &kde; a correr num único computador. </para>

</sect2
> <!-- unixdev-corba -->

<sect2 id="unixdev-dcop">
<title
>A Interface DCOP</title>

<indexterm zone="unixdev-dcop"
><primary
>DCOP</primary
></indexterm>
<indexterm zone="unixdev-dcop">
  <primary
>linguagens de 'scripting'</primary>
  <secondary
>DCOP</secondary
></indexterm>
<indexterm zone="unixdev-dcop">
  <primary
>comunicação</primary>
  <secondary
>DCOP</secondary
></indexterm>

<para
>Outra evolução do 'scripting' semelhante ao &UNIX; é o protocolo <ulink url="http://developer.kde.org/documentation/library/kdeqt/dcop.html"
><emphasis
>DCOP</emphasis
></ulink
>, o qual foi destinado à comunicação entre as aplicações do &kde; para ultrapassar as limitações do CORBA. </para>
<para
>O DCOP significa <emphasis
>Desktop COmmunikation Protocol</emphasis
> e está implementado como um mecanismo simples de IPC/RPC para operar sobre 'sockets'. De facto, isto fornece funcionalidades semelhantes às do mecanismo tradicional de 'pipes' do UNIX. </para>
<para
>O 'scripting' de linha de comandos tradicional é baseado em programas utilitários relativamente pequenos que foram desenhados para funcionarem de uma forma textual muito restrita. O DCOP permite aos programas gráficos elaborados comunicarem uns com os outros de uma forma muito semelhante. Isto permite p.ex. a um programa do &kde; enviar mensagens a outro programa do &kde; ou receber dados do mesmo para os seus objectivos próprios. </para>
<para
>Existem desvantagens, contudo. Para usar o DCOP um programa precisa de ser desenhado para conter uma interface DCOP especial. Para além disso, o processo de comunicação do DCOP corre de forma um pouco lenta. De qualquer forma, ele confere muito do poder e da flexibilidade do 'scripting' em &UNIX; para os programas de alto nível que se baseiam numa interface gráfica para o utilizador. </para>
<para
>Para mais informações, veja o artigo <ulink url="http://developer.kde.org/documentation/library/kdeqt/dcop.html"
>DCOP: Desktop COmmunications Protocol</ulink
> ou a referência da API da <ulink url="developer.kde.org/documentation/library/cvs-api/dcop/html/index.html"
>biblioteca do Desktop Communication Protocol DCOP</ulink
> para a biblioteca de DCOP do &kde;. </para>
</sect2
> <!--  unixdev-dcop -->

</sect1
> <!--  unixdev-hl-script -->

<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

<sect1 id="unixdev-buildsystems">
<title
>Sistemas de Compilação</title>

<para
>Excepto nos casos muito simples, o seu projecto irá consistir de um grande conjunto de blocos de construção de código-fonte, estando cada um deles colocado num ficheiro separado para uma manutenção mais simples. Para pôr isto a correr, você terá de traduzir efectivamente todas estas coisas em algumas unidades de linguagem da máquina, num formato adequado que permita ao sistema operativo carregar e executar o programa. </para>
<para
>Para conseguir isto, as ferramentas básicas que necessárias são <itemizedlist>
  <listitem
><para
>um <emphasis
>editor de texto</emphasis
> para escrever os ficheiros de código-fonte, </para
></listitem>
  <listitem
><para
>um programa de tradução, normalmente um <emphasis
>compilador</emphasis
> para transformar o código-fonte em ficheiros-objecto, </para
></listitem>
  <listitem
><para
>um <emphasis
>criador de bibliotecas</emphasis
> que junta os ficheiros-objecto em bibliotecas, para os poder reutilizar facilmente sem ter de os recompilar. </para
></listitem>
  <listitem
><para
>um <emphasis
>editor de ligações</emphasis
> que junta os vários ficheiros-objecto e bibliotecas todos num único executável, </para
></listitem>
  <listitem
><para
>um <emphasis
>sistema de compilação</emphasis
> que forneça alguns meios de gerir todas estas coisas e &mdash; não esquecer </para
></listitem>
  <listitem
><para
>um <emphasis
>depurador</emphasis
> para (assim se espera) poder encontrar todos os erros no programa e possivelmente algumas outras ferramentas de diagnóstico para ter tudo a correr sem problemas. </para
></listitem>
</itemizedlist>
</para>

<para
>Quando você tem um projecto grande que consiste possivelmente em centenas de ficheiros de código-fonte, o processo de compilação pode-se tornar bastante trabalhoso. Você não irá querer recompilar todos os ficheiros de cada vez que você tenha alterado apenas alguns deles. Em vez disso, você só deseja compilar aqueles ficheiros que são afectados pelas modificações. De um mode geral, não é óbvio saber quais é que são. </para>
<para
>Quando você &eg; mudar o protótipo de uma função num ficheiro de inclusão, você terá de compilar todos os ficheiros que incluam este. Se o seu projecto contivre assim tantos ficheiros, você poder-se-á esquecer de um ou dois deles, se tiver de fazer esse trabalho manualmente. Como tal, é necessária alguma forma de automatização. </para>

<sect2 id="unixdev-buildsystems-make">
<title
>O Processo Make</title>

<indexterm zone="unixdev-buildsystems-make">
  <primary
>make</primary
></indexterm>
<indexterm zone="unixdev-buildsystems-make">
  <primary
>Makefile</primary
></indexterm>
<indexterm zone="unixdev-buildsystems-make">
  <primary
>regra</primary
></indexterm>
<indexterm zone="unixdev-buildsystems-make">
  <primary
>recompilações</primary
></indexterm>
<indexterm zone="unixdev-buildsystems-make">
  <primary
>alvo</primary
></indexterm>
<indexterm zone="unixdev-buildsystems-make">
  <primary
>dependências</primary
></indexterm>
<indexterm zone="unixdev-buildsystems-make">
  <primary
>comandos</primary
></indexterm>

<para
>Uma ferramenta que toma conta das recompilações é o <command
>make</command
>. Ele mantém um registo de todo o trabalho, usando um conjunto de <emphasis
>regras</emphasis
> que descrevem o que fazer no caso de algum pedaço de informação (normalmente um ficheiro de código ou um ficheiro-objecto) ser alterado. Todas as regras que pertencem a um dado projecto são guardadas num ficheiro chamado <filename
>Makefile</filename
> que é processado pelo <command
>make</command
> de cada vez que você deseja actualizar o seu trabalho. </para>
<para
>Cada regra consiste em vários blocos de construção, nomeadamente <itemizedlist>
  <listitem
><para
>um <emphasis
>alvo</emphasis
>, ou seja, o ficheiro a ser criado </para
></listitem>
  <listitem
><para
>um conjunto de <emphasis
>dependências</emphasis
>, basicamente os nomes daqueles ficheiros de que o alvo depende (&eg;, o nome de um ficheiro de código, onde então o alvo será o nome do ficheiro-objecto a ser criado) e </para
></listitem>
  <listitem
><para
>os <emphasis
>comandos</emphasis
> que serão executados para <quote
>criar</quote
> o alvo (&ie;, para o compilar ou para ligar outros ficheiros-objecto em conjunto para formar um programa executável). </para
></listitem>
</itemizedlist>
</para>
<para
>Basicamente, o comando <command
>make</command
> irá ler as regras uma a seguir à outra, verificar cada ficheiro na lista de dependências de um determinado alvo e criar esse alvo de novo, se algum destes ficheiros foi alterado, usando os comandos indicados na regra. </para>
<para
>Existem várias possibilidades adicionais para controlar um processo do 'make' e, deste modo, uma <filename
>Makefile</filename
> poderá deste modo ficar bastante complexa. Não poderemos entrar em detalhes aqui. Contudo, recomendamos que você se vá acostumando à sintaxe do <command
>make</command
>. Mesmo que você não o use directamente, a compreensão dos fundamentos do sistema de compilação poderá ser útil. Veja o <ulink url="info://make/Top"
> <quote
>Manual do Make da GNU</quote
></ulink
> para mais informações. </para>
<para
>Para mais detalhes específicos do &kdevelop;, veja o capítulo sobre a <link linkend="project-management"
>Gestão de Projectos e Compilações</link
> deste manual. </para>
<para
>Existem vários tutoriais disponíveis; veja as <link linkend="automake-references"
>referências</link
> no capítulo sobre gestão dos projectos e das compilações. </para>
</sect2
> <!-- unixdev-buildsystems-make -->

</sect1
> <!-- unixdev-buildsystems -->

<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

<sect1 id="unixdev-guidevelopment">
<title
>Desenvolvimento de &GUI;s</title>

<indexterm zone="unixdev-guidevelopment">
  <primary
>GUI</primary
></indexterm>
<indexterm zone="unixdev-guidevelopment">
  <primary
>interface gráfica do utilizador</primary
></indexterm>
<indexterm zone="unixdev-guidevelopment">
  <primary
>interface do utilizador</primary>
  <secondary
>GUI</secondary
></indexterm>

<para
>Os programadores de aplicações estão incumbidos normalmente em ter não só de criar as bibliotecas e a lógica dos programas, mas também em fornecer interfaces de utilizador que sejam tanto intuitivas como funcionais. A maioria dos programadores recebem pouca ou nenhuma formação na programação de GUIs e, como tal, as interfaces do utilizador resultantes poderão ficar mal desenhadas. </para>
<para
>Ao longo dos anos, alguns princípios de desenho foram evoluindo. É altamente recomendado que adira a eles. Desta forma, as suas interfaces de utilizador irão reter uma aparência e comportamento comuns, factores que os utilizadores da sua aplicação irão agradecer. </para>
<para
>Para a programação de &GUI;s no &kde;, existe um guia de estilo disponível. Ele está nas <ulink url="http://developer.kde.org/documentation/standards/kde/style/basics/index.html"
>Linhas-Guia de Interfaces do Utilizador do &kde;</ulink
> na página dos programadores do &kde;. </para>
<para
>Poderá ser encontrada uma breve introdução aos princípios de desenho de interfaces <ulink url="http://axp16.iie.org.mx/Monitor/v01n03/ar_ihc2.htm"
>aqui</ulink
>. </para>

</sect1
> <!-- unixdev-guidevelopment -->

<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

<sect1 id="unixdev-ide">
<title
>Integrar os Conceitos e as Ferramentas &ndash; o IDE</title>

<indexterm zone="unixdev-ide">
  <primary
>IDE</primary
></indexterm>
<indexterm zone="unixdev-ide">
  <primary
>ambiente integrado de desenvolvimento</primary
></indexterm>
<indexterm zone="unixdev-ide">
  <primary
>desenvolvimento</primary>
  <secondary
>IDE</secondary
></indexterm>
<indexterm zone="unixdev-ide">
  <primary
>ambiente</primary>
  <secondary
>IDE</secondary
></indexterm>

<para
>Existem várias ferramentas separadas disponíveis para quase todos os passos do processo de programação &mdash; planeamento, edição, gestão de ficheiros e processos de compilação, depuração, documentação, entre muitas outras coisas. Mas, logo que os projectos cresçam, o processo de programação tornar-se-ão bastante complicados. </para>
<para
>Muito do trabalho repetitivo tem de ser feito ao desenhar, compilar e depurar um programa. Muito do trabalho pode-se poupar através do uso de modelos e 'scripts'. O restante é feito mantendo, de forma simples, as ferramentas disponíveis facilmente e com capacidades de comunicarem umas com as outras através de uma &GUI; comum. </para>
<para
>Por exemplo&mdash;não seria conveniente que um depurador fosse capaz de abrir o ficheiro de código em questão num editor e colocasse o cursor directamente sobre a posição do erro que foi encontrado? </para>
<para
>Para conseguir um esquema desses mais facilmente, os <emphasis
>Ambientes de Desenvolvimento Integrados</emphasis
> (IDE) foram criados. Um IDE desse género integra todos os modelos, ferramentas e programas necessários no processo de desenvolvimento num único ambiente. </para>
<para
>Para a plataforma do &kde;, o &kdevelop; é desses IDEs. Ele contém um conjunto vasto de ferramentas que facilitam o desenvolvimento e manutenção dos programas, mesmo para as diferentes linguagens de programação e pelas várias plataformas. </para>

<sect2 id="unixdev-ide-kdevelop">
<title
>Funcionalidades Básicas do &kdevelop; &kdevrelease;</title>

<indexterm zone="unixdev-ide-kdevelop">
  <primary
>&kdevelop;</primary>
  <secondary
>funcionalidades</secondary
></indexterm>
<indexterm zone="unixdev-ide-kdevelop">
  <primary
>funcionalidades</primary
></indexterm>

<!-- ### copied from web page, needs to be updated -->

<itemizedlist>
  <listitem>
  <para
>Gere todas as <emphasis
>ferramentas de desenvolvimento</emphasis
> necessárias para a programação em C++, como o compilador, o editor de ligações, o depurador e o sistema de compilações.</para>
  </listitem>
  <listitem>
  <para
>Contém um <emphasis
>&appwizard;</emphasis
> que gera aplicações completas e prontas a funcionar.</para>
  </listitem>
  <listitem>
  <para
>Permite ao utilizador seleccionar um <emphasis
>editor integrado</emphasis
>, baseado no editor do programador KWrite ou no QEditor da Trolltech ou noutro qualquer.</para>
  </listitem>
  <listitem>
  <para
>Um <emphasis
>gerador de classes</emphasis
>, para poder criar classes novas e integrá-las no projecto actual.</para>
  </listitem>
  <listitem>
  <para
><emphasis
>Gestão de ficheiros</emphasis
> para o código, os ficheiros de inclusão, documentação, etc., a incluir no projecto.</para>
  </listitem>
  <listitem>
  <para
>A assistência na <emphasis
>criação de manuais do utilizador da aplicação</emphasis
>, feitos com as ferramentas do KDE.</para>
  </listitem>
  <listitem>
  <para
><emphasis
>Documentação da API</emphasis
> automática e baseada em HTML para as classes de um projecto com referências cruzadas para as bibliotecas utilizadas.</para>
  </listitem>
  <listitem>
  <para
><emphasis
>Suporte para internacionalização</emphasis
>, o que permite aos tradutores adicionarem a sua língua-alvo a um projecto com facilidade, incluindo o suporte para o KBabel.</para>
  </listitem>
  <listitem>
  <para
>O suporte para a gestão de um projecto através de um de vários <emphasis
>sistemas de controlo de versões</emphasis
>, fornecendo uma interface simples de utilizar para as funções mais necessárias.</para>
  </listitem>
  <listitem>
  <para
>Uma interface para um <emphasis
>depurador</emphasis
> integrado.</para>
  </listitem>
  <listitem>
  <para
>Um emulador da <emphasis
>consola de texto</emphasis
>.</para>
  </listitem>
  <listitem>
  <para
><emphasis
>Realce de sintaxe</emphasis
> nos ficheiros de código.</para>
  </listitem>
  <listitem>
  <para
><emphasis
>Completação automática de código</emphasis
> para as variáveis das classes, os métodos das mesmas, os argumentos das funções, entre outras coisas.</para>
  </listitem>
  <listitem>
  <para
><emphasis
>Modelos para criar vários projectos</emphasis
> (módulos do KControl, 'applets' do Kicker (painel), KIOSlaves, 'plugins' do Konqueror e estilos do ecrã).</para>
  </listitem>
  <listitem>
  <para
>Quatro <emphasis
>janelas de navegação em árvore</emphasis
> para mudar facilmente entre ficheiros de código, ficheiros de inclusão, classes e documentação, eliminando a necessidade de um gestor de ficheiros externo.</para>
  </listitem>
  <listitem>
  <para
><emphasis
>Suporte para compilações cruzadas</emphasis
>, com a possibilidade de indicar vários compiladores diferentes, opções de compilação, arquitecturas-alvo, &etc;</para>
  </listitem>
  <listitem>
  <para
>Suporte para <emphasis
>projectos do Qt/Embedded</emphasis
> (como o Zaurus e o iPAQ).</para>
  </listitem>
  <listitem>
  <para
><emphasis
>Inclusão de vários programas</emphasis
> que necessite para programar, adicionando-os ao menu <guimenuitem
>Ferramentas</guimenuitem
>, de acordo com as suas necessidades individuais.</para>
  </listitem>
</itemizedlist>

</sect2
> <!-- unixdev-ide-kdevelop -->

</sect1
> <!-- unixdev-ide -->

</chapter
> <!-- unixdev -->

