ESCOLA SUPERIOR ABERTA DO BRASIL - ESAB

PÓS-GRADUAÇÃO EM ENGENHARIA DE SISTEMAS

MÁRCIO HENRIQUE DA SILVA

ASPECTOS IMPORTANTES NA ESCOLHA DE UMA LINGUAGEM DE

PROGRAMAÇÃO E FERRAMENTAS DE DESENVOLVIMENTO

VILA VELHA-ES
2008
 MÁRCIO HENRIQUE DA SILVA

ASPECTOS IMPORTANTES NA ESCOLHA DE UMA LINGUAGEM DE

PROGRAMAÇÃO E FERRAMENTAS DE DESENVOLVIMENTO

Monografia apresentada à ESAB - Escola

Superior Aberta do Brasil, sob orientação do
Professor Dr. Jaime Roy Doxey para
obtenção do título de Pós-Graduação em
Engenharia de Sistemas.

VILA VELHA-ES
2008
 MARCIO HENRIQUE DA SILVA

ASPECTOS IMPORTANTES NA ESCOLHA DE UMA LINGUAGEM DE

PROGRAMAÇÃO E FERRAMENTAS DE DESENVOLVIMENTO

Aprovada em 08 de março de 2008.

___________________________

___________________________

___________________________

VILA VELHA-ES
2008
Dedico este trabalho a minha família, aos
amigos e colegas de profissão que
colaboraram com a pesquisa.
AGRADECIMENTOS
Agradeço a DEUS, aos profissionais que
responderam o questionário, aos amigos que
ajudaram a encontrar literaturas sobre o
assunto, à minha família pela paciência e
minha mãe por tudo.
“Um relato honesto se desenrola melhor
se o fazem sem rodeios.”
(Shakespeare)
 RESUMO

Escolher uma linguagem de programação é uma tarefa árdua. Aspectos como as

características psicológicas da linguagem que influenciam na sua aprendizagem e
outras características como portabilidade, produtividade e manutenibilidade são
essenciais para garantir qualidade e conquistar mercado. Quanto às ferramentas de
apoio ao desenvolvimento é importante conhecê-las bem, para selecionar a
tecnologia adequada ao perfil do ambiente de desenvolvimento. Neste documento
são caracterizadas três categorias de ambiente de desenvolvimento:
desenvolvedores autônomos, desenvolvimento in-house e fábricas de softwares,
além de uma classificação dos softwares produzidos para diferenciá-los quanto ao
custo, recursos tecnológicos, nível intelectual e concorrência. Estes e outros
conceitos associados a uma pesquisa de campo com profissionais de
desenvolvimento, fazem deste trabalho um instrumento para nortear uma escolha
consciente e aproveitar com maior eficiência as metodologias criadas pela indústria
de software para desenvolvimento. Não se trata de um indicativo de melhores
linguagens ou ferramentas, mas um conjunto de conceitos essenciais para se fazer
uma escolha técnica e imparcial.
 ABSTRACT

Choose a programming language is a hard task. Issues like the psychological

characteristics that influence the language in their learning and other features like
portability, maintainability and productivity are essential to ensure quality and gain
market. About tools of development support, is important to select the appropriate
technology to profile the environment of development. In this document are
characterized three categories of environment for development: Freelance software
developers, in-house development and software factories, and a ranking of software
produced to distinguish between them as to cost, technological resources, intellectual
level and competition. These and other concepts associated with a research with
professional development, make this work a tool to guide a conscious and more
efficiently choice to use the methodologies created by the software industry for
development. This is not an indication of improved languages or tools, but a set of
concepts essential to make a technical choice and impartial.
 LISTA DE GRÁFICOS

Gráfico 1 - Evolução das linguagens.......................................................... 20

Gráfico 2 – Perfil dos profissionais entrevistados ...................................... 42
Gráfico 3 – Linguagens escolhidas............................................................. 43
Gráfico 4 – Critérios decisivos de escolha de linguagens e ferramentas . 44
Gráfico 5 – Classificação dos aspectos mais importantes ........................ 44
 Sumário

I. LINGUAGENS DE PROGRAMAÇÃO...................................................................16
1.1. COMO FUNCIONAM AS LINGUAGENS ......................................................16
1.1.1. Código fonte ............................................................................................16
1.1.2. Processos de tradução ...........................................................................17
1.2. CLASSIFICAÇÃO DAS LINGUAGENS .........................................................17
1.3. HISTÓRICO DAS LINGUAGENS ..................................................................18
1.4. PARADIGMAS DE PROGRAMAÇÃO ...........................................................21
1.4.1. Imperativo................................................................................................21
1.4.2. Orientação a objetos ...............................................................................21
1.4.3. Orientação a aspecto ..............................................................................22
1.4.4. Funcional .................................................................................................22
1.4.5. Lógico ......................................................................................................23
1.5. TENDÊNCIAS DAS LINGUAGENS...............................................................23
1.6. ASPECTOS PARA AVALIAÇÃO DE UMA LINGUAGEM.............................24
1.6.1. Uniformidade ...........................................................................................24
1.6.2. Ambigüidade ...........................................................................................24
1.6.3. Concisão..................................................................................................24
1.6.4. Localidade ...............................................................................................25
1.6.5. Linearidade..............................................................................................25
1.6.6. Manutenibilidade .....................................................................................25
1.6.7. Modularidade...........................................................................................26
1.6.8. Independência modular ..........................................................................26
1.6.9. Legibilidade .............................................................................................26
1.6.10. Simplicidade ........................................................................................27
1.6.11. Ortogonalidade ....................................................................................27
1.6.12. Confiabilidade ......................................................................................28
1.6.13. Portabilidade........................................................................................28
1.6.14. Tipologia de dados ..............................................................................28
 1.6.15. Documentação do código ...................................................................29
1.6.16. Eficiência..............................................................................................30
II. FERRAMENTAS DE DESENVOLVIMENTO........................................................32
2.1. CASE ..............................................................................................................32
2.2. CONTROLE DE QUALIDADE .......................................................................33
III. AMBIENTES DE DESENVOLVIMENTO...........................................................36
3.1. DESENVOLVEDOR AUTÔNOMO ................................................................36
3.2. DESENVOLVIMENTO IN-HOUSE ................................................................37
3.3. EMPRESAS ESPECIALIZADAS EM DESENVOLVIMENTO .......................37
IV. PESQUISA .........................................................................................................40
4.1. METODOLOGIA .............................................................................................40
4.2. ANÁLISE DA PESQUISA...............................................................................42
4.3. SÍNTESE.........................................................................................................45
V. CONCLUSÃO ........................................................................................................47
VI. REFERÊNCIAS BIBLIOGRÁFICAS ..................................................................49
 12

INTRODUÇÃO

Diante da grande diversidade de linguagens e ferramentas, evolução tecnológica,

expansão da mobilidade, universalização de ambientes operacionais e exigência de
qualidade, escolher uma linguagem de programação tornou-se uma tarefa difícil.
Muitas vezes sua importância é ignorada e as escolhas são baseadas no empirismo.
Este trabalho visa apresentar conceitos que podem auxiliar na escolha com
parâmetros indispensáveis para garantir uma tomada de decisão mais consciente.

O principal objetivo deste trabalho é identificar os aspectos relevantes à escolha da

linguagem de programação e as ferramentas que auxiliam no desenvolvimento de
softwares levando em consideração alguns cenários típicos de empresas e
profissionais da área de desenvolvimento.

São apresentados conceitos sobre o funcionamento das linguagens, paradigmas de

programação, tendências e aspectos das linguagens. Também serão classificados
os principais cenários de desenvolvimento, destacando suas características mais
marcantes e as categorias de software que produzem.

São apresentados indicadores de uma pesquisa de campo com profissionais da área

de desenvolvimento sobre os critérios que consideram nas suas escolhas, bem
como, as linguagens e ferramentas que utilizam.

O produto final deste trabalho se resume em reunir fontes básicas de informações

relevantes para garantir que a escolha de uma linguagem ou ferramenta de
desenvolvimento seja coerente com as necessidades de sua aplicação. E visa ainda,
apresentar os aspectos considerados importantes por profissionais da área de
desenvolvimento, em diferentes cenários para servir de referencial para novos
profissionais ou estudantes.

Este trabalho não irá apresentar nomes de linguagens ou ferramentas que devem
ser selecionadas para esta ou aquela necessidade. O propósito é alertar para os
 13

conceitos que devem ser levados em conta, considerando que a escolha irá
depender de muitas variáveis.

Quanto à pesquisa, não visa apontar a solução mais usada, mas um estudo de caso
dos aspectos que são tratados pelos profissionais como mais importantes.
 14

JUSTIFICATIVA

Embora existam muitos trabalhos apresentando conceitos que envolvem

características das linguagens e ferramentas de desenvolvimento, são poucos
aqueles que o fazem por completo e sem direcionar para uma escolha específica.
Certamente porque na prática não é fácil encontrar profissionais que
experimentaram todas as principais opções disponíveis e pelo fato de serem poucas
as pesquisas voltadas para a melhor escola. Muitas vezes as escolhas são feitas ao
acaso, outras vezes dentro de uma condição específica o bastante para se descartar
aspectos fundamentais.

Há ainda que se considerar fatores psicológicos das linguagens, mercado e

cenários. Mas todo o cuidado é pouco quando se indaga alguém sobre os motivos
que o levaram a escolher certa linguagem ou ferramenta. Sua resposta pode ser
muito pessoal ou condicionada a uma situação específica.

Popularmente, é comum de se ouvir: “A melhor linguagem que existe é aquela que

você domina”. Mas esta resposta pouco sustenta uma escolha envolvida com um
grande projeto. Há ainda que se considerar a dificuldade dos estudantes que não
dominam nenhuma linguagem e precisam fazer escolhas que podem definir suas
ferramentas para vários anos de dedicação, já que não se domina uma linguagem
do dia para a noite.

Este trabalho é uma resposta à escassez de conteúdos científicos sobre o assunto,

uma vez que sintetiza conceitos, relaciona cenários e pesquisa de campo. Servirá
como passo inicial de um trabalho ainda mais amplo no sentido de estabelecer um
padrão que reúna informações importantes de serem analisadas em uma escolha
tão complexa.
 15

PROBLEMATIZAÇÃO

Escolher uma linguagem de programação pode ser considerado uma tarefa

complicada até mesmo para desenvolvedores experientes. Não basta ter em mãos a
lista das linguagens mais vendidas, mais usadas ou que mais aparecem nos sites de
busca. Existem muitos aspectos a serem considerados. Mas quais aspectos são
mais importantes? Há uma linguagem ideal para todas as situações? Quais os
cenários de desenvolvimento de softwares são mais comuns? Na prática, o que
condicionou os profissionais deste seguimento a escolherem as linguagens que
utilizam hoje?

Estas perguntas precisam ser respondidas à sombra de um referencial teórico de

credibilidade e imparcialidade.

A proposta deste trabalho é levantar os aspectos primordiais, dentro de cenários

típicos que precisam ser analisados quando se pretende fazer uma boa escolha de
linguagens e ferramentas de desenvolvimento sem indicar nomes, marcas ou
experiências.
 16

I. LINGUAGENS DE PROGRAMAÇÃO

As linguagens de programação surgiram para facilitar a comunicação entre as

máquinas e os homens, uma vez que as máquinas entendem apenas uma
linguagem própria, denominada linguagem de máquina ou binária, formada por 0 e
1. Existe um conjunto de regras semânticas e sintáticas que devem ser seguidas
para produzir uma seqüência de instruções válidas para a execução do computador.
Segundo a definição de Pressman (1995, p. 677), “As linguagens de programação
são veículos de comunicação entre os seres humanos e os computadores”.

1.1. COMO FUNCIONAM AS LINGUAGENS

Price (2001) esclarece que os programas são escritos em linguagem próximas à

linguagem humana e depois são traduzidos para a linguagem de máquina. Este
processo é realizado através de sistemas especializados – compiladores ou
interpretadores – que entendem uma representação textual para solução de um
problema, denominado código fonte, e geram uma outra linguagem denominada
objeto.

1.1.1. Código fonte

A maneira mais fácil de gerar instruções exeqüíveis por um computador é utilizar

instruções de alto nível, ou seja, mais próximas da linguagem humana. Estas
instruções precisam seguir regras semânticas e sintáticas específicas para o tradutor
que será utilizado. Este conjunto de instruções que compreende arquivos de texto,
bibliotecas, parâmetros de tela e formatação de dados e rótulos compõe o código
fonte do programa.

Exemplo de programação em Java:

class AloMundo {
public static void main (String args[]) {
System.out.println("Exemplo de programa em Java");
 17

System.out.println("Esab - 2008");

}
}

1.1.2. Processos de tradução

A geração de um programa de computador é realizada sempre com o uso de um

tradutor, que recebe um código fonte e gera um código objeto ou um código
exeqüível por um interpretador.

Tradutor, no contexto de linguagem de programação, é um sistema que

aceita como entrada um programa escrito em uma linguagem (linguagem
fonte) e produz como resultado um programa equivalente em outra
linguagem (linguagem objeto) (PRICE, 2001, p. 4).

Price (2001) classifica os tradutores assim:

Montadores: Mapeiam cada uma das instruções simbólicas em uma instrução de

máquina.

Macro-assemblers: Traduzem um comando de macro (linguagem mnemônica) para

uma seqüência de comandos simbólicos a fim de que estes sejam traduzidos para
linguagem de máquina.

Compiladores: Mapeiam programas inteiros (não apenas algumas instruções)

escritos em linguagem de alto nível para linguagem simbólica ou de máquina,
denominado programa objeto, para ser executado mais tarde.

Pré-compiladores: Servem para traduzir instruções em linguagem de alto nível para

instruções em linguagem de alto nível, aprimorando sua escrita para serem
submetidas a um interpretador ou compilador.

Interpretadores: Interpretam instruções previamente traduzidas e as submete à

execução, imediatamente, sem que se gere um código objeto.

1.2. CLASSIFICAÇÃO DAS LINGUAGENS

Ao longo dos tempos, foram desenvolvidas centenas ou talvez milhares de

linguagens, cada uma com sua finalidade específica. Deste modo, podemos realizar
diversas classificações de linguagens, de acordo com a geração, aplicação,
processo de tradução e muitos outros.
 18

A classificação mais conhecida das linguagens é quando à geração, que além de

tratar a cronologia, diferencia as linguagens quando à evolução da escrita, ou seja,
proximidade da linguagem humana.

1.3. HISTÓRICO DAS LINGUAGENS

A primeira linguagem de programação que se têm notícias foi projetada pelo alemão
Konrad Zuse em meados de 1943, o nome desta linguagem é Plancalkül (Calculus)
(SEBESTA, 2005).

Desde então, sugiram centenas de outras linguagens que podemos classificar

quando à sua geração, de acordo com Price (2001):

Primeira geração: Linguagens de máquina. Os programas eram escritos através de

dados primitivos, ou seja, uma seqüência de zeros e uns. Este processo era
complexo, estava sujeito a muitos erros, além de ser muito cansativo. Podemos dizer
que não havia linguagem de programação, mas sim programas de computador
gerados manualmente por humanos.

Segunda geração: Assembly ou linguagem de montagem. Foram criados os

mnemônicos que representavam códigos de operações e endereços binários.
Exemplo de instrução mnemônica utilizada pelo microprocessador SAP-2.

MVI A
MVI B
MVI C
ADD B
ADD C
ANA B
CALL 0010
JNZ 0015

Terceira geração: Surgiram na década de 60 e caracterizavam-se principalmente

pelo modelo de programação procedural e o modelo declarativo. No caso das
linguagens procedurais, as instruções se dividiam em: entrada/saída, cálculos
aritméticos e lógicos e controle de fluxo. Já as linguagens declarativas se classificam
os modelos funcionais, com uso de funções e as de base lógica, que utilizam dados
de entrada e suas relações para deduzir novas verdades.

Estas linguagens não foram projetadas para usuários finais e conseqüentemente,

seu uso era restrito a profissionais da área.
 19

Exemplo de código LISP (SEBESTA, 2005, p. 56):

; Exemplo de função em LISP

; O código abaixo define uma função que recebe
; 2 listas como argumentos e retorna VERDADEIRO
; se as duas listas forem iguais e FALSO se não forem iguais
(DEFUN equal_lists(list1 list2)
(COND
((ATOM list1) (EQ list1 list2))
((ATOM list2) NIL)
((equal_lists (CAR list1) (CAR list2))
(equal_lists (CDR list1) (CDR list2)))
(T NIL)
)
)

Quarta geração: Também chamadas de linguagens de alto nível, pertencem a esta

classe todas as linguagens projetadas para facilitar a programação, aumentar a
produtividade, simplificar a manutenção, reduzir custos e gerar códigos sem erros. O
código fonte usa instruções bem próximas à linguagem do homem.

Exemplo de código em Java (SEBESTA, 2005, p. 108.):

// Exemplo de Programa em Java

// Entrada: Um inteiro para tamanho da lista e uma lista de valores.
// Quando o tamanho da lista for menor que 100, assumirá o
tamanho inteiro informado.
// Saida: O número de dados de entrada maiores que a média de todos
// os valores de entrada
import java.io.*;
class IntSort {
public static void main(String args[]) throws IOException {
DataInputStream in = new DataInputStream(System.in)
int listlen,
counter,
sum = 0,
average,
result = 0;
int[] intlist = new int[99];
listlen = Integer.parseInt(in.readLine());
if ((listlen > 0) && (listlen < 100)) {
/* Lê os valores de entrada para um vetor e calcula /*
for (counter = 0; counter < listlen; counter++) {
intlist[counter] =
Integer.valueOf(in.readLine()).intValue();
sum += intlist[counter];
}

/* Calcula a média */
average = sum / listlen;
/* conta os valores de entrada maiores que a média */
for (counter = 0; counter < listlen; counter++ )
if (intlist(counter] > average) result ++;
/* Imprime o resultado */
System.out.println(
"\nNúmero de valores > que a média é: " + result);
} //** Fim do if ((listlen >0) ...
else System.out.println(
"Erro de entrada. Tamanho da lista inválido\n");
} //** Fim do método principal
} //** Fim da classe Ins(Sort)
 20

Quinta geração: São linguagens projetadas principalmente para desenvolvimento

de sistemas com inteligência artificial.

O gráfico a seguir, extraído da obra de (SEBESTA, 2005, p. 41) mostra a evolução

das principais linguagens de programação de 1957 a 2004:

Gráfico 1 - Evolução das linguagens

 21

1.4. PARADIGMAS DE PROGRAMAÇÃO

Um paradigma de programação nada mais é do que um modelo programação que

agrupa características comuns de um grupo de linguagens. Conforme foram
surgindo novas gerações de linguagens, foram também surgindo novos modelos de
programação. Existem linguagens que suportam mais de um paradigma.

Não se pode dizer que um determinado paradigma é melhor ou pior que outro, visto
que suas vantagens estão associadas ao projeto e às necessidades específicas.

Sampaio (2008) apresenta os paradigmas e suas principais características:

1.4.1. Imperativo

O paradigma imperativo, também conhecido como procedural, caracteriza-se

principalmente pelo conceito de um estado modelado por variáveis e instruções que
manipulam estes estados. Embora tenha sido o primeiro a surgir, ainda é o mais
utilizado.

Trata-se de um modelo eficiente, porém de difícil legibilidade que se preocupa mais

em “como” fazer do que “o que” fazer.

1.4.2. Orientação a objetos

Resumidamente, caracteriza-se pela estruturação em módulos, denominados

classes, com seus estados, chamados de atributos e suas operações, também
conhecidas como métodos.

É muito eficiente, assim como o imperativo, e ainda oferece modularidade,

reusabilidade e extensibilidade. Comercialmente é o modelo que mais cresce.

O paradigma de orientação a objetos introduziu conceitos importantes quando à

organização código, reusabilidade, segurança e facilidade de manutenção.

Hoje em dia, a grande maioria das linguagens que estão crescendo quanto à
aceitação do mercado suportam orientação a objetos e muitas ferramentas oferecem
recursos para documentar e facilitar o uso de objetos.
 22

1.4.3. Orientação a aspecto

Alguns autores não o consideram exatamente como um paradigma, mas diferencia-

se significativamente dos demais quanto à metodologia que foca na concepção e
modelagem do sistema. Sua principal preocupação está em modularizar os
requisitos que afetam diversas partes do sistema.

Resumidamente, trata aspectos que agrupam pontos de percepção em outras

classes ou outros aspectos para definir novo comportamento. Portanto, incorpora os
conceitos de orientação a objetos, mas também pode ser aplicado em conjunto com
o modelo imperativo.

Para permitir a modelagem de sistemas orientados a aspectos foram desenvolvidas

novas extensões para a linguagem UML (Unified Modeling Language) denominados
UAM (UML-based Aspect Engineering).

O modelo de orientação a aspecto aplica melhor a extensibilidade e reusabilidade

que o modelo de orientação a objetos.

1.4.4. Funcional

Segundo Baranauskas (1993) este modelo foi desenvolvido por John McCarthy
através da linguagem LISP, em 1958.

O paradigma funcional caracteriza-se pela definição e uso funções para tratamento

de entrada e saída. Dispensa o conceito de estado e comando de atribuição onde o
mecanismo de controle do programa deixa de ser iterativo para ser recursivo, ou
seja, capaz de se auto-executar.

Embora seja um modelo simples, introduziu novos conceitos como polimorfismo,

funções de alta ordem e avaliação sob demanda, as implementações não são
eficientes e os mecanismos para tratamento de entrada e saída são primitivos.

Exemplo de uma função para retornar fatorial, escrita em Lisp: (Baranauskas, 1993):

(defun fatorial (n)

(cond
((zerop n) 1)
(T (* n (fatorial (- n 1))))
)
 23

1.4.5. Lógico

Teoria que representa o modelo abstrato de computação onde a representação de

um problema é expressa em forma de lógica simbólica para que através de um
processo de inferência a máquina calcule o resultado (BARANAUSKAS, 1993).

Este modelo inclui algumas características imperativas para aumentar sua eficiência.
É muito utilizado em prototipação, sistemas especialistas e banco de dados.

Como vantagem destaca-se o alto nível de abstração e a simplicidade de

implementação, porém não é um modelo muito eficiente.

Exemplo de código lógico, segundo Baranauskas (1993):

fatorial(0,1).
fatorial(N,Fat):- N>0,
N1 is N-1,
fatorial(N1,Fat1),
Fat is Fat1 * N

1.5. TENDÊNCIAS DAS LINGUAGENS

As linguagens mais modernas e que dispõem de mais recursos para agilizar o

desenvolvimento certamente serão utilizadas em larga escala. Mas isto não quer
dizer que técnicas e conceitos e antigos serão desprezados. Como por exemplo, a
orientação a objetos.

Uma forte tendência presumida com base nas tecnologias que surgiram nos últimos
é sem dúvida a universalização de ambientes, proposta principalmente pelas
máquinas virtuais e frameworks. O objetivo é gerar código que possam ser
traduzidos em diferentes sistemas operacionais e equipamentos.

Outro aspecto fortemente crescente são as aplicações para Internet, que rodam em
browsers (programa que interpreta as páginas de Internet). Embora ainda não exista
uma receita para produzir aplicações que funcionam em todos os ambientes, há uma
grande tendência de soluções deste tipo.
 24

1.6. ASPECTOS PARA AVALIAÇÃO DE UMA LINGUAGEM

Existe uma série de características psicológicas que se manifestam em todas as

linguagens de programação: Uniformidade, ambigüidade, concisão, localidade e
linearidade (PRESSMAN apud WEINBERG, 1995, p. 678).

1.6.1. Uniformidade

Uniformidade serve para indicar o grau de consistência da notação usada na

linguagem, seu nível de restrição aparentemente arbitrária e o quanto suporta de
exceções sintáticas e semânticas nas regras de codificação.

Podemos dizer que há falta de uniformidade quando, por exemplo, a linguagem

permite que se utilize o mesmo operador (símbolo) tanto para comparar valores
como para atribuir valor a uma variável.

A = 10 {Atribuição}
if A = 10 then <comando> { Comparação }

1.6.2. Ambigüidade

Geralmente acompanhada da falta de uniformidade, a ambigüidade pode levar o

programador a interpretar de uma determinada forma aquela instrução que o
compilador irá entender diferentemente.

Isto pode ser exemplificado no caso de uma sintaxe cuja precedência aritmética não
seja óbvia.

X1 = X1/X2 * X3

1.6.3. Concisão

O nível de concisão de uma linguagem de programação diz respeito às informações

que o programador precisa conhecer para compreender o código. Ou seja, uma
linguagem concisa é mais breve e precisa.

Para medir o grau de concisão é importante observar o quanto uma linguagem

suporta de construções estruturadas, os tipos de palavras-chave, abreviações, tipos
de dados e características dos valores padrões. Também é preciso observar o
 25

número de operadores lógicos e aritméticos disponíveis, bem como o número de

funções embutidas.

Uma linguagem exageradamente concisa pode se tornar pouco uniforme e seu

código pode se tornar difícil de ler e entender, mas por outro lado, a falta de
concisão aumenta o tamanho do código e exige uma sintaxe muito metódica.

1.6.4. Localidade

Localidade é uma característica relativa à memória humana pertencente ao domínio

sinestésico, ou seja, ausência de preocupação com os detalhes.

A localidade é aumentada quando as declarações podem ser combinadas

em blocos, quando as construções estruturadas podem ser implementadas
diretamente e quando o projeto e o código resultantes são altamente
modulares e coesivos (PRESSMAN apud WEINBERG, 1995, p. 680).

1.6.5. Linearidade

Linearidade é uma característica oposta à localidade que também está associada à

memória humana, porém, relativa à percepção facilitada pela seqüência de
operações lógicas.

Programadores com memória seqüencial têm maior dificuldade em analisar códigos

com quebra de seqüência ou com excesso de iterações.

1.6.6. Manutenibilidade

De acordo com Brusamolin (2004), a manutenibilidade indica o grau de facilidade

para realizar correções ou aperfeiçoamento em um software.

Esta característica envolve principalmente questões de projeto, mas pode ser

influenciada pela linguagem de programação e ferramentas de desenvolvimento.

Alguns aspectos da linguagem como uniformidade, ambigüidade, concisão,

localidade e linearidade influenciam diretamente sobre a manutenibilidade do código.
Mas há outros fatores importantes, como por exemplo, a questão da evolução da
linguagem, para atender à manutenção evolutiva do software que implica em sua
qualidade. Uma linguagem em constante evolução precisa oferecer recursos como
 26

compatibilidade de código, para evitar que códigos-fonte antigos tenham que ser
reescritos em uma nova compilação ou interpretação.

1.6.7. Modularidade

A modularidade, presente na maioria das linguagens modernas é a possibilidade de

dividir o programa em partes menos como unidades de arquivo, seções, parágrafos,
sentenças e até mesmo palavras.

Silva (2007, p. 7) trata a modularidade com um fator de qualidade e afirma que seu
significado é “... uma forma particular da separação de interesses, em que a divisão
do problema se faz por unidades (módulos) individualizados e coerentes, com valor
e significado por si só”.

1.6.8. Independência modular

A independência modular estende a principal vantagem da modularidade que é a

divisão do problema em partes com o propósito de simplificar a sua resolução. Esta
independência se concretiza quando cada parte do código pode ser executada
separadamente ou incorporada à outra para resolver problemas diferentes. Há ainda
outro aspecto importante quanto à independência modular que diz respeito à
possibilidade de se proteger blocos de códigos ou dados quando se faz uso do
módulo.

Pressman (1995) exemplifica a independência modular presente na linguagem ADA

quando se oculta informações durante a criação de packge (pacote).

1.6.9. Legibilidade

A legibilidade, também conhecida como regibilidade, representa a facilidade de ler e

escrever códigos em uma linguagem. Esta característica influi na produtividade,
depuração e manutenção do software.

Não há dúvida, entretanto, de que características técnicas que aumentem a

legibilidade do código e reduzam a complexidade são importantes para que
ocorra uma efetiva manutenção (PRESSMAN, 1995, p. 688).
 27

Uma linguagem com alta legibilidade precisa oferecer uma boa abstração de dados,
comandos de controle, modularização, documentação, convenções léxicas, sintaxe e
semântica. Estas características determinam não só a aceitação da linguagem pelos
programadores, como também contribuem para que outros profissionais como os
analistas, profissionais de suporte e especialistas de outras áreas possam interpretar
os código gerados.

Um bom exemplo das vantagens da boa legibilidade podem ser as linguagens de

script, comuns em aplicações de grande porte. Neste caso, sua manipulação
geralmente é feita por consultores de implantação, com pouca experiência em
programação, que conhecem as estruturas de dados e o os processamentos que
precisam ser realizadas e geralmente não encontram dificuldades ao construírem
códigos para o interpretador de scripts.

1.6.10. Simplicidade

O conceito de simplicidade caracteriza o quanto é simples é aprender e dominar

uma linguagem. A simplicidade sintática exige precisão nas representações de forma
exista apenas uma maneira de expressar um comando ou instrução.
Semanticamente, ou seja, com relação ao significado, um comando ou instrução não
pode variar conforme o contexto.

1.6.11. Ortogonalidade

Ortogonalidade é quando as instruções primitivas podem ser combinadas, de forma

a construir estruturas de controle e estrutura de dados de uma linguagem,
onde toda combinação de estruturas seja válida e significativa (SEBESTA, 2005).

A ortogonalidade indica a possibilidade de combinar entre si, os componentes

básicos de uma linguagem, como vetores, tipos básicos de dados, tipos definidos
pelo usuário em expressões, atribuições, argumentos e retornos de procedimentos.

Estas combinações podem ser influenciadas pelo paradigma contemplado pela

linguagem, mas quanto maior a ortogonalidade mais simples se torna o código e
consequentemente maior a sua produtividade.
 28

1.6.12. Confiabilidade

A confiabilidade está diretamente ligada aos mecanismos que permitem o

desenvolvimento de programas conforme o conjunto de requisitos.

Uma característica importante da linguagem para oferecer confiabilidade é a tipagem

forte, que consiste em assegurar que as operações considerem os dados sempre
conforme seus tipos corretos, ou seja, de acordo com a definição de tipo.

Quanto ao tratamento de exceções a linguagem deve permitir que procedimentos

especiais sejam executados em caso de comportamento não usual e ainda que seja
permitido diagnosticar erros em tempo de execução.

1.6.13. Portabilidade

É a capacidade de uma linguagem de gerar programas que possam ser executados

em diferentes plataformas com o mínimo de adaptação possível e também suportar
diferentes configurações e hardware mesmo que defasada tecnologicamente.

A portabilidade da linguagem simplifica o suporte aos programas gerados, facilita a

distribuição, gera programas que funcionam em um domínio maior de equipamentos
compatíveis e consequentemente oferece melhor custo/benefício.

1.6.14. Tipologia de dados

Ao avaliar uma linguagem, é importante levar em consideração os tipos de dados

que ela suporta e também as operações que permite realizar com estes tipos de
dados.

De acordo com Fairley apud Pressman (1995) há cinco níveis de verificação de tipos
disponíveis na maioria das linguagens:

Nível 0: Nenhum tipo. Não é realizada a verificação de tipo de compilador ou

interpretador.
 29

Nível 1: Coerção automática de tipos. Permite que o programador misture tipos

diferentes, mas com a possibilidade de converter tipos de modo a permitir que as
operações sejam realizadas.

Nível 2: Conversão mista de tipos. Permite a conversão de uma categoria de tipos

em um único tipo específico para permitir que uma determinada operação seja
realizada. Deve ser evitada como boa prática de codificação.

Nível 3: Verificação pseudoforte de tipos. Somente operações entre dados de

mesmo tipo, previamente definido, são permitidas. Porém, nem sempre a verificação
de tipo é realizada, possibilitando que tipos diferentes sejam envolvidos na mesma
operação.

Nível 4: Verificação forte de tipos. Somente operações entre dados de mesmo tipo,
previamente definido, são permitidas. A verificação de tipo é realizada na
compilação, carga e execução do programa.

Embora muitos programadores não acostumados com a verificação de tipos possam

alegar que é “burocrático” e pouco produtivo realizar a tipagem de cada dado
manipulado pelo programa, esta prática pode ser facilmente inviabilizada quando
ocorrer um erro de entrada de parâmetro em que o resultado da operação não seja
coerente com o tipo aplicado. A verificação forte de tipos garante um resultado com
maiores chances de acerto e evita erros durante a codificação e ainda torna a leitura
do código mais simples. Pode-se dizer que as linhas adicionais do código
responsáveis por definirem os tipos de dados não prejudicam a produtividade de
uma equipe porque evitam maiores transtornos e facilitam a manutenção do código.

1.6.15. Documentação do código

Um dos fatores que pode influenciar significativamente no custo e até mesmo na

viabilidade na manutenção de um software é a documentação. A falta de
documentação ou mesmo a documentação parcial e sem padronização pode
impossibilitar o aproveitamento de códigos gerados.

Este aspecto deve ser levado e consideração quando se avalia uma linguagem e
inclusive as ferramentas de apoio ao desenvolvimento.
 30

A documentação interna do código-fonte inicia-se com a escolha de nomes

de identificadores (variáveis e rótulos), prossegue com a colocação e
composição dos comentários e encerra-se com a organização visual do
programa (PRESSMAN 1995, p.705).

As expressões demasiadamente longas devem ser evitadas porque dificultam o

entendimento e alterações.

Quanto aos comentários de código, praticamente são aceitos por todas as

linguagens, mas é importante observar que estes podem ser definidos conforme a
necessidade. Muitas vezes é preciso comentar sucintamente usando diversas linhas
(comentário de prólogo), outras vezes apenas uma linha é ideal ou até mesmo incluir
o comentário na mesma linha de código, desde que não comprometa a
apresentação.

A documentação requer bom senso, se faltar pode dificultar o entendimento, se

sobrar acaba “sujando” o código e dificultando a sua leitura bem como alteração.

1.6.16. Eficiência

Pressman, (1995) considera três máximas quanto à eficiência:

• É um requisito de desempenho que deve ser estabelecido durante a fase de

análise;
• O software precisa ser eficiente apenas o necessário;
• Não vale a pena sacrificar a simplicidade apenas por eficiência.
Ainda Pressman, define um conjunto de diretrizes que precisam ser levadas em
conta quando se codifica o projeto:

• Simplificar nas expressões;

• Evitar que laços de repetição tenham comando que não precisam se repetir;
• Evitar vetores multidimensionais;
• Usar operações aritméticas “rápidas”;
• Não misturar tipos de dados;
• Usar expressões com tipos de dados mais rápidos sempre que possível.
Outros aspectos importantes para a eficiência do software são quanto ao uso de
memória e entrada/saída. Embora atualmente a memória tenha custo reduzido, o
modelo de codificação poderá influenciar no custo do projeto exigindo uma
codificação que consome menos recursos dos equipamentos. Em relação à
entrada/saída, é importante focar em simplificar a linguagem de comunicação para
 31

facilitar a interpretação humana e aumentar o desempenho quando se tratar de

comunicação com outro hardware.

Para exemplificar a importância da eficiência vamos considerar uma aplicação

simples, com acesso a banco de dados via TCP/IP. A princípio, o projeto previa que
a aplicação funcionaria apenas em rede local com cerca de dez usuários
simultâneos. Porém, após dois anos, a aplicação passou a ser usada por vinte e
cinco usuários, sendo dois deles com acesso via VPN com link de 256kbps. Como
em tempo de projeto não se pensou na expansão do uso da aplicação e na
codificação não houve nenhum esforço para economizar fluxo de dados, liberando
planilhas de consultas com todos os registros para o usuário, ao acessar a aplicação
remotamente o desempenho passou a ser crítico. Esta situação seria bem mais
simples de resolver se durante a fase de codificação fossem implementadas
consultas com um número limitado de registros para que o fluxo entre o servidor de
dados e a estação de trabalho fosse reduzida ao máximo. Assim, a aplicação não
teria um funcionamento crítico, sem a necessidade de aumentar o custo de
desenvolvimento. Logo, pode-se dizer que a boas práticas aumentam a eficiência e
ainda reduzem custos de manutenção do projeto. Uma prova de eficiência.
 32

II. FERRAMENTAS DE DESENVOLVIMENTO

2.1. CASE

CASE (Computer Aided Software Engeneeging) são técnicas e ferramentas de

software que facilitam, agilizam e apóiam o desenvolvimento de softwares.

Basicamente, toda ferramenta que auxilia o processo de construção lógica,

construção física, controle de documentação, elaboração e execução de
testes, diminuindo tempo, esforço, e complexidade de uma forma
automatizada e uniforme é denominada ferramenta CASE (OLIVEIRA, 2006,
p. 41).

A importância das ferramentas no processo de desenvolvimento de software vai

além do aumento da produtividade, principalmente, quando se trabalha em equipe e
com grandes projetos. Praticamente, um programador munido de apenas um
computador, editor de código simples e um compilador não irá conseguir resultados
significativos, pois, terá muitas dificuldades em concluir o projeto e documentá-lo
completamente. É exatamente para mudar este cenário que surgiram as técnicas e
softwares capazes de enriquecer e padronizar o desenvolvimento.

Em um ambiente de desenvolvimento de software encontramos diversos tipos de

ferramentas de apoio, conforme explica Oliveira (2006):

Toolkit: Ferramentas para pequenas tarefas, sem interação entre si e que apóiam
parte do processo de desenvolvimento.

Baseado em linguagem: São ferramentas, em geral específicas para determinadas

linguagens, utilizadas nas fases de programação, compilação, execução, teste e
depuração.

Metodologia com suporte: Apóia todo o ciclo de vida do sistema e permite a

integração das ferramentas.

Segundo as necessidades: Ferramentas de apoio a todas as fases do ciclo de vida

do sistema, integração plena com gerência de projeto, gerência de configuração,
 33

gerência de mudanças e problemas de suma importância para a qualidade do

software.

Principais vantagens da CASE:

• Maior produtividade
• Redução de erros
• Padronização
• Apoio à gerência de projetos
• Simplificação do trabalho
Desvantagens da CASE:

• Custo pode ser elevado

• Pode oferecer limitações
• Exige maiores conhecimentos da equipe

2.2. CONTROLE DE QUALIDADE

A qualidade no processo de desenvolvimento de software tornou-se uma exigência

para conquistar mercado, reduzir custos e satisfazer os clientes.

Sem qualidade não é possível competir, e a conquista da qualidade inclui a adoção

de padrões internacionais de certificação, essencial para qualquer empresa
desenvolvedora que visa distribuir seu produto em âmbito internacional, ou até
mesmo nacional, uma vez que estes padrões passam a ser exigidos por todos os
usuários.

Mas a preocupação com a qualidade não se limita às exigências do cliente, pois

para garantir um processo de produção rentável, é preciso implantar sistemas de
qualidade que reduzem os custos de produção, manutenção e distribuição do
software e ainda assegurar a satisfação do cliente.

A qualidade de desempenho de um software constitui, ainda hoje, um

grande desafio para os técnicos da tecnologia da informação cada vez mais
pressionados pelas exigências constantes estabelecidas pelos clientes no
mercado mundial de construção de software (OLIVEIRA, 2006, p. 49).

Saur (2004) apresenta três fatores críticos de sucesso para o Brasil no mercado de
“Global sourcing”:
 34

• A questão da certificação: A CMM (Capability Maturity Model), criada nos

Estados Unidos, tornou-se a certificação preferida pelo mercado norte-
americano e foi adotada, inclusive, pelas empresas indianas, que são grandes
produtores mundiais de softwares. O conjunto de padrões CMM passou por
aperfeiçoamentos e gerou a certificação CMMI (Integrada). Mais
recentemente, para atender aos padrões europeus e práticas de específicas
para compradores e vendedores de serviços de software, surgiu a certificação
(eSCM) que, inclusive, tem o Brasil como participante, através da COPPE. É
importante alertar que mesmo fazendo parte destes padrões de qualidade, as
empresas desenvolvedoras de softwares precisam preocupar-se com as
mudanças de padrões para não seguir caminhos sem futuro.

• A capacidade de subir na escala de valores: A competitividade em nível de

codificação isolada já se tornou extremamente alta, beneficiando empresas
indianas que têm baixo custo de mão-de-obra. Para garantir mercado, é
preciso oferecer soluções em nível mais elevado, como análise e consultoria.
Esta prática abre espaço para o trabalho de “tradução” que através de diálogo
com o comprador permite oferecer soluções que garantam a funcionalidade
do software no negócio.

• A atualização tecnológica: Possuir escalabilidade e componentização para

reusabilidade é fundamental para conquistar e manter mercado. A
escalabilidade garante atender à demanda com a mesma qualidade, ainda
que seja necessário aumentar a capacidade de produção e
conseqüentemente suprir a necessidade de mão-de-obra especializada.
Quanto à componentização refere-se às técnicas para se gerar códigos
reutilizáveis por diversas aplicações, que reduz o tempo de desenvolvimento
e ainda facilita a manutenção do software.

Quando se trata do desenvolvimento sob encomenda, um dos fatores importantes

da qualidade está no tratamento dos requisitos. No estágio de levantamento dos
requisitos não pode haver falhas na descrição dos detalhes. Porém, muitas vezes o
cliente não consegue estabelecer requisitos completos, ficando por responsabilidade
do desenvolvedor a verificação de toda documentação para evitar que solicitações
inviáveis ou impraticáveis. E é justamente na entrega do software que novamente
 35

estes detalhes precisam ser testados e conferidos para garantir o funcionamento do

software no ambiente de produção do cliente e exigir o mínimo de manutenção
possível.

No ritmo em que vão as criações de novas tecnologias, prever o que pode

dar errado tem-se tornado, cada vez mais, uma tarefa hercúlea,
principalmente porque o tempo para o aprendizado de tudo que se
apresenta no mercado tecnológico é insuficiente (OLIVEIRA, 2006, p. 53).

Além dos padrões de qualidade CMM há padrões ISO (Organização Internacional

para Padronização), IEEE (Instituto de Engenharia Elétrica e Eletrônica) e ABNT
(Associação Brasileira de Normas e Técnicas) que estabelecem normas de
qualidade para de software. Cabe ao desenvolvedor, procurar se profissionalizar
cada vez mais nos padrões de qualidade e buscar a certificação adequada à sua
linha de atuação para enfrentar os desafios do mercado.
 36

III. AMBIENTES DE DESENVOLVIMENTO

De acordo com Roselino (2006), a definição de software não pode se restringir a

“programas de computador” uma vez que muitos outros equipamentos (aparelhos de
TV, microondas, DVDs, celulares e etc.) demandam cada vez mais o
desenvolvimento de soluções em softwares, denominados softwares embarcados.
Há ainda a demanda gerada pelas infra-estruturas de transportes, energia,
comunicações e muitos outros setores. Portanto, o software possui caráter pervasivo
e é transverso nas cadeias produtivas.

Diante de tantas opções para atuarem, os produtores de software precisam definir

claramente seus objetivos para evitar custos elevados com preparação da equipe e
estruturação tecnológica, falta de especialização e principalmente para não
concorrerem com “gigantes mundiais” sem possuir diferencial.

Para classificar os desenvolvedores de acordo seu foco de mercado e capacidade

produtiva, definiu-se os seguintes perfis: autônomos, in-house e fábricas de
software.

3.1. DESENVOLVEDOR AUTÔNOMO

A prestação de serviços de desenvolvimento pequeno porte é muito comum por

todos os lados. Estes serviços vão de suporte, assistência técnica em equipamentos
e programas, treinamento, desenvolvimento de pequenas rotinas e automação de
processos simples. Neste cenário, todas as etapas de desenvolvimento, muitas
vezes são realizadas por apenas um profissional que geralmente não possui
empresa de prestação de serviços.

Roselino (2006) caracteriza como desenvolvimento de baixo valor aquele que é

realizado por profissionais, muitas vezes de nível técnico, e que dispensa
padronizações, utiliza-se de poucos recursos tecnológicos e tem um custo
 37

estreitamente ligado ao custo de mão-de-obra. Neste cenário, o diferencial costuma

ser o preço e a localização geográfica do prestador de serviços.

Uma forte justificativa para este mercado pode ser a questão do desemprego, baixo
custo dos serviços oferecidos e também pela questão geográfica, ou seja,
proximidade do prestador de serviços em relação ao cliente.

3.2. DESENVOLVIMENTO IN-HOUSE

O processo de automação de uma empresa envolve aspectos de ordem

administrativa que muitas vezes esbarram em situações de mudanças dramáticas.
Conciliado com exigências legais, este cenário pode dificultar o processo de decisão
da alta diretoria, fazendo com que a adoção de soluções prontas possa impactar em
dificuldades maiores em curto prazo. Este pode ser um dos grandes motivos para o
desenvolvimento próprio ou in-house. Mas, muitas empresas optam pelo
desenvolvimento próprio para equilibrar custos, morosidade nas mudanças de
processos gerenciais, preparação dos usuários e até mesmo porque necessita de
uma reengenharia de processos para atender às necessidades da automação. Por
se tratar, em geral, de uma equipe pequena, é comum sobrarem muitas funções
para um mesmo profissional e ainda faltar uma pessoa responsável pela gerência
dos projetos, planejamento de longo prazo e ferramentas adequadas. É geralmente
neste cenário que a linguagem conhecida pelo desenvolvedor acaba sendo utilizada
mesmo que não seja totalmente adequada à solução em vistas ao custo e tempo de
treinamento em outra linguagem mais específica.

Ainda que a tendência geral de terceirização das atividades de tecnologias

de informação tenha avançado na última década, persiste um significativo
conjunto de atividades em software desenvolvido in-house (ROSELINO,
2006, p. 35).

3.3. EMPRESAS ESPECIALIZADAS EM DESENVOLVIMENTO

As empresas especializadas em desenvolvimento de software, também

denominadas Fábricas de Softwares são em geral compostas por profissionais com
boa formação, possuem estrutura tecnológica adequada e fazem uso contínuo de
ferramentas e técnicas sofisticadas de desenvolvimento.
 38

Os engenheiros de software empenham grande esforço em busca de

modelos maduros de desenvolvimento, aproximando o processo de
produção de software à rigidez das rotinas industriais, como sugere a
própria idéia de “fábrica de software”. O processo de produção tem
avançado nessa direção mediante uma crescente racionalização do
desenvolvimento, em busca de ganhos de produtividade, inclusive com o
emprego de ferramentas automatizadas (ROSELINO, 2006, p. 29).

Estas empresas de desenvolvimento costumam se especializar conforme a categoria

de software que desenvolve. Para identificar cada uma destas categorias, pode-se
basear na proposta de Roselino (2006):

Serviços em software de baixo valor: São softwares desenvolvidos para atender a

demanda não atendida de software produto, ou seja, onde os requisitos do cliente
são muito particulares e requerem uma solução específica. Porém, a tecnologia
empregada é mais simples e não requer serviço altamente especializado. O
mercado desta categoria é consequentemente mais fragmentado que nas demais.

Serviços em software de Alto Valor e Software sob Encomenda: Também

atuante na suplência do software produto, é uma atividade com maior densidade
tecnológica, serviço especializado de alto nível em análise de sistemas e engenharia
de software. Muitas vezes os contratos prevêem todas as fases do desenvolvimento
e até mesmo consultoria especializada no negócio para atingir alto nível de
adequação e funcionalidade ideal. Exige-se, portanto, alto nível de confiabilidade,
resultando em uma competitividade nem sempre se fundamenta no preço.

Software produto: É a categoria que mais se distingue do modelo tradicional de

prestação de serviços e consequentemente possui maiores propriedades de
competitividade. O produto oferecido é geralmente o pacote de software
desenvolvido para atender ao maior número possível de clientes e não mais às
necessidades específicas. É exatamente nesta categoria de aparecem gigantes da
indústria de software como Microsoft, Oracle, Sum, IBM e muitas outras. Atuar nesta
categoria requer mais estrutura, qualidade, estratégia e consequentemente maiores
investimentos.

Independente da categoria de software produzido, uma fábrica de software precisa

se preocupar mais com qualidade, produtividade, componentização e estratégia para
tornar-se competitiva. Estes aspectos aumentam a complexidade do negócio e dão
maiores possibilidade para obter lucros. Por isto, a escolha de linguagens e
 39

ferramentas de apoio ao desenvolvimento é tratada com mais critérios para não

levar a resultados insatisfatórios.

Outro fator importante quanto às fábricas de software diz respeito ao aproveitamento

das tecnologias e benefícios de negociação com fornecedores que outros perfis de
desenvolvedores não têm. Um bom exemplo é quando às licenças de ferramentas e
linguagens que adquiridas em pacote, geralmente têm menores custos e ainda
possibilitam ambientes diversos para efeito de experimentação, integração e
aperfeiçoamento de técnicas.
 40

IV. PESQUISA

Com o intuito de apontar como alguns profissionais do mercado têm tratado a

escolha das linguagens e ferramentas de desenvolvimento, foi realizada uma
pesquisa de campo. Esta pesquisa não tinha como objetivo formatar um perfil
generalizado das escolhas, mas destacar os aspectos que mais preocupam os
profissionais ao compararem linguagens e ferramentas.

4.1. METODOLOGIA

A pesquisa de campo foi realizada em forma de estudo de caso, nos meses de

março e abril de 2008, através de um questionário aplicado a profissionais
programadores, analistas de sistemas, web designers e professores da área de
programação. A maioria do estado de Minas Gerais, das cidades de Varginha, Belo
Horizonte, Governador Valadares, Tocantins, Eloi Mendes, Lavras, Perdões e
Diamantina. Do estado de São Paulo apareceram as cidades de Bragança Paulista,
Piracicaba e Indaiatuba e para finalizar, uma resposta de Brasília – Distrito Federal.
Todos eles da rede de relacionamento profissional do pesquisador. Portando, teve-
se o cuidado de procurar um conjunto de entrevistados realmente envolvidos com a
prática da programação e que atuam em ambientes diferenciados. Nota-se, porém,
que a maioria destes profissionais fizeram referências à linguagem Delphi®,
desenvolvida pela Borland Software Corporation, já que esta é a principal linguagem
utilizada pelo pesquisador, que também é desenvolvedor, refletindo na composição
de sua rede de relacionamento. Mas como o propósito da pesquisa não é revelar a
linguagem mais usada, entende-se que o resultado da pesquisa não foi influenciado.

Uma pequena parte destes profissionais atua como desenvolvedores autônomos.

Estes escolheram suas linguagens e ferramentas para oferecer seus serviços ao
mercado, ou seja, tiveram a oportunidade de escolher sem interferência de legados
ou projetos alheios.
 41

A maior parte das respostas veio de profissionais do desenvolvimento in-house que

desenvolvem aplicações, na sua maioria voltada para o comércio. Seus
empregadores não são especializados em desenvolvimento, logo, desenvolvem para
atender as necessidades específicas. Neste caso, podemos destacar alguns fatores
que podem influenciar as escolhas, que são os softwares legados, formação da
equipe, disponibilidade de recursos, ou até mesmo a falta de escolha proporcionada
por projetos em andamento onde não há outra opção viável senão aquela oferecida
pela condição.

A outra parte das respostas veio de profissionais que trabalham em empresas

especializadas em desenvolvimento (fábricas de softwares) que precisam escolher
suas linguagens e ferramentas levando-se em consideração o maior número
possível de critérios.

O questionário continha 5 questões relacionadas conforme a seguir:

A primeira delas visou identificar se a empresa é especializada em desenvolvimento

ou se apenas desenvolve apara atender suas necessidades específicas.

A segunda, indagava diretamente sobre qual a linguagem utilizada e os motivos que

levaram à sua escolha.

Quanto à terceira questão, buscou-se a opinião do profissional sobre os aspectos

que considera mais importantes na escolha de uma linguagem para se traçar um
paralelo com os conceitos tratados neste trabalho segundo as fontes de pesquisa
utilizadas.

A única questão fechada, a quarta, buscou classificar a importância, dentre os

aspectos mais citados pela comunidade de desenvolvedores, anúncios de
fornecedores, fóruns, listas de discussão e conversa com profissionais
desenvolvedores.

A quinta questão focou as ferramentas de desenvolvimento com o propósito de

identificar as mais utilizadas e as vantagens que justificaram suas escolhas.
 42

4.2. ANÁLISE DA PESQUISA

Foram entrevistados 23 profissionais que trabalham com desenvolvimento de

sistemas nos modelos autônomo, in-house e especializado. Distribuídos conforme o
gráfico abaixo:

PERFIL DOS PROFISSIONAIS

ENTREVISTADOS

Autônomo

In-house Especializado

Gráfico 2 – Perfil dos profissionais entrevistados

Percebe-se que a ocorrência do desenvolvimento in-house representa mais da

metade dos pesquisados, o que pode ser uma realidade das cidades da região da
pesquisa.

Ainda que a tendência geral de terceirização das atividades de tecnologias

de informação tenha avançado na última década, persiste um significativo
conjunto de atividades em software desenvolvido in-house. Isso significa
aceitar que as dimensões daquilo que se pode denominar como conjunto de
atividades de software é bastante superior àquilo que se denomina aqui
como sendo a indústria de software. (ROSELINO, 2006 p. 35).

Conforme cita Roselino (2006), ao tratar da heterogeneidade do caráter da indústria

de software. Embora crescente o outsoursing das áreas de tecnologia, ainda há
muitas empresas que empregam profissionais para realizarem os serviços de
implementação de softwares conforme suas necessidades.

Quanto às linguagens mais utilizadas pelos profissionais pesquisados, podemos ver

o gráfico abaixo:
 43

Principal linguagem de programação

14

12

10

0
Java ASP C# Delphi Flex PHP Progress VB VB.Net

Gráfico 3 – Linguagens escolhidas

Observa-se que as linguagens Delphi e Java se destacam. Mas é preciso observar

bem os motivos que levaram a essas escolhas. As palavras que mais apareceram
para justificar a utilização destas linguagens foram: produtividade, mercado, recursos
e facilidades no aprendizado. Aliado ao fato destas linguagens estarem em
constante evolução e suportarem o paradigma de orientação a objetos.

Observou-se em todas as respostas que os aspectos técnicos da linguagem não

foram citados, mas sim, jargões da área de desenvolvimento como: produtividade,
mercado, recursos, etc. Denotando que geralmente os programadores pesquisados
não fazem questão de comparar as linguagens observando cada um dos aspectos
citados no capítulo I por Pressman, Sebesta, Brusamolim e outros.

A explicação para esta questão pode ser um conjunto de fatores, como por exemplo,
da forte divulgação, disponibilidade de cursos e treinamentos. Mas principalmente o
fato destas linguagens e ferramentas serem usadas por equipes e projetos
pequenas, no domínio desta pesquisa, onde não há um projeto detalhado das
necessidades tecnológicas e ainda porque muitos desenvolvedores trabalham com
mais de uma linguagem e diversas ferramentas.

Quando perguntados sobre os critérios que consideram decisivos na escolha de

linguagens e ferramentas, os profissionais deram destaque para a produtividade,
custo das licenças, portabilidade e aprendizagem rápida, conforme nos mostra o
gráfico a seguir:
 44

Critérios decisivos de escolha

14
Produtividade
Portabilidade
12
Custo de licenças
Robustez
10
Aprendizagem rápida
Recursos
8
Planos do fornecedor
Comunidade
6
Documentação
Tipo de licença
4
Legibilidade
Material disponível
2
Mercado
Conhecimento da equipe
0

Gráfico 4 – Critérios decisivos de escolha de linguagens e ferramentas

Quando solicitados a classificar os aspectos que vulgam mais importantes na

escolha de uma linguagem de programação, os pesquisados produziram os
seguintes resultados:

Classificação dos aspectos mais importantes

120
Portabilidade

Open Source/Free/Pago
100
Custo das licenças e pacotes

80 Tempo de aprendizado

Planos do fornecedor

60 Apoio da comunidade

Livros e artigos disponíveis

40 Disponibilidade de treinamentos

Produtividade
20 Valorização profissional

Recursos e bibliotecas disponíveis

0

Gráfico 5 – Classificação dos aspectos mais importantes

Observa-se que aspectos como: recursos e bibliotecas disponíveis, produtividades e

planos do fornecedor se destacaram sensivelmente. No caso do primeiro, podemos
perceber que os desenvolvedores preferem linguagens que permitem criar soluções
para o maior número possível de problemas, sem ter que investir em outra
 45

linguagem ou ferramenta. Já o segundo aspecto, (produtividade), não poderia ser

diferente, uma vez que o mercado busca agilidade nos serviços mesmo que isto
possa comprometer a qualidade. Nota se claramente uma forte demanda por
ferramentas de alto nível, ou seja, quarta e quinta gerações. Quanto ao terceiro
aspecto, (planos do fornecedor) justifica-se sua importância pelo fato de ser muito
custosa a troca de uma linguagem de programação, que leva o programador a
reaprender a programar em um novo ambiente. Assim, é de grande importância que
exista um crescimento da linguagem paralelamente ao avanço tecnológico.
Linguagens que não conseguiram evoluir-se, como por exemplo, CA-Clipper
(Linguagem criada pela Natucket e vendida para a Computer Associates), tendem a
ser evitadas e acabam desaparecendo.

Uma questão que realmente chamou a atenção foi a quinta, que perguntava sobre
quais as ferramentas de apoio são utilizadas e porque foram escolhidas. Não foram
citadas ferramentas de apoio à qualidade, testes, controle de versão, métricas ou até
mesmo geradores de aplicação. Isto pode ser um reflexo do ambiente restrito da
pesquisa, que atingiu apenas cenários de pequenas equipes e projetos simples ou
de pequeno porte, onde as metodologias mais avançadas não são utilizadas, bem
como qualquer ferramenta de apoio de alto nível.

4.3. SÍNTESE

Conforme proposta do projeto, a pesquisa através de questionário aos profissionais

desenvolvedores da rede de relacionamento do pesquisador buscou identificar,
principalmente, se os critérios de escolha de linguagens e ferramentas são
criteriosos. Baseando-se nas respostas, principalmente, nos julgamento dos
aspectos mais importantes, percebe-se que a maioria dos programadores
pesquisados ignora muitos aspectos ao escolherem suas linguagens e ferramentas.

Este procedimento pode ser justificado, em partes, pela simplicidade dos projetos
associado ao fato de sua maioria atuar no desenvolvimento in-house que, conforme
citado anteriormente, gera condições especiais, impossibilitando que os critérios de
escolhas de ferramentas sejam mais condicionantes que a exigência interna do
projeto. Um bom exemplo pode ser o caso do desenvolvimento de soluções de
migração e integração de sistemas, onde já existe um aparato tecnológico e
 46

qualquer alteração de contexto implica em alto custo e pode demandar de muito

tempo de trabalho.

As ferramentas que mais apareceram nas respostas foram IDEs (Ambiente/Interface

de desenvolvimento) como Delphi, Eclipse e NetBeans para Java, ferramentas para
administrar bancos de dados e algumas ferramentas de projeto e documentação.

Isto mostra que os ambientes de desenvolvimento pesquisados precisam preocupar-

se mais com questões de qualidade caso queiram competir no mercado.
 47

V. CONCLUSÃO

Escolher uma linguagem de programação e ferramentas de apoio envolve muitos

conceitos de programação, ambiente de desenvolvimento, controle de qualidade,
porte da aplicação, nível de complexidade, perfil de usuário e inclusive mercado.

O processo de produção de software compreende tarefas que vão desde o estudo

das necessidades, projeto, codificação, testes de qualidade, manutenção e gerência
de projeto.

A codificação envolve conceitos que vão desde abstração, regras de sintaxe, regras
de semântica, interpretação do código, execução, interface com usuários e geração
de resultados. As metodologias construídas ao longo dos anos criaram diversos
paradigmas e a evolução tecnológica trouxe diversas opções de softwares de
desenvolvimento, com editores avançados, compiladores poderosos, interfaces de
produção, ferramentas de apoio, testes e métrica. Esta evolução também gerou
diversas alternativas para se alcançar uma solução esperada, por meio de técnicas
simples ou complexas, de custo elevado ou baixo, flexíveis ou limitadas.

Diante deste cenário, formou-se também um usuário mais exigente, diversidade de

equipamentos, necessidade de integração e exigência por qualidade associada ao
menor custo possível.

Para nortear a busca de opções tecnológicas adequadas é preciso antes de tudo

identificar o cenário de desenvolvimento, perfil das aplicações que serão
desenvolvidas e a disponibilidade de recursos. E é preciso considerar ainda as
características psicológicas das linguagens, sua aceitação no mercado, projeção de
vida e domínio de seus recursos. A final, para se formar um bom desenvolvedor é
preciso muito tempo de estudo, prática e aperfeiçoamento, tornando o processo
longo e, inviável qualquer retorno à estaca zero.

Diante de tantas variáveis, cenários e tendências era preciso investigar, na prática,

como estes conceitos estão sendo tratados pelos profissionais. Resultando em uma
 48

pesquisa de campo que apontou um desenvolvedor bastante preocupado com a

escolha das linguagens, mas bem menos preocupado com as ferramentas de apoio.
Não se pode estender estes resultados a uma dedução generalizada porque os
entrevistados não representam uma amostragem real de uma região, pais, ou muito
menos mundial. Mas os aspectos destacados na pesquisa, constantemente
difundidos em sites, livros, revistas e grupos de discussão, como: produtividade,
recursos, portabilidade, licenças e facilidade de uso e aprendizado são fortemente
consideradas nas escolhas.

Paradigmas como orientação a objetos e orientação a aspectos crescem

significativamente e atraem cada vez mais adeptos. Linguagens que suportam estes
paradigmas aparecem como as preferidas, mas certamente não só por isso, já que
incorporam conceitos como legibilidade, concisão, portabilidade, manutenibilidade,
tipagem forte e eficiência.

O conjunto de informações reunidas neste trabalho serve como importante

referência para aqueles que estão ingressando no “mundo da programação”,
profissionais atuantes e inclusive como base para outros trabalhos científicos que
visem buscar resultados de campo mais amplos e que sirvam de amostragem real.
 49

VI. REFERÊNCIAS BIBLIOGRÁFICAS

BARANAUSKAS, Maria Cecília Calani. Procedimento, função, objeto ou lógica?

Linguagens de programação vistas pelos seus paradigmas. Artigo. Campinas,
1993.

BRUSAMOLIN, Valério. Manutenibilidade de Software. Revista Digital Online.

Disponível em http://www.revistadigital.com.br, v. 2, 2004, acessado em 26 de abril
de 2008.

FAIRLEY, R. E. Software Engeneering Concepts, McGraw-Hill, 1985.

MACHADO, Patrícia D. L. Paradigmas de linguagem de programação. Notas de

aula, 2001. Disponível em http://www.dsc.ufcg.edu.br/~patricia/plp2001.1/aulas/
aula1.PDF acessado em 30 de março de 2008.

MAYER, Jason Guilherme; FRANQUETO, João Paulo. Estudo comparativo entre

linguagens de programação para dispositivos móveis. Monografia. Curitiba,
2005.

Modelos de Linguagens de programação. Disponível em http://www.inf.ufrgs.br/

aulas/mlp/slides/MLPIntro1.pdf acessado em 26 de março de 2008.

OLIVEIRA, Viviane de. Ferramentas de apoio: Do desenvolvimento à

homologação de processos. 1. ed. Alta Books: Rio de Janeiro, 2006.

PRESSMAN, Roger S. Engenharia de Software. 3. ed. São Paulo: Makron Books,

1995.

PRICE, Ana Maria de Alencar. Implementação de linguagens de programação:

Compiladores. 2. ed. Porto Alegre: SagraLuzzatto, 2001.

ROSELINO, José Eduardo. Indústria de Software: O “modelo brasileiro” em

perspectiva comparada. Tese de doutorado. Unicamp. Campinas, 2006.
 50

SAMPAIO, Augusto. Paradigmas de linguagens de programação. Apresentação

disponível em http://www.cin.ufpe.br/~acas, Recife, 2008 acessado em 30 de março
de 2008.

SAUR, Ricardo A. C. Futuro da indústria de software: a perspectiva do Brasil:

coletânea de artigos / Ministério do Desenvolvimento, Indústria e Comércio Exterior,
Instituto Euvaldo Lodi / Núcleo Central. Brasília : MDIC/STI : IEL/NC, 2004.

SEBESTA, Robert W. Concepts of Programming Languages. 7. ed. Colorado:

Pearson Education. Inc, 2005.

SILVA, Miguel A. Mendes Oliveira e, Metodologias e Mecanismos para

linguagens de programação concorrente orientadas por objeto. Dissertação de
Douturado. Universidade de Avaneio. Avaneio, 2007.

VAVASSORI, Fabiane Barreto, et al. Ferramenta case para gerenciamento de

projetos e métricas de software. XV Simpósio Brasileiro de Engenharia de
Software. Rio de Janeiro, 2001.

WEINBERG, D. The Psychology of Computer Programming. Van Nostrand, 1971.