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

EspecializadoIn-house

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

0

2

4

6

8

10

12

14

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

0

2

4

6

8

10

12

14Produtividade

Portabilidade

Custo de licenças

Robustez

Aprendizagem rápida

Recursos

Planos do fornecedor

Comunidade

Documentação

Tipo de licença

Legibilidade

Material disponível

Mercado

Conhecimento da equipe

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

0

20

40

60

80

100

120Portabilidade

Open Source/Free/Pago

Custo das licenças e pacotes

Tempo de aprendizado

Planos do fornecedor

Apoio da comunidade

Livros e artigos disponíveis

Disponibilidade de treinamentos

Produtividade

Valorização profissional

Recursos e bibliotecas disponíveis

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.