Você está na página 1de 20

Trabalho de Linguagens de Programao Universidade Federal de Juiz de Fora Prof.

: Jairo Souza
Adriano da Silva Castro Guilherme Ribeiro Morisson

Sumrio
1 Estudo sobre a linguagem Groovy .............................................................................. 3 1.1 1.2 1.3 Histrico ............................................................................................................... 3 Paradigmas implementados ................................................................................. 3 Conceitos bsicos ................................................................................................. 3 Sintaxe e semntica ....................................................................................... 3 Tipos de dados .............................................................................................. 5 Estruturas de controle................................................................................... 6

1.3.1 1.3.2 1.3.3 1.4 2

Propriedades desejveis ....................................................................................... 8

Estudo sobre a linguagem PL/I ................................................................................. 10 2.1 2.2 2.3 Histrico ............................................................................................................. 10 Paradigmas Implementados ............................................................................... 11 Conceitos Bsicos .............................................................................................. 11 Sintaxe e Semntica .................................................................................... 11 Tipos de Dados ........................................................................................... 12 Estruturas de Controle................................................................................ 13

2.3.1 2.3.2 2.3.3 2.4 3 4 5

Propriedades desejveis ..................................................................................... 16

Resumo - Quadro Comparativo ................................................................................. 18 Concluso .................................................................................................................. 18 Bibliografia................................................................................................................ 20

1
1.1

Estudo sobre a linguagem Groovy


Histrico

A primeira meno ao Groovy foi vista no blog de James Strachan em Agosto de 2003, enquanto a maioria das verses era desenvolvida entre 2004 e 2006. Em 2 de janeiro de 2007 foi publicada a primeira verso (1.0) do Groovy e aps vrias verses betas e candidatas a distribuies, em dezembro de 2007 a verso 1.1 Final foi entregue e imediatamente se constituiu como Groovy 1.5 devido ao grande avano obtido. Groovy uma linguagem gil e dinmica para a plataforma Java com muitas caractersticas inspiradas em linguagens como Python, Ruby e Smalltalk, disponibilizando-as para os desenvolvedores utlizando uma sintaxe similar de Java [GROOVY, 2009]

1.2

Paradigmas implementados

Os paradigmas implementados no Groovy so o de orientao a objetos e scripting linguagens de script so linguagens que permitem o controle de um ou mais softwares.

1.3

Conceitos bsicos

1.3.1 Sintaxe e semntica A sintaxe do Groovy bastante semelhante sintaxe Java. Entre outras caractersticas, podem ser citadas:

Suporte a closures - blocos de cdigo reutilizveis; Sintaxe nativa parar listas e mapas; Suporte ao padro Gof Builder atravs na noo de builders; Operadores regex ao nvel de sintaxe e sequncias de escape; Suporte nativo a JavaBean;

Sobrecarga de operadores para simplificar o trabalho com Collections e Maps; Iterao polimrfica e autoboxing; Estenso da biblioteca padro da Java atravs do GDK;

Todas as caractersticas foram retiradas de [GROOVY, 2009]. Em linguagens com tipagem esttica, uma varivel deve ser declarada com um tipo antes de receber um valor. Alm disso, declarar uma varivel de um tipo e tentar armazenar um valor de outro pode gerar erros de compilao ou de execuo. J em linguagens de tipagem dinmica, como Groovy, o tipo da varivel determinado de acordo com o valor associado mesma [HENRY, 2004]. Ainda segundo Henry, a maioria das linguagens de script possuem recursos nativos para criao de estruturas de dados em forma de lista ou mapas. Em Groovy, um exemplo de criao de lista est no trecho de cdigo abaixo:
list = [ 10, 20, -5, 100, -987] println list println list[ 2] println list[ list.size-1 .. 0]

Assim como a criao de um mapa:


map = [ hello: 5, whatever: 8, "who am i?": "kevin"] println map println map.whatever

A figura 1.1 contm uma tabela com exemplos de operadores em Groovy.

Figura 1.1 Operadores em Groovy [HENRY, 2004] J a figura 1.2 apresenta uma comparao entre Java e Groovy para impresso de nomes que atendem a uma restrio em um array de strings.

Figura 1.2 Comparao entre Java e Groovy

1.3.2 Tipos de dados Groovy tem por princpio ser totalmente orientada a objetos. Isso fez com que os tipos primitivos, presentes no Java, passassem a ser utilizados atravs de tipos Wrapper, que so nada mais do que as classes em Java que transformam tipos primitivos em objetos, como indica as figuras 1.3 e 1.4.

Figura 1.3 Tipos de dados em Groovy [KOENING e GLOVER, et al. 2007]

Figura 1.4 Sentenas em Groovy e seus tipos retornados [KOENING e GLOVER, et al. 2007]

1.3.3 Estruturas de controle As estruturas de controle em Groovy so bastante semelhantes s estruturas em Java e sero mostradas nas figuras abaixo, todas retiradas de Groovy in Action [KOENING e GLOVER, et al. 2007].

Figura 1.5 Estruturas if, else e else if [KOENING e GLOVER, et al. 2007] Tem-se ainda o operador condicional ? para simplificar as estruturas acima, como indica a figura 1.6.

Figura 1.6 Operador condicional ? [KOENING e GLOVER, et al. 2007]

Figura 1.7 Estrutura avanada de switch ? [KOENING e GLOVER, et al. 2007] Groovy fornece estruturas de loop como while e for, sendo a figura 1.8 um exemplo da estrutura for.

Figura 1.8 Exemplo de estrutura for em Groovy [KOENING e GLOVER, et al. 2007]

1.4

Propriedades desejveis

1. Legibilidade: a legibilidade com Groovy um pouco prejudicada, visto que o que se buscou, simplificando a linguagem Java, reuniu elementos que necessitariam de grandes blocos de cdigo em pequenos trechos. Isso faz com que se oculte aes que eram bem explcitas. 2. Redigibilidade: a redigibilidade outro ponto de dificuldade em Groovy. Por resumir funes para facilitar a escrita, determinadas aes podero necessitar de reestruturao em caso de manuteno, visto que, quanto menor a escrita, menos liberdade se tem para escrev-la. 3. Confiabilidade: a confiabilidade em Groovy alta, visto que ela trabalha sobre a JVM, que uma mquina virtual de grande nome no mercado, experincia e grande quantidade de pessoas envolvidas no processo de melhorias. 4. Eficincia: a eficincia o ponto alto da linguagem Groovy. Suas estruturas facilitam a vida do programador com loops condicionais mais eficientes e possibilidade de execuo de tarefas complexas com simples linhas de cdigo.

5. Facilidade de aprendizado: Groovy uma linguagem relativamente complexa e demanda que o programador j tenha experincia em outras linguagens principalmente Java visto que suas estruturas tentam facilitar tarefas que em outras linguagens eram complexas. Logo, conhecer essas tarefas so uma forma de pr-requisito. 6. Ortogonalidade: a ortogonalidade em Groovy um conceito especial, visto que a prpria linguagem usa de operaes primitivas para encapsular tarefas que seriam complexas. Logo, para o programador, essa uma tarefa que necessitar de mais conhecimento e experincia. 7. Reusabilidade: a reusabilidade em Groovy um dos pontos fortes da linguagem. Pelo fato de seguir a risca o paradigma da orientao a objetos, reusabilidade um dos termos focados pelos seus desenvolvedores. 8. Modificabilidade: a modificabilidade em Groovy, assim como a redigibilidade um pouco prejudicada pelo "resumo" com que certas funes realizam ao agrupar outras mais complexas. Caso seja utilizada uma dessas funes, mas o desenvolvedor precisa modific-la, necessrio "dar a volta" por outros caminhos, talvez at mais complexos. 9. Portabilidade: a portabilidade em Groovy bastante explorada pelo fato do mesmo trabalhar sobre a JVM, que uma mquina virtual desenvolvida com um vis muito forte para esta caracterstica. Basta uma JVM compatvel com Groovy instalada em qualquer ambiente que um programa escrito nesta linguagem ser executado.

2
2.1

Estudo sobre a linguagem PL/I


Histrico

A PL/I foi desenvolvida como um produto IBM. No incio da dcada de 60, os usurios de computadores da indstria estabeleceram-se em dois campos separados e bem diferentes. Do ponto de vista da IBM, os programadores cientficos podiam usar ou computadores 7090 de grande porte ou o 1620 IBM de pequeno porte. Esse grupo usava os nmeros reais e as matrizes extensivamente. O FORTRAN era a linguagem principal, embora outras linguagens de montagem tambm fossem usadas. Eles tinham seu prprio grupo de usurios, o SHARE, e tinham pouco contato com qualquer um que trabalhasse em aplicaes comerciais. Para aplicaes comerciais, os computadores IBM 7080 grandes ou os 1404 pequenos eram utilizados. Eles precisavam dos tipos de dados comerciais e de cadeias de caracteres, bem como de facilidades de entrada e de sada elaboradas e eficientes. Eles usavam o COBOL, ainda que no incio de 1963, quando a histria da PL/I se iniciou, a converso da linguagem de montagem para o COBOL estivesse longe de ser completa. Tal categoria de usurios tambm tinha seu prprio grupo de usurios, o GUIDE, e raramente contatava com usurios cientficos. No incio de 1963, os planejadores da IBM perceberam o incio de uma mudana nessa situao. Os dois grupos, amplamente separados, movimentavam-se um em direo ao outro de uma maneira que se imaginava certa para criar problemas. Os cientistas comeavam a reunir grandes arquivos de dados para serem processados que exigiam facilidades de entrada e de sada mais sofisticadas e eficientes. O pessoal das aplicaes comerciais comeava a usar anlise da regresso para construir sistemas de informao gerencial, os quais exigiam dados com nmeros reais e matrizes. Comeou a parecer que as instalaes de computao logo exigiriam dois computadores separados, suportando duas linguagens de programao muito diferentes. Essas percepes muito naturalmente levaram ao conceito de projetar-se um computador universal capaz de fazer aplicaes tanto com nmeros reais como com aritmtica decimal e, por conseguinte, aplicaes cientficas e comerciais. Assim, nascia o conceito da linha de computadores IBM System/360. Juntamente com isso, veio a ideia de uma linguagem de programao que pudesse ser usada tanto para aplicaes comerciais como cientficas. Para obterem uma boa media, a programao de sistemas e o processamento de listas estavam entre suas capacidades. Portanto, a nova linguagem destinava-se a substituir o FORTRAN, o COBOL, a LISP e as aplicaes de sistemas da linguagem de montagem.

2.2

Paradigmas Implementados

PL/I uma linguagem estruturada em bloco, composta por pacotes, procedimentos, declaraes, expresses e funes embutidas. Os paradigmas implementados pela PL/I so a unio das melhores partes de outras linguagens, como: ALGOL 60 (recurso e estrutura em bloco); FORTRAN IV (compilao separada com comunicao por meio de dados globais); COBOL 60 (estrutura de dados, entrada/sada e facilidades de gerao de relatrio).

2.3

Conceitos Bsicos

2.3.1 Sintaxe e Semntica Algumas das caractersticas da PL/I: Modularidade: Sesses de programas podem ser compiladas separadamente; Independncia da Mquina: Programas podem ser escritos de tal forma que eles fornecem os mesmos resultados, independentemente do computador que est sendo usado; Proximidade da Mquina: Se voc quer programar no nvel mais profundo, voc pode at mesmo manipular bits individualmente; Claridade: Os conceitos da chamada programao estruturada podem ser realizados em PL/I; Variedade de tipos de dados: PL/I oferece uma variedade de tipos de dados. Alm disso h a possibilidade de definir tipos de dados prprios; Padres Pressupostos: Apesar do tamanho da linguagem, um conceito de pressupostos padres ajuda a reduzir o esforo de escrita. Alm disso, este conceito garante que o programador no seja perturbado por elementos da linguagem que ele no conhece. Dinmica de Armazenamento: Alocaes de memria podem ser manipuladas de acordo com as requisies do problema. Para isso, diferentes classes de armazenamento esto disponveis. Entrada e Sada: Comparada com outras linguagens de programao, em PL/I existem mtodos muito sofisticados de transmisso de dados. Isso varia desde uma simples leitura de caractere at um acesso a banco de dados. At complexas estruturas de dados, como rvores binrias, podem ser eficientemente salvas em disco.

Manipulao de erro: Em PL/I existe um nmero para cada erro, e tambm nomes para os mais importantes. O programa pode reagir flexivelmente a erros e continuar o processamento. Expansividade: Se voc quer definir declaraes de seus problemas especficos, isso tambm possvel em PL/I. O pr-processador capaz de converter esses elementos de linguagem nova em declaraes normais de PL/I. Processamento Paralelo: Isso permite processos rodando em paralelo (em vrios processadores) ou quase paralelas (em um processador) - de forma coordenada, claro. Conexo com outras linguagens: Graas s diferentes funcionalidades de passagem de parmetro e graas aos sofisticados tipos de dados, voc pode usar, por exemplo, PL/I e componentes JAVA, juntamente. 2.3.2 Tipos de Dados Alguns tipos de dados disponveis em PL/I:

Figura 2.1 [Enterprise PL/I Language Reference, IBM 2005] 2.3.3 Estruturas de Controle

Seguem algumas estruturas de controle usadas em PL/I: If ... Else:

Figura 2.2 [STURM, et. al. 2009]

While:

Figura 2.3 [STURM, et. al. 2009] Until:

Figura 2.4 [STURM, et. al. 2009]

Get:

Figura 2.5 [STURM, et. al. 2009] On:

Figura 2.6 [STURM, et. al. 2009] Null:

Figura 2.7 [STURM, et. al. 2009]

Select:

Figura 2.8 [STURM, et. al. 2009] Prioridade entre operadores:

Figura 2.9 [STURM, et. al. 2009]

2.4

Propriedades desejveis

1. Legibilidade: o uso declaraes implcitas em PL/I prejudica a legibilidade. 2. Redigibilidade: a redigibilidade um ponto de facilidade em PL/I, por manter a escrita completa, sem resumo de funes, facilitando a manuteno. 3. Confiabilidade: A confiabilidade em PL/I relativa, visto que em determinados casos, onde h muita liberdade na programao, pode ser considerada confivel a linguagem que permite o tratamento de minuciosas situaes. Entretanto, possvel que qualquer programador utilize dos mesmos comandos para agir de m f, proporcionando uma queda na confiabilidade. 4. Eficincia: bom ponto em PL/I, por ser usada no desenvolvimento de softwares cientficos e bsicos e utilizar recursos de baixo nvel.

5. Facilidade de aprendizado: A grande quantidade de regras e de construtores tornam a PL/I uma linguagem muito complexa, de difcil aprendizado. 6. Ortogonalidade: uma LP que ortogonal quando tem um nmero de construtores bsicos e um conjunto de regras para combin-los relativamente pequeno. PL/I possui uma ortogonalidade fraca. 7. Reusabilidade: Esta propriedade visa o reaproveitamento do cdigo-fonte sendo desnecessrio sua re-escrita. No uma caracterstica bem aplicada a PL/I. 8. Modificabilidade: Por causa da enorme quantidade e complexidade de regras e construtores a modificabilidade fica prejudicada em PL/I. 9. Portabilidade: A portabilidade em PL/I evidente, visto que suas aplicaes possuem uso amplo e podem rodar em diferentes plataformas.

Resumo - Quadro Comparativo


Groovy PL/I

Propriedade
Legibilidade Redigibilidade Confiabilidade Eficincia Facilidade de Aprendizado Ortogonalidade Reusabilidade Modificabilidade Portabilidade

Legenda: timo Regular Pssimo

Concluso

Analisar uma linguagem de programao no uma tarefa simples. So muitos fatores que em determinados casos podem ser at subjetivos que caracterizam cada linguagem, tornando-as aptas a determinados tipos de aplicaes e hardwares. De acordo com o quadro comparativo obtido no final deste trabalho foi possvel perceber que o Groovy tem mais pontos positivos que a PL/I. Mas isso no a caracteriza como a melhor. Significa que em ambientes onde a reusabilidade e a portabilidade mais recomendvel sua utilizao, enquanto que para ambientes onde a redigibilidade crucial, PL/I se adapta melhor. Deve-se analisar uma linguagem visando as necessidades do sistema e do hardware de forma a utilizar a que mais preenche as lacunas e brechas que uma aplicao pode apresentar. Mas isso trabalho para uma anlise mais minuciosa. O que se

apresentou aqui uma breve anlise de duas linguagens, e, tomando-se ambientes maiores possvel chegar a concluses mais detalhadas a respeito das mesmas.

Bibliografia

[Enterprise PL/I Language Reference, IBM 2005] Disponvel em http://www01.ibm.com/software/awdtools/pli/. Acessado em 27 de agosto de 2009. [GROOVY, 2009] Groovy Site oficial. Disponvel em http://groovy.codehaus.org/Portuguese+Home. Acessado em 26 de agosto de 2009. [HENRY, 2004] A Crash Overview of Groovy. Disponvel em http://www.acm.org/crossroads/xrds12-3/groovy.html. Acessado em 26 de agosto de 2009. [KOENING e GLOVER, et al. 2007] Groovy in Action. Manning Publications: 2007. [STURM, 2009] The New PL/I for PC, Workstation and Mainframe.