conceitos de linguagem de programação (9a edição) robert w. sebesta

CONCEITOS DE

LINGUAGENS DEPROGRAMAO

NONA EDIO

R O B E R T W. S E B E S TA

Traduo tcnica:Eduardo Kessler Piveta

Doutor em Cincia da Computao UFRGSProfessor Adjunto da Universidade Federal de Santa Maria UFSM

2011

Verso impressadesta obra: 2011

ROBERT W. SEBESTA

Reservados todos os direitos de publicao, em lngua portuguesa, ARTMED EDITORA S. A. (BOOKMAN COMPANHIA EDITORA uma diviso da ARTMED EDITORA S.A.)Av. Jernimo de Ornelas, 670 - Santana 90040-340 Porto Alegre RSFone (51) 3027-7000 Fax (51) 3027-7070

proibida a duplicao ou reproduo deste volume, no todo ou em parte, sob quaisquer formas ou por quaisquer meios (eletrnico, mecnico, gravao, fotocpia, distribuio na Web e outros), sem permisso expressa da Editora.

SO PAULOAv. Embaixador Macedo Soares, 10.735 - Pavilho 5 - Cond. Espace Center Vila Anastcio 05095-035 So Paulo SPFone (11) 3665-1100 Fax (11) 3667-1333

SAC 0800 703-3444

IMPRESSO NO BRASILPRINTED IN BRAZIL

Obra originalmente publicada sob o ttuloConcepts of Programming Languages, 9th Edition

ISBN 9780136073475

Authorized translation from the English language edition, entitled CONCEPTS OF PROGRAMMING LANGUAGES, 9th Edition, by ROBERT SEBESTA, published by Pearson Education,Inc., publishing as Addison-Wesley, Copyright 2010. All rights reserved. No part of this book may be reproduced or trans-mitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from Pearson Education,Inc.

Portuguese language edition published by Bookman Companhia Editora Ltda, a Division of Artmed Editora SA, Copyright 2010

Traduo autorizada a partir do original em lngua inglesa da obra intitulada CONCEPTS OF PROGRAM-MING LANGUAGES, 9 Edio, autoria de ROBERT SEBESTA, publicado por Pearson Education, Inc., sob o selo Addison-Wesley, Copyright 2010. Todos os direitos reservados. Este livro no poder ser re-produzido nem em parte nem na ntegra, nem ter partes ou sua ntegra armazenado em qualquer meio, seja mecnico ou eletrnico, inclusive fotoreprografao, sem permisso da Pearson Education,Inc.

A edio em lngua portuguesa desta obra publicada por Bookman Companhia Editora Ltda, uma diviso da Artmed Editora SA, Copyright 2010

Capa: Rogrio Grilho, arte sobre capa original

Leitura fi nal: Mirella Nascimento

Editora Snior: Denise Weber Nowaczyk

Editora responsvel por esta obra: Elisa Viali

Projeto e editorao: Techbooks

O AUTOR

Robert Sebesta Professor Associado Emrito no Departamento de Cincia da Computao da Universidade do Colorado Colorado Springs. Tem bacharelado em Matemtica Aplicada pela Universidade de Colorado em Boulder e mestrado e doutorado (PhD) em Cincia da Computao pela Universidade Estadual da Pensilvnia. Ele ensina cincia da computao h mais de 38 anos. Seus interesses profissionais so o projeto e a avaliao de linguagens de programao, projeto de compiladores e mtodos e ferramentas de testes de software.

Catalogao na publicao: Ana Paula M. Magnus CRB 10/2052

S443c Sebesta, Robert W. Conceitos de linguagens de programao [recurso eletrnico] / Robert W. Sebesta; traduo tcnica: Eduardo Kessler Piveta. 9. ed. Dados eletrnicos. Porto Alegre : Bookman, 2011.

Editado tambm como livro impresso em 2011. ISBN 978-85-7780-862-5

1. Cincia da computao. 2. Linguagens de programao de computador. I. Ttulo.

CDU 004.43

Prefcio

MUDANAS PARA A NONA EDIO

Os objetivos, a estrutura geral e a abordagem desta nona edio de Conceitos de Linguagens de Programao permanecem as mesmas das oito anteriores. Os objetivos principais so introduzir as construes mais importantes das lin-guagens de programao contemporneas e fornecer ao leitor as ferramen-tas necessrias para a avaliao crtica de linguagens existentes e futuras. Um objetivo adicional preparar o leitor para o estudo de projeto de compilado-res, apresentando um mtodo formal de descrio de sintaxe e introduzindo abordagens para as anlises sinttica e lxica.

Para manter a atualidade do contedo, algumas das discusses acerca de linguagens de programao mais antigas foram substitudas por material de linguagens mais recentes na nona edio. Por exemplo, no Captulo 6, foram adicionadas discusses acerca dos tipos tabela em Lua, das tuplas e das compreenses de lista de Python, e das fatias em Ruby. Algum material mais antigo foi removido do Captulo 7, diminuindo-o em duas pginas. A seo sobre o modelo de objetos de JavaScript foi removida do Captulo 11. Em alguns casos, o material foi movido. Por exemplo, trs sees do Captulo 5 foram para o Captulo 6, cujo tpico trata de tipos de dados. Em algumas sees, o material foi expandido. No Captulo 4, por exemplo, o cdigo do analisador lxico foi expandido para um programa completo, e uma sada real dele foi includa. A seo sobre escopo no Captulo 5 foi expandida com subsees sobre escopo global e ordem de declarao. A discusso dos tipos de dados abstratos no Captulo 11 foi revisada e au-mentada. No Captulo 15, uma seo sobre recurso em cauda em Scheme foi adicionada. No Captulo 3, a introduo semntica foi revisada e as subsees foram reordenadas. Alm disso, pequenas mudanas foram feitas em diversas sees do livro, principalmente para melhorar a clareza. Por fim, mais de 50 problemas e exerccios de programao, alm de mais de cem questes de reviso, foram adicionados obra.

A VISO

Este livro descreve os conceitos fundamentais de linguagens de programao ao discutir as questes de projeto de diversas construes de linguagens, exa-minando as escolhas para essas construes em algumas das linguagens mais comuns e comparando criticamente alternativas de projeto.

vi Prefcio

Qualquer estudo srio sobre linguagens de programao requer um exa-me de alguns tpicos relacionados, dentre os quais esto os mtodos de des-crio de sintaxe e de semntica, tratados no Captulo 3. Alm disso, tcnicas de implementao para vrias construes de linguagem devem ser conside-radas: as anlises lxica e sinttica so discutidas no Captulo 4, e a implemen-tao da ligao de subprogramas assunto do Captulo 10. A implementao de outras construes de linguagem discutida em outras partes do livro.

Os pargrafos a seguir descrevem o contedo da nona edio.

DESCRIO DOS CAPTULOS

O Captulo 1 comea com uma discusso sobre por que estudar linguagens de programao. Ele ento discute os critrios usados para avaliar linguagens e construes de linguagem. A influncia primria no projeto de linguagens, alguns compromissos comuns de projeto e as abordagens bsicas para a imple-mentao tambm so examinadas.

O Captulo 2 descreve a evoluo da maioria das linguagens impor-tantes discutidas neste livro. Apesar de nenhuma delas ser descrita comple-tamente, as origens, os propsitos e as contribuies de cada uma so discu-tidos. Essa viso histrica valiosa, porque fornece o conhecimento neces-srio para entender as bases tericas e prticas do projeto contemporneo de linguagens. Tambm motiva o estudo adicional do projeto e da avaliao de linguagens. E, j que nenhum dos captulos restantes depende do Captulo 2, ele pode ser lido independentemente.

O Captulo 3 mostra o modelo formal primrio para descrever a sintaxe de linguagens de programao BNF. Esse seguido por uma apresentao das gramticas de atributos, que descrevem tanto a sintaxe quanto a semntica esttica de linguagens. A difcil tarefa da descrio semntica ento explora-da, incluindo breves introdues para os trs mtodos mais comuns: semnti-ca operacional, denotacional e axiomtica.

O Captulo 4 introduz as anlises lxica e sinttica. Esse captulo volta-do para as faculdades que no mais requerem um curso de projeto de compila-dores em seu currculo. Como o Captulo 2, pode ser lido independentemente do restante do livro.

Os Captulos 5 a 14 descrevem em detalhes as questes de projeto para as construes primrias das linguagens imperativas. Em cada um dos casos, as escolhas de projeto para diversas linguagens de exemplo so apresentadas e avaliadas. Especificamente, o Captulo 5 cobre as muitas caractersticas das variveis, o Captulo 6 mostra os tipos de dados, e o Captulo 7 explica as ex-presses e as sentenas de atribuio. O Captulo 8 descreve as sentenas de controle, e os Captulos 9 e 10 discutem os subprogramas e suas implementa-es. O Captulo 11 examina os recursos de abstrao de dados.

O Captulo 12 fornece uma discusso aprofundada dos recursos de lin-guagem que suportam a programao orientada a objetos (herana e vincu-lao dinmica de mtodos), o Captulo 13 discute as unidades de programa

Prefcio vii

concorrentes, e o Captulo 14 fala sobre o tratamento de excees, com uma breve discusso sobre o tratamento de eventos.

Os dois ltimos captulos (15 e 16) descrevem dois dos paradigmas de programao mais importantes: a programao funcional e a programao l-gica. O Captulo 15 apresenta uma introduo linguagem Scheme, incluindo descries de algumas de suas funes primitivas, formas especiais e formas funcionais, alm de alguns exemplos de funes simples escritas em Scheme. Introdues breves a ML e a Haskell so dadas para ilustrar alguns tipos dife-rentes de linguagens funcionais. O Captulo 16 introduz a programao lgica e a linguagem Prolog.

PARA O INSTRUTOR

No curso inicial de linguagens de programao na Universidade do Colorado, em Colorado Springs, o livro usado da seguinte forma: cobrimos os Captulos 1 e 3 em detalhes, e apesar de os estudantes acharem interessante e de leitura benfica o Captulo 2 recebe pouco tempo de aula devido falta de contedo altamente tcnico. Como nenhum material nos captulos subsequentes depende do Captulo 2, ele pode ser ignorado completamente. E, j que requeremos um curso de projeto de compiladores, o Captulo 4 no tratado.

Os Captulos 5 a 9 devem ser relativamente fceis para estudantes com extensa experincia em programao em C++, Java ou C#. Os Captulos 10 a 14 so mais desafiadores e requerem aulas mais detalhadas.

Os Captulos 15 e 16 so inteiramente novos para a maioria dos estu-dantes principiantes. Idealmente, processadores de linguagem para Scheme e Prolog devem estar disponveis para que os estudantes possam aprender o material nesses captulos. includo material suficiente para permitir que os estudantes lidem com alguns programas simples.

Cursos de graduao provavelmente no sero capazes de cobrir todo o contedo dos ltimos dois captulos. Cursos de ps-graduao, entretanto, devem conseguir discutir completamente o material pulando partes dos pri-meiros captulos acerca de linguagens imperativas.

MATERIAIS SUPLEMENTARES

Os seguintes suplementos esto disponveis para os leitores deste livro em www.bookman.com.br.

Um conjunto de slides (em portugus) com notas de aulas. Slides em Power Point esto disponveis para cada um dos captulos do livro.

Slides em Power Point contendo todas as figuras do livro (em portugus).

Para acessar os recursos, procure pelo livro no site www.bookman.com.br e clique em Contedo Online.

viii Prefcio

Solues para muitos dos conjuntos de problemas (em ingls) esto dis-ponveis para instrutores qualificados na nossa rea do Professor. Para aces-sar os materiais procure pelo livro em www.bookman.com.br e clique em Material para professores. Faa o seu cadastro de professor no site, caso ainda no tenha, para receber uma senha de acesso ao material.

Disponibilidade de processador de linguagemProcessadores e informaes acerca de algumas das linguagens de programa-o discutidas neste livro podem ser encontrados nestes sites:

C, C++, Fortran e Ada gcc.gnu.orgC# microsoft.comJava java.sun.comHaskell haskell.orgLua www.lua.orgScheme www.plt-scheme.org/software/drschemePerl www.perl.comPython www.python.orgRuby www.ruby-lang.org

JavaScript est inclusa em praticamente todos os navegadores; PHP est in-cluso em praticamente todos os servidores Web.

Todas essas informaes tambm esto includas no site do livro, em www.aw-bc.com/sebesta.

AGRADECIMENTOS

As sugestes de revisores magnficos contriburam muito para a forma atual deste livro. Em ordem alfabtica de sobrenomes, so eles:

I-ping Chu Universidade DePaulAmer Diwan Universidade do ColoradoStephen Edwards Virginia TechNigel Gwee Southern University Baton RougeK. N. King Universidade Estadual da GergiaDonald Kraft Universidade Estadual da LouisianaSimon H. Lin Universidade Estadual da Califrnia NorthridgeMark Llewellyn Universidade da Flrida CentralBruce R. Maxim Universidade de Michigan DearbornGloria Melara Universidade Estadual da Califrnia NorthridgeFrank J. Mitropoulos Nova Universidade de SoutheasternEuripides Montagne Universidade da Flrida CentralBob Neufeld Universidade Estadual de WichitaAmar Raheja Universidade Politcnica do Estado da Califrnia

PomonaHossein Saiedian Universidade de KansasNeelam Soundarajan Universidade Estadual de Ohio

Prefcio ix

Paul Tymann Instituto de Tecnologia de RochesterCristian Videira Lopes Universidade da Califrnia IrvineSalih Yurttas Universidade Texas A&M

Diversas outras pessoas forneceram sugestes para as edies prvias de Conceitos de Linguagens de Programao em diferentes estgios de seu de-senvolvimento. Todos os comentrios foram teis e detalhadamente consi-derados. Em ordem alfabtica de sobrenomes, so elas: Vicki Allan, Henry Bauer, Carter Bays, Manuel E. Bermudez, Peter Brouwer, Margaret Burnett, Paosheng Chang, Liang Cheng, John Crenshaw, Charles Dana, Barbara Ann Griem, Mary Lou Haag, John V. Harrison, Eileen Head, Ralph C. Hilzer, Eric Joanis, Leon Jololian, Hikyoo Koh, Jiang B. Liu, Meiliu Lu, Jon Mauney, Robert McCoard, Dennis L. Mumaugh, Michael G. Murphy, Andrew Oldroyd, Young Park, Rebecca Parsons, Steve J. Phelps, Jeffery Popyack, Raghvinder Sangwan, Steven Rapkin, Hamilton Richard, Tom Sager, Joseph Schell, Sibylle Schupp, Mary Louise Soffa, Neelam Soundarajan, Ryan Stansifer, Steve Stevenson, Virginia Teller, Yang Wang, John M. Weiss, Franck Xia, e Salih Yurnas.

Matt Goldstein, editor; Sarah Milmore, assistente editorial; e Meredith Gertz, supervisora de produo da Addison-Wesley, e Dennis Free da Aptara, merecem minha gratido por seus esforos para produzir a nona edio rpida e cuidadosamente.

Sumrio

Captulo 1 Aspectos preliminares 19

1.1 Razes para estudar conceitos de linguagens de programao ............ 20

1.2 Domnios de programao............................................................ 23

1.3 Critrios de avaliao de linguagens .............................................. 26

1.4 Influncias no projeto de linguagens ............................................. 38

1.5 Categorias de linguagens ............................................................. 42

1.6 Trade-offs no projeto de linguagens ............................................... 43

1.7 Mtodos de implementao.......................................................... 44

1.8 Ambientes de programao .......................................................... 52

Resumo Questes de reviso Conjunto de problemas ............................ 52

Captulo 2 Evoluo das principais linguagens de programao 56

2.1 Plankalkl de Zuse ...................................................................... 58

2.2 Programao de hardware mnima: pseudocdigos ........................... 60

2.3 O IBM 704 e Fortran ................................................................... 63

2.4 Programao funcional: LISP ........................................................ 68

2.5 O primeiro passo em direo sofisticao: ALGOL 60 ...................... 74

2.6 Informatizando os registros comerciais: COBOL ............................... 80

2.7 O incio do compartilhamento de tempo: BASIC............................... 85

Entrevista: ALAN COOPER Projeto de usurio e projeto de linguagens ... 88

2.8 Tudo para todos: PL/I ................................................................. 90

2.9 Duas das primeiras linguagens dinmicas: APL e SNOBOL .................. 93

2.10 O incio da abstrao de dados: SIMULA 67 .................................... 95

2.11 Projeto ortogonal: ALGOL 68 ........................................................ 96

2.12 Alguns dos primeiros descendentes dos ALGOLs ............................... 97

2.13 Programao baseada em lgica: Prolog ........................................102

2.14 O maior esforo de projeto da histria: Ada ...................................103

12 Sumrio

2.15 Programao orientada a objetos: Smalltalk ...................................108

2.16 Combinando recursos imperativos e orientados a objetos: C++ ..........110

2.17 Uma linguagem orientada a objetos baseada no paradigma imperativo: Java ..................................................................114

2.18 Linguagens de scripting ..............................................................118

2.19 Uma linguagem baseada em C para o novo milnio: C# ....................125

2.20 Linguagens hbridas de marcao/programao ..............................128

Resumo Notas bibliogrficas Questes de reviso Conjunto de problemas Exerccios de programao .................................130

Captulo 3 Descrevendo sintaxe e semntica 135

3.1 Introduo ...............................................................................136

3.2 O problema geral de descrever sintaxe ..........................................137

3.3 Mtodos formais para descrever sintaxe ........................................139

3.4 Gramticas de atributos .............................................................155

Nota histrica ..............................................................................155

3.5 Descrevendo o significado de programas: semntica dinmica...........161

Nota Histrica .............................................................................176

Resumo Notas bibliogrficas Questes de reviso Conjunto de problemas .......................................................................183

Captulo 4 Anlise lxica e sinttica 189

4.1 Introduo ...............................................................................190

4.2 Anlise lxica ...........................................................................192

4.3 O problema da anlise sinttica ...................................................200

4.4 Anlise sinttica descendente recursiva ........................................204

4.5 Anlise sinttica ascendente .......................................................213

Resumo Questes de reviso Conjunto de problemas Exerccios de programao ..................................................................221

Captulo 5 Nomes, vinculaes e escopos 226

5.1 Introduo ...............................................................................227

5.2 Nomes .....................................................................................228

Nota histrica ..............................................................................228

Nota histrica ..............................................................................229

Sumrio 13

5.3 Variveis..................................................................................231

Nota histrica ..............................................................................232

5.4 O conceito de vinculao............................................................233

Entrevista: RASMUS LERDORF Linguagens de scripting e outros exemplos de solues simples ..................................................238

5.5 Escopo ....................................................................................245

Nota histrica ..............................................................................247

5.6 Escopo e tempo de vida .............................................................255

5.7 Ambientes de referenciamento ....................................................256

5.8 Constantes nomeadas ................................................................258

Resumo Questes de reviso Conjunto de problemas Exerccios de programao ...................................................................260

Captulo 6 Tipos de dados 267

6.1 Introduo ...............................................................................268

6.2 Tipos de dados primitivos ...........................................................270

6.3 Cadeias de caracteres .................................................................274

Nota histrica ..............................................................................275

6.4 Tipos ordinais definidos pelo usurio ............................................280

6.5 Tipos de matrizes ......................................................................284

Nota histrica ..............................................................................285

Nota histrica ..............................................................................288

6.6 Matrizes associativas .................................................................299

6.7 Registros .................................................................................301

Entrevista: ROBERTO IERUSALIMSCHY Lua .........................................302

6.8 Unies ....................................................................................308

6.9 Ponteiros e referncias ...............................................................312

Nota histrica ..............................................................................317

6.10 Verificao de tipos ...................................................................327

6.11 Tipagem forte ...........................................................................328

6.12 Equivalncia de tipos .................................................................330

6.13 Teoria e tipos de dados ..............................................................334


14 Sumrio

Captulo 7 Expresses e sentenas de atribuio 341

7.1 Introduo ...............................................................................342

7.2 Expresses aritmticas ...............................................................343

7.3 Operadores sobrecarregados ........................................................352

7.4 Converses de tipos ...................................................................354

Nota histrica ..............................................................................356

7.5 Expresses relacionais e booleanas ..............................................357

Nota histrica ..............................................................................357

7.6 Avaliao em curto-circuito ........................................................360

7.7 Sentenas de atribuio .............................................................361

Nota histrica ..............................................................................365

7.8 Atribuio de modo misto...........................................................366


Captulo 8 Estruturas de controle no nvel de sentena 371

8.1 Introduo ...............................................................................372

8.2 Sentenas de seleo .................................................................374

Nota histrica ..............................................................................374

Nota histrica ..............................................................................376

8.3 Sentenas de iterao ................................................................387

Nota histrica ..............................................................................387

Entrevista: LARRY WALL Parte 1: Lingustica e o nascimento de Perl ...392

Nota histrica ..............................................................................400

8.4 Desvio incondicional ..................................................................403

8.5 Comandos protegidos .................................................................404

8.6 Concluses ...............................................................................406


Captulo 9 Subprogramas 413

9.1 Introduo ...............................................................................414

9.2 Fundamentos de subprogramas ....................................................414

Sumrio 15

9.3 Questes de projeto para subprogramas ........................................425

9.4 Ambientes de referenciamento local .............................................425

9.5 Mtodos de passagem de parmetros ............................................428

Entrevista: LARRY WALL Parte 2: Linguagens de scripting em geral e Perl em particular .............................................................430

Nota histrica ..............................................................................438

Nota histrica ..............................................................................438

Nota histrica ..............................................................................442

9.6 Parmetros que so subprogramas ................................................450

Nota histrica ..............................................................................452

9.7 Subprogramas sobrecarregados ....................................................452

9.8 Subprogramas genricos .............................................................453

9.9 Questes de projeto para funes ................................................460

9.10 Operadores sobrecarregados definidos pelo usurio .........................462

9.11 Corrotinas ................................................................................462

Nota histrica ..............................................................................462


Captulo 10 Implementando subprogramas 471

10.1 A semntica geral de chamadas e retornos.....................................472

10.2 Implementando subprogramas simples .......................................473

10.3 Implementando subprogramas com variveis locais dinmicas da pilha ..............................................................................475

10.4 Subprogramas aninhados ............................................................484

Entrevista: NIKLAUS WIRTH Mantendo a simplicidade ........................486

10.5 Blocos .....................................................................................492

10.6 Implementando escopo dinmico .................................................494


Captulo 11 Tipos de dados abstratos e construes de encapsulamento 503

11.1 O conceito de abstrao .............................................................504

11.2 Introduo abstrao de dados .................................................505

16 Sumrio

11.3 Questes de projeto para tipos de dados abstratos .........................508

11.4 Exemplos de linguagem ..............................................................509

Entrevista: BJARNE STROUSTRUP C++: nascimento, onipresena e crticas comuns ............................................................512

11.5 Tipos de dados abstratos parametrizados ......................................527

11.6 Construes de encapsulamento ..................................................531

11.7 Nomeando encapsulamentos .......................................................535


Captulo 12 Suporte para a programao orientada a objetos 545

12.1 Introduo ...............................................................................546

12.2 Programao orientada a objetos .................................................546

12.3 Questes de projeto para programao orientada a objetos ..............550

12.4 Suporte para programao orientada a objetos em Smalltalk ............555

12.5 Suporte para programao orientada a objetos em C++ ....................558

Entrevista: BJARNE STROUSTRUP Sobre paradigmas e uma programao melhor ...................................................................560

12.6 Suporte para programao orientada a objetos em Java ...................569

12.7 Suporte para programao orientada a objetos em C# ......................574

12.8 Suporte para programao orientada a objetos em Ada 95 ...............575

12.9 Suporte para programao orientada a objetos em Ruby ..................580

12.10 Implementao de construes orientadas a objetos .......................584


Captulo 13 Concorrncia 592

13.1 Introduo ...............................................................................593

13.2 Introduo concorrncia no nvel de subprograma ........................598

Nota histrica ..............................................................................601

13.3 Semforos ................................................................................602

13.4 Monitores ................................................................................607

13.5 Passagem de mensagens .............................................................609

Sumrio 17

13.6 Suporte de Ada para concorrncia ................................................611

13.7 Linhas de execuo em Java .......................................................622

13.8 Linhas de execuo em C# ..........................................................630

13.9 Concorrncia no nvel de sentena ...............................................632


Captulo 14 Tratamento de excees e tratamento de eventos 639

14.1 Introduo ao tratamento de excees .........................................640

Nota histrica ..............................................................................644

14.2 Tratamento de excees em Ada ..................................................647

14.3 Tratamento de excees em C++ ..................................................654

14.4 Tratamento de excees em Java .................................................659

Entrevista: JAMES GOSLING O nascimento de Java .............................660

14.5 Introduo ao tratamento de eventos ...........................................668

14.6 Tratamento de eventos com Java .................................................670


Captulo 15 Linguagens de programao funcional 680

15.1 Introduo ...............................................................................681

15.2 Funes matemticas .................................................................682

15.3 Fundamentos das linguagens de programao funcional ...................685

15.4 A primeira linguagem de programao funcional: LISP .....................686

15.5 Uma introduo a Scheme...........................................................690

15.6 COMMON LISP ...........................................................................708

15.7 ML ..........................................................................................709

15.8 Haskell ....................................................................................712

15.9 Aplicaes de linguagens funcionais .............................................717

15.10 Uma comparao entre linguagens funcionais e imperativas .............718

Resumo Notas Bibliogrficas Questes de Reviso Conjunto de Problemas Exerccios de Programao .................................721

18 Sumrio

Captulo 16 Linguagens de programao lgica 726

16.1 Introduo ...............................................................................727

16.2 Uma breve introduo ao clculo de predicados ..............................727

16.3 Clculo de predicados e prova de teoremas ....................................731

16.4 Uma viso geral da programao lgica .........................................734

16.5 As origens do Prolog ..................................................................735

16.6 Os elementos bsicos do Prolog ...................................................736

16.7 Deficincias do Prolog ...............................................................751

16.8 Aplicaes de programao lgica ................................................757


Referncias ............................................................................763

ndice ...................................................................................775

Captulo 1Aspectos Preliminares

1.1 Razes para estudar conceitos de linguagens de programao

1.2 Domnios de programao

1.3 Critrios de avaliao de linguagens

1.4 Influncias no projeto de linguagens

1.5 Categorias de linguagens

1.6 Trade-offs no projeto de linguagens

1.7 Mtodos de implementao

1.8 Ambientes de programao

20 Conceitos de Linguagens de Programao

Antes de iniciarmos a discusso sobre os conceitos de linguagens de progra-mao, precisamos considerar aspectos preliminares. Primeiro, explicaremos algumas razes pelas quais os estudantes de cincia da computao e os desen-volvedores de software profissionais devem estudar conceitos gerais sobre o projeto e a avaliao de linguagens. Essa discusso valiosa para quem acredita que um conhe-cimento funcional de uma ou duas linguagens e programao suficiente para cien-tistas da computao. Na sequncia, descrevemos brevemente os principais domnios de programao. A seguir, como o livro avalia construes e recursos de linguagens, apresentamos uma lista de critrios que podem servir de base para tais julgamentos. Ento, discutimos as duas maiores influncias no projeto de linguagens: a arquitetura de mquinas e as metodologias de projeto de programas. Depois, introduzimos as diversas categorias de linguagens de programao. A seguir, descrevemos alguns dos principais compromissos que devem ser considerados durante o projeto de linguagens.

Como este livro trata tambm da implementao de linguagens de programa-o, este captulo inclui uma viso geral das abordagens mais comuns para a imple-mentao. Finalmente, descrevemos alguns exemplos de ambientes de programao e discutimos seu impacto na produo de software.

1.1 RAZES PARA ESTUDAR CONCEITOS DE LINGUAGENS DE PROGRAMAO

natural que os estudantes se perguntem como se beneficiaro com o estudo de conceitos de linguagens de programao. Afinal, muitos outros tpicos em cincia da computao so merecedores de um estudo srio. A seguir, temos uma lista de potenciais vantagens de estudar esses conceitos:

Capacidade aumentada para expressar ideias. Acredita-se que a profundi-dade com a qual as pessoas podem pensar influenciada pelo poder de expressividade da linguagem que elas usam para comunicar seus pensa-mentos. As pessoas que tm apenas um fraco entendimento da lingua-gem natural so limitadas na complexidade de seus pensamentos, parti-cularmente na profundidade de abstrao. Em outras palavras, difcil para essas pessoas criar conceitos de estruturas que elas no podem des-crever verbalmente ou expressar na escrita.

Programadores no processo de desenvolvimento software apresen-tam a mesma limitao. A linguagem na qual eles desenvolvem software impe restries nos tipos de estruturas de controle, estruturas de dados e abstraes que eles podem usar logo, as formas dos algoritmos que eles constroem tambm so limitadas. Conhecer uma variedade mais ampla de recursos das linguagens de programao pode reduzir essas limitaes no desenvolvimento de software. Os programadores podem aumentar a faixa de seus processos mentais de desenvolvimento de soft-ware ao aprender novas construes de linguagens.

Pode-se argumentar que aprender os recursos de outras lingua-gens no ajuda um programador forado a usar uma determinada lin-guagem que no tem tais recursos. Esse argumento no se sustenta,

Captulo 1 Aspectos Preliminares 21

porque normalmente as construes das linguagens podem ser simula-das em outras que no as oferecem suporte diretamente. Por exemplo, um programador C que aprendeu a estrutura e os usos de matrizes associativas em Perl (Wall et al., 2000) pode projetar estruturas que as simulem em C. Em outras palavras, o estudo de conceitos de lingua-gens de programao constri uma apreciao de recursos e constru-es valiosas das linguagens e incentiva os programadores a us-las, mesmo quando a linguagem utilizada no oferece suporte direto para esses recursos e construes.

Embasamento para escolher linguagens adequadas. Muitos programadores profissionais tiveram pouca educao formal em cincia da computa-o em vez disso, aprenderam programao por conta prpria ou em programas de treinamento em suas empresas. Tais programas normal-mente ensinam apenas uma ou duas linguagens diretamente relevantes para os projetos atuais da organizao. Possivelmente, muitos outros programadores receberam seu treinamento formal em um passado dis-tante. As linguagens que aprenderam na poca no so mais usadas, e muitos recursos agora disponveis em outras no eram amplamente conhecidos. O resultado que muitos programadores, quando podem escolher a linguagem para um novo projeto, continuam a usar aquela com a qual esto mais familiarizados, mesmo que ela seja pobre na sua adequao ao projeto. Se esses programadores conhecessem uma faixa mais ampla de linguagens e construes de linguagens, estariam mais capacitados a escolher a que inclui os recursos melhor adaptados s caractersticas do problema em questo.

Alguns dos recursos de uma linguagem podem ser simulados em outra. Entretanto, sempre melhor usar um recurso cujo projeto tenha sido integrado em uma linguagem do que usar uma simulao normal-mente menos elegante, de manipulao mais difcil e menos segura em uma linguagem que no suporta tal recurso.

Habilidade aumentada para aprender novas linguagens. A programao de computadores ainda uma disciplina relativamente nova e as me-todologias de projeto, ferramentas de desenvolvimento de software e linguagens de programao ainda esto em evoluo. Isso torna o de-senvolvimento de software uma profisso excitante, mas tambm exige aprendizado contnuo. O processo de aprender uma nova linguagem de programao pode ser longo e difcil, especialmente para algum que esteja confortvel com apenas uma ou duas e nunca examinou os concei-tos de linguagens de programao de um modo geral. Uma vez que um entendimento preciso dos conceitos fundamentais das linguagens tenha sido adquirido, fica mais fcil ver como esses conceitos so incorporados no projeto da linguagem aprendida. Por exemplo, programadores que entendem os conceitos de programao orientada a objetos aprendero


Java muito mais facilmente (Arnold et al., 2006) do que aqueles que nun-ca usaram tais conceitos.

O mesmo ocorre nas linguagens naturais. Quanto melhor voc co-nhece a gramtica de seu idioma nativo, mais fcil ser aprender uma segunda lngua. Alm disso, aprender uma segunda lngua tambm tem o efeito colateral benfico de ensinar a voc mais sobre a primeira.

A Comunidade de Programao TIOBE disponibiliza um ndice (http://www.tiobe.com/tiobe_index/index.htm) que funciona como in-dicador da popularidade relativa das linguagens de programao. Por exemplo, de acordo com o ndice, Java, C e C++ foram as trs linguagens mais populares em uso em outubro de 2008. Entretanto, dezenas de ou-tras linguagens foram amplamente usadas nessa mesma poca. Os dados do ndice tambm mostram que a distribuio do uso das linguagens de programao est sempre mudando. Tanto o tamanho da lista das linguagens em uso quanto a natureza dinmica das estatsticas implicam que os desenvolvedores de software devem aprender linguagens diferen-tes constantemente.

Por fim, essencial que programadores em atividade conheam o vocabulrio e os conceitos fundamentais das linguagens de programa-o para poderem ler e entender descries e avaliaes de linguagens de programao, assim como a literatura promocional de linguagens e compiladores. Essas so as fontes de informaes necessrias tanto para escolher quanto para aprender uma linguagem.

Melhor entendimento da importncia da implementao. Ao aprender os conceitos de linguagens de programao, to interessante quanto ne-cessrio abordar aspectos de implementao que afetam esses conceitos. Em alguns casos, um entendimento de questes de implementao leva a por que as linguagens foram projetadas de uma determinada forma. Esse conhecimento muitas vezes leva habilidade de usar uma lingua-gem de maneira mais inteligente e como ela foi projetada para ser usa-da. Podemos ser programadores melhores ao entender as escolhas entre construes de linguagens de programao e as consequncias dessas escolhas.

Certos tipos de erros em programas podem ser encontrados e cor-rigidos apenas por programadores que conhecem alguns detalhes de implementao relacionados. Outro benefcio de entender questes de implementao permitir a visualizao da forma como um computador executa as diversas construes de uma linguagem. Em certos casos, al-gum conhecimento sobre questes de implementao fornece dicas so-bre a eficincia relativa de construes alternativas que podem ser esco-lhidas para um programa. Por exemplo, programadores que conhecem pouco sobre a complexidade da implementao de chamadas a subpro-gramas muitas vezes no se do conta de que um pequeno subprograma chamado frequentemente pode ser uma deciso de projeto altamente ineficiente.


Como este livro aborda apenas algumas questes de implementa-o, os dois pargrafos anteriores tambm servem como uma explicao das vantagens de estudar o projeto de compiladores.

Melhor uso de linguagens j conhecidas. Muitas linguagens de programao contemporneas so grandes e complexas. incomum um programa-dor conhecer e usar todos os recursos da linguagem que ele utiliza. Ao estudar os conceitos de linguagens de programao, os programadores podem aprender sobre partes antes desconhecidas e no utilizadas das linguagens que eles j trabalham e comear a utiliz-las.

Avano geral da computao. Por fim, existe uma viso geral de computao que pode justificar o estudo de conceitos de linguagens de programao. Apesar de normalmente ser possvel determinar por que uma linguagem em particular se tornou popular, muitos acreditam, ao menos em retros-pecto, que as linguagens de programao mais populares nem sempre so as melhores disponveis. Em alguns casos, pode-se concluir que uma lin-guagem se tornou amplamente usada, ao menos em parte, porque aqueles em posies de escolha no estavam suficientemente familiarizados com conceitos de linguagens de programao.

Por exemplo, muitas pessoas acreditam que teria sido melhor se o ALGOL 60 (Backus et al., 1963) tivesse substitudo o Fortran (Metcalf et al., 2004) no incio dos anos 1960, porque ele era mais elegante e tinha sentenas de controle muito melhores do que o Fortran, dentre outras razes. Ele no o substituiu, em parte por causa dos programa-dores e dos gerentes de desenvolvimento de software da poca; muitos no entendiam o projeto conceitual do ALGOL 60. Eles achavam sua descrio difcil de ler (o que era verdade) e mais difcil ainda de enten-der. Eles no gostaram das vantagens da estrutura de blocos, da recurso e de estruturas de controle bem estruturadas, ento falharam em ver as melhorias do ALGOL 60 ao relao ao Fortran.

claro, muitos outros fatores contriburam para a falta de acei-tao do ALGOL 60, como veremos no Captulo 2. Entretanto, o fato de os usurios de computadores no estarem cientes das vantagens da linguagem teve um papel significativo em sua rejeio.

Em geral, se aqueles que escolhem as linguagens fossem mais bem informados, talvez linguagens melhores ganhassem de outras.

1.2 DOMNIOS DE PROGRAMAO

Computadores tm sido aplicados a uma infinidade de reas, desde contro-lar usinas nucleares at disponibilizar jogos eletrnicos em telefones celu-lares. Por causa dessa diversidade de uso, linguagens de programao com objetivos muito diferentes tm sido desenvolvidas. Nesta seo, discutimos brevemente algumas das reas de aplicao dos computadores e de suas lin-guagens associadas.


1.2.1 Aplicaes cientficasOs primeiros computadores digitais, que apareceram nos anos 1940, foram inventados e usados para aplicaes cientficas. Normalmente, aplicaes cientficas tm estruturas de dados relativamente simples, mas requerem diversas computaes de aritmtica de ponto flutuante. As estruturas de dados mais comuns so os vetores e matrizes; as estruturas de controle mais comuns so os laos de contagem e as selees. As primeiras linguagens de programao de alto nvel inventadas para aplicaes cientficas foram projetadas para suprir tais necessidades. Sua competidora era a linguagem assembly logo, a eficincia era uma preocupao primordial. A primeira linguagem para aplicaes cientficas foi o Fortran. O ALGOL 60 e a maio-ria de seus descendentes tambm tinham a inteno de serem usados nessa rea, apesar de terem sido projetados tambm para outras reas relaciona-das. Para aplicaes cientficas nas quais a eficincia a principal preocupa-o, como as que eram comuns nos anos 1950 e 1960, nenhuma linguagem subsequente significativamente melhor do que o Fortran, o que explica por que o Fortran ainda usado.

1.2.2 Aplicaes empresariaisO uso de computadores para aplicaes comerciais comeou nos anos 1950. Computadores especiais foram desenvolvidos para esse propsito, com lin-guagens especiais. A primeira linguagem de alto nvel para negcios a ser bem-sucedida foi o COBOL (ISO/IEC, 2002), com sua primeira verso apa-recendo em 1960. O COBOL ainda a linguagem mais utilizada para tais aplicaes. Linguagens de negcios so caracterizadas por facilidades para a produo de relatrios elaborados, maneiras precisas de descrever e armaze-nar nmeros decimais e caracteres, e a habilidade de especificar operaes aritmticas decimais.

Poucos avanos ocorreram nas linguagens para aplicaes empresariais fora do desenvolvimento e evoluo do COBOL. Logo, este livro inclui ape-nas discusses limitadas das estruturas em COBOL.

1.2.3 Inteligncia ArtificialInteligncia Artificial (IA) uma ampla rea de aplicaes computacionais caracterizada pelo uso de computaes simblicas em vez de numricas. Computaes simblicas so aquelas nas quais smbolos, compostos de nomes em vez de nmeros, so manipulados. Alm disso, a computao simblica feita de modo mais fcil por meio de listas ligadas de dados do que por meio de vetores. Esse tipo de programao algumas vezes requer mais flexibilidade do que outros domnios de programao. Por exemplo, em algumas aplicaes de IA, a habilidade de criar e de executar segmentos de cdigo durante a exe-cuo conveniente.

A primeira linguagem de programao amplamente utilizada desenvol-vida para aplicaes de IA foi a linguagem funcional LISP (McCarthy et al.,


1965), que apareceu em 1959. A maioria das aplicaes de IA desenvolvidas antes de 1990 foi escrita em LISP ou em uma de suas parentes prximas. No incio dos anos 1970, entretanto, uma abordagem alternativa a algu-mas dessas aplicaes apareceu programao lgica usando a linguagem Prolog (Clocksin e Mellish, 2003). Mais recentemente, algumas aplicaes de IA tm sido escritas em linguagens de sistemas como C. Scheme (Dybvig, 2003), um dialeto de LISP, e Prolog so introduzidas nos Captulos 15 e 16, respectivamente.

1.2.4 Programao de sistemasO sistema operacional e todas as ferramentas de suporte programao de um sistema de computao so coletivamente conhecidos como seu software de sistema. Software de sistema so aplicativos usados quase continuamente e, dessa forma, devem ser eficientes. Alm disso, tais aplicativos devem ter recur-sos de baixo nvel que permitam aos aplicativos de software se comunicarem com dispositivos externos a serem escritos.

Nos anos 1960 e 1970, alguns fabricantes de computadores, como a IBM, a Digital e a Burroughs (agora UNISYS), desenvolveram linguagens especiais de alto nvel orientadas mquina para software de sistema que rodassem em suas mquinas. Para os computadores mainframes da IBM, a linguagem era PL/S, um dialeto de PL/I; para a Digital, era BLISS, uma linguagem apenas um nvel acima da assembly; para a Burroughs, era o ALGOL Estendido.

O sistema operacional UNIX escrito quase todo em C (ISO, 1999), o que o fez relativamente fcil de ser portado, ou movido, para diferentes m-quinas. Algumas das caractersticas de C fazem que ele seja uma boa escolha para a programao de sistemas. C uma linguagem de baixo nvel, tm uma execuo eficiente e no sobrecarrega o usurio com muitas restries de se-gurana. Os programadores de sistemas so excelentes e no acreditam que precisam de tais restries. Alguns programadores que no trabalham com a programao de sistemas, no entanto, acham C muito perigoso para ser usado em sistemas de software grandes e importantes.

1.2.5 Software para a WebA World Wide Web mantida por uma ecltica coleo de linguagens, que vo desde linguagens de marcao, como XHTML, que no de programao, at linguagens de programao de propsito geral, como Java. Dada a necessi-dade universal por contedo dinmico na Web, alguma capacidade de compu-tao geralmente includa na tecnologia de apresentao de contedo. Essa funcionalidade pode ser fornecida por cdigo de programao embarcado em um documento XHTML. Tal cdigo normalmente escrito com uma lingua-gem de scripting, como JavaScript ou PHP. Existem tambm algumas lingua-gens similares s de marcao que tm sido estendidas para incluir constru-es que controlam o processamento de documentos, as quais so discutidas na Seo 1.5 do Captulo 2.


1.3 CRITRIOS DE AVALIAO DE LINGUAGENS

Conforme mencionado, o objetivo deste livro examinar os conceitos fun-damentais das diversas construes e capacidades das linguagens de progra-mao. Iremos tambm avaliar esses recursos, focando em seu impacto no processo de desenvolvimento de software, incluindo a manuteno. Para isso, precisamos de um conjunto de critrios de avaliao. Tal lista necessaria-mente controversa, porque praticamente impossvel fazer dois cientistas da computao concordarem com o valor de certas caractersticas das linguagens em relao s outras. Apesar dessas diferenas, a maioria concordaria que os critrios discutidos nas subsees a seguir so importantes.

Algumas das caractersticas que influenciam trs dos quatro critrios mais importantes so mostradas na Tabela 1.1, e os critrios propriamente ditos so discutidos nas sees seguintes1. Note que apenas as caractersticas mais importantes so includas na tabela, espelhando a discusso nas subsees seguintes. Algum poderia argumentar que, se fossem consideradas caracters-ticas menos importantes, praticamente todas as posies da tabela poderiam ser marcadas.

Note que alguns dos critrios so amplos e, de certa forma, vagos como a facilidade de escrita, enquanto outros so construes especficas de linguagens, como o tratamento de excees. Apesar de a discusso parecer implicar que os critrios tm uma importncia idntica, no o caso.

1 O quarto critrio principal o custo, que no foi includo na tabela porque apenas superfi-cialmente relacionado aos outros trs critrios e s caractersticas que os influenciam.

Tabela 1.1 Critrios de avaliao de linguagens e as caractersticas que os afetam

CRITRIOS

Caracterstica LEGIBILIDADE FACILIDADE DE ESCRITA CONFIABILIDADE

Simplicidade

Ortogonalidade

Tipos de dados

Projeto de sintaxe

Suporte para abstrao

Expressividade

Verifi cao de tipos

Tratamento de excees

Apelidos restritos


1.3.1 LegibilidadeUm dos critrios mais importantes para julgar uma linguagem de programa-o a facilidade com a qual os programas podem ser lidos e entendidos. Antes de 1970, o desenvolvimento de software era amplamente pensado em termos da escrita de cdigo. As principais caractersticas positivas das lingua-gens de programao eram a eficincia e a legibilidade de mquina. As cons-trues das linguagens foram projetadas mais do ponto de vista do computa-dor do que do dos usurios. Nos anos 1970, entretanto, o conceito de ciclo de vida de software (Booch, 1987) foi desenvolvido; a codificao foi relegada a um papel muito menor, e a manuteno foi reconhecida como uma parte principal do ciclo, particularmente em termos de custo. Como a facilidade de manuteno determinada, em grande parte, pela legibilidade dos programas, a legibilidade se tornou uma medida importante da qualidade dos programas e das linguagens de programao, o que representou um marco na sua evolu-o. Ocorreu uma transio de foco bem definida: da orientao mquina orientao s pessoas

A legibilidade deve ser considerada no contexto do domnio do proble-ma. Por exemplo, se um programa que descreve uma computao escrito em uma linguagem que no foi projetada para tal uso, ele pode no ser natural e desnecessariamente complexo, tornando complicada sua leitura (quando em geral seria algo simples).

As subsees a seguir descrevem caractersticas que contribuem para a legibilidade de uma linguagem de programao.

1.3.1.1 Simplicidade geralA simplicidade geral de uma linguagem de programao afeta fortemente sua legibilidade. Uma linguagem com muitas construes bsicas mais difcil de aprender do que uma com poucas. Os programadores que precisam usar uma linguagem grande aprendem um subconjunto dessa linguagem e igno-ram outros recursos. Esse padro de aprendizagem usado como desculpa para a grande quantidade de construes de uma linguagem, mas o argumento no vlido. Problemas de legibilidade ocorrem sempre que o autor de um programa aprender um subconjunto diferente daquele com o qual o leitor est familiarizado.

Outra caracterstica de uma linguagem de programao que pode ser um complicador a multiplicidade de recursos ou seja, haver mais de uma maneira de realizar uma operao. Por exemplo, em Java um usurio pode incrementar uma simples varivel inteira de quatro maneiras:

count = count + 1count += 1count++++count

Apesar de as ltimas duas sentenas terem significados um pouco diferentes uma da outra e em relao s duas primeiras em alguns contextos, as quatro


tm o mesmo significado quando usadas em expresses isoladas. Essas varia-es so discutidas no Captulo 7.

Um terceiro problema em potencial a sobrecarga de operadores, na qual um operador tem mais de um significado. Apesar de ser til, pode levar a uma reduo da legibilidade se for permitido aos usurios criar suas prprias sobrecargas e eles no o fizerem de maneira sensata. Por exemplo, aceitvel sobrecarregar o operador + para us-lo tanto para a adio de inteiros quanto para a adio de valores de ponto flutuante. Na verdade, essa sobrecarga sim-plifica uma linguagem ao reduzir o nmero de operadores. Entretanto, supo-nha que o programador definiu o smbolo + usado entre vetores de uma nica dimenso para significar a soma de todos os elementos de ambos os vetores. Como o significado usual da adio de vetores bastante diferente, isso tor-naria o programa mais confuso, tanto para o autor quanto para os leitores do programa. Um exemplo ainda mais extremo da confuso em programas seria um usurio definir que o + entre dois operandos do tipo vetor seja a diferena entre os primeiros elementos de cada vetor. A sobrecarga de operadores discutida com mais detalhes no Captulo 7.

A simplicidade em linguagens pode, claro, ser levada muito ao extremo. Por exemplo, a forma e o significado da maioria das sentenas de uma lingua-gem assembly so modelos de simplicidade, como voc pode ver quando consi-dera as sentenas que aparecem na prxima seo. Essa simplicidade extrema, entretanto, torna menos legveis os programas escritos em linguagem assembly.

Devido falta de sentenas de controle mais complexas, a estrutura de um programa menos bvia; e como as sentenas so simples, so necessrias mais do que em programas equivalentes escritos em uma linguagem de alto nvel. Os mesmos argumentos se aplicam para os casos menos extremos de linguagens de alto nvel com construes inadequadas de controle e de estru-turas de dados.

1.3.1.2 OrtogonalidadeOrtogonalidade em uma linguagem de programao significa que um con-junto relativamente pequeno de construes primitivas pode ser combinado a um nmero relativamente pequeno de formas para construir as estruturas de controle e de dados da linguagem. Alm disso, cada possvel combinao de primitivas legal e significativa. Por exemplo, considere os tipos de dados. Suponha que uma linguagem tenha quatro tipos primitivos de dados (inteiro, ponto flutuante, ponto flutuante de dupla preciso e caractere) e dois opera-dores de tipo (vetor e ponteiro). Se os dois operadores de tipo puderem ser aplicados a eles mesmos e aos quatro tipos de dados primitivos, um grande nmero de estruturas de dados pode ser definido.

O significado de um recurso de linguagem ortogonal independente do contexto de sua apario em um programa (o nome ortogonal vem do con-ceito matemtico de vetores ortogonais, independentes uns dos outros). A or-togonalidade vem de uma simetria de relacionamentos entre primitivas. Uma falta de ortogonalidade leva a excees s regras de linguagem. Por exemplo, deve ser possvel, em uma linguagem de programao que possibilita o uso de


ponteiros, definir que um aponte para qualquer tipo especfico definido na linguagem. Entretanto, se no for permitido aos ponteiros apontar para veto-res, muitas estruturas de dados potencialmente teis definidas pelos usurios no poderiam ser definidas.

Podemos ilustrar o uso da ortogonalidade como um conceito de proje-to ao comparar um aspecto das linguagens assembly dos mainframes da IBM com a srie VAX de minicomputadores. Consideramos uma situao simples: adicionar dois valores inteiros de 32-bits que residem na memria ou nos registradores e substituir um dos valores pela soma. Os mainframes IBM tm duas instrues para esse propsito, com a forma

A Reg1, memory_cellAR Reg1, Reg2

onde Reg1 e Reg2 representam registradores. A semntica desses

Reg1 contents(Reg1) + contents(memory_cell)Reg1 contents(Reg1) + contents(Reg2)

A instruo de adio VAX para valores inteiros de 32-bits

ADDL operand_1, operand_2

cuja semntica

operand_2 contents(operand_1) + contents(operand_2)

Nesse caso, cada operando pode ser registrador ou uma clula de memria.O projeto de instrues VAX ortogonal no sentido de que uma instru-

o pode usar tanto registradores quanto clulas de memria como operan-dos. Existem duas maneiras para especificar operandos, as quais podem ser combinadas de todas as maneiras possveis. O projeto da IBM no ortogo-nal. Apenas duas combinaes de operandos so legais (dentre quatro possi-bilidades), e ambas necessitam de instrues diferentes, A e AR. O projeto da IBM mais restrito e tem menor facilidade de escrita. Por exemplo, voc no pode adicionar dois valores e armazenar a soma em um local de memria. Alm disso, o projeto da IBM mais difcil de aprender por causa das restri-es e da instruo adicional.

A ortogonalidade fortemente relacionada simplicidade: quanto mais ortogonal o projeto de uma linguagem, menor o nmero necessrio de ex-cees s regras da linguagem. Menos excees significam um maior grau de regularidade no projeto, o que torna a linguagem mais fcil de aprender, ler e entender. Qualquer um que tenha aprendido uma parte significativa da lngua inglesa pode testemunhar sobre a dificuldade de aprender suas muitas exce-es de regras (por exemplo, i antes de e exceto aps c).

Como exemplos da falta de ortogonalidade em uma linguagem de alto nvel, considere as seguintes regras e excees em C. Apesar de C ter duas for-mas de tipos de dados estruturados, vetores e registros (structs), os registros podem ser retornados por funes, mas os vetores no. Um membro de uma


estrutura pode ser de qualquer tipo de dados, exceto void ou uma estrutura do mesmo tipo. Um elemento de um vetor pode ser qualquer tipo de dados, exceto void ou uma funo. Parmetros so passados por valor, a menos que sejam vetores, o que faz com que sejam passados por referncia (porque a ocorrncia de um nome de um vetor sem um ndice em um programa em C interpretada como o endereo do primeiro elemento desse vetor).

Como um exemplo da dependncia do contexto, considere a seguinte expresso em C

a + b

Ela significa que os valores de a e b so obtidos e adicionados juntos. Entretanto, se a for um ponteiro, afeta o valor de b. Por exemplo, se a aponta para um valor de ponto flutuante que ocupa quatro bytes, o valor de b deve ser ampliado nesse caso, multiplicado por 4 antes que seja adicionado a a. Logo, o tipo de a afeta o tratamento do valor de b. O contexto de b afeta seu significado.

Muita ortogonalidade tambm pode causar problemas. Talvez a lingua-gem de programao mais ortogonal seja o ALGOL 68 (van Wijngaarden et al.,1969). Cada construo de linguagem no ALGOL 68 tem um tipo, e no existem restries nesses tipos. Alm disso, mais construes produzem valores. Essa liberdade de combinaes permite construes extremamente complexas. Por exemplo, uma sentena condicional pode aparecer no lado es-querdo de uma atribuio, com declaraes e outras sentenas diversas, desde que o resultado seja um endereo. Essa forma extrema de ortogonalidade leva a uma complexidade desnecessria. Como as linguagens necessitam de um grande nmero de tipos primitivos, um alto grau de ortogonalidade resulta em uma exploso de combinaes. Ento, mesmo se as combinaes forem simples, seu nmero j leva complexidade.

Simplicidade em uma linguagem , ao menos em parte, o resultado de uma combinao de um nmero relativamente pequeno de construes pri-mitivas e um uso limitado do conceito de ortogonalidade.

Algumas pessoas acreditam que as linguagens funcionais oferecem uma boa combinao de simplicidade e ortogonalidade. Uma linguagem funcio-nal, como LISP, uma na qual as computaes so feitas basicamente pela aplicao de funes para parmetros informados. Em contraste a isso, em linguagens imperativas como C, C++ e Java, as computaes so normalmente especificadas com variveis e sentenas de atribuio. As linguagens funcio-nais oferecem a maior simplicidade de um modo geral, porque podem realizar tudo com uma construo, a chamada funo, a qual pode ser combinada com outras funes de maneiras simples. Essa elegncia simples a razo pela qual alguns pesquisadores de linguagens so atrados pelas linguagens funcio-nais como principal alternativa s complexas linguagens no funcionais como C++. Outros fatores, como a eficincia, entretanto, tm prevenido que as lin-guagens funcionais sejam mais utilizadas.


1.3.1.3 Tipos de dadosA presena de mecanismos adequados para definir tipos e estruturas de dados outro auxlio significativo legibilidade. Por exemplo, suponha que um tipo numrico seja usado como uma flag porque no existe nenhum tipo booleano na linguagem. Em tal linguagem, poderamos ter uma atribuio como:

timeOut = 1

O significado dessa sentena no claro. Em uma linguagem que inclui tipos booleanos, teramos:

timeOut = true

O significado dessa sentena perfeitamente claro.

1.3.1.4 Projeto da sintaxeA sintaxe, ou forma, dos elementos de uma linguagem tem um efeito significa-tivo na legibilidade dos programas. A seguir, esto dois exemplos de escolhas de projeto sintticas que afetam a legibilidade:

Formato dos identificadores. Restringir os identificadores a tamanhos mui-to curtos piora a legibilidade. Se os identificadores podem ter no mxi-mo seis caracteres, como no Fortran 77, praticamente impossvel usar nomes conotativos para variveis. Um exemplo mais extremo o ANSI* BASIC (ANSI, 1978b), no qual um identificador poderia ser formado por apenas uma letra ou por uma letra seguida de um dgito. Outras questes de projeto relacionadas ao formato dos identificadores so dis-cutidas no Captulo 5.

Palavras especiais. A aparncia de um programa e sua legibilidade so for-temente influenciadas pela forma das palavras especiais de uma lingua-gem (por exemplo, while, class e for). O mtodo para formar sen-tenas compostas, ou grupos de sentenas, especialmente importante, principalmente em construes de controle. Algumas linguagens tm usado pares casados de palavras especiais ou de smbolos para formar grupos. C e seus descendentes usam chaves para especificar sentenas compostas. Todas essas linguagens sofrem porque os grupos de senten-as so sempre terminados da mesma forma, o que torna difcil determi-nar qual grupo est sendo finalizado quando um end ou um } aparece. O Fortran 95 e Ada tornaram isso claro ao usar uma sintaxe distinta para cada tipo de grupo de sentenas. Por exemplo, Ada utiliza end if para terminar uma construo de seleo e end loop para terminar uma construo de repetio. Esse um exemplo do conflito entre a simpli-

* N. de T.: American National Standards Institute, Instituto Nacional NorteAmericano de Padres.


cidade resultante ao serem usadas menos palavras reservadas, como em C++, e a maior legibilidade que pode resultar do uso de mais palavras reservadas, como em Ada.

Outra questo importante se as palavras especiais de uma lin-guagem podem ser usadas como nomes de variveis de programas. Se puderem, os programas resultantes podem ser bastante confusos. Por exemplo, no Fortran 95, palavras especiais como Do e End so nomes vlidos de variveis, logo a ocorrncia dessas palavras em um programa pode ou no conotar algo especial.

Forma e significado. Projetar sentenas de maneira que sua aparncia ao menos indique parcialmente seu propsito uma ajuda bvia legibi-lidade. A semntica, ou significado, deve advir diretamente da sintaxe, ou da forma. Em alguns casos, esse princpio violado por duas cons-trues de uma mesma linguagem idnticas ou similares na aparncia, mas com significados diferentes, dependendo talvez do contexto. Em C, por exemplo, o significado da palavra reservada static depende do contexto no qual ela aparece. Se for usada na definio de uma varivel dentro de uma funo, significa que a varivel criada em tempo de compilao. Se for usada na definio de uma varivel fora de todas as funes, significa que a varivel visvel apenas no arquivo no qual sua definio aparece; ou seja, no exportada desse arquivo.

Uma das principais reclamaes sobre os comandos de shell do UNIX (Raymond, 2004) que a sua aparncia nem sempre sugere sua funcionalida-de. Por exemplo, o significado do comando UNIX grep pode ser decifrado apenas com conhecimento prvio, ou talvez com certa esperteza e familiari-dade com o editor UNIX ed. A aparncia do grep no tem conotao algu-ma para iniciantes no UNIX. (No ed, o comando /regular_expression/ busca uma subcadeia que casa com a expresso regular. Preceder isso com g faz ele ser um comando global, especificando que o escopo da busca o arquivo inteiro que est sendo editado. Seguir o comando com p especifica que as linhas contendo a subcadeia casada devem ser impressas. Logo g/regular_expression/p, que pode ser abreviado como grep, imprime todas as linhas em um arquivo que contenham subcadeias que casem com a expresso regular.)

1.3.2 Facilidade de escritaA facilidade de escrita a medida do quo facilmente uma linguagem pode ser usada para criar programas para um domnio. A maioria das caractersticas de linguagem que afetam a legibilidade tambm afeta a facilidade de escrita. Isso derivado do fato de que o processo de escrita de um programa requer que o programador releia sua parte j escrita.

Como ocorre com a legibilidade, a facilidade de escrita deve ser consi-derada no contexto do domnio de problema alvo de uma linguagem. No razovel comparar a facilidade de escrita de duas linguagens no contexto de uma aplicao em particular quando uma delas foi projetada para tal aplicao


e a outra no. Por exemplo, as facilidades de escrita do Visual BASIC (VB) e do C so drasticamente diferentes para criar um programa com uma interface grfica com o usurio, para o qual o VB ideal. Suas facilidades de escrita tambm so bastante diferentes para a escrita de programas de sistema, como um sistema operacional, para os quais a linguagem C foi projetada.

As sees seguintes descrevem as caractersticas mais importantes que influenciam a facilidade de escrita de uma linguagem.

1.3.2.1 Simplicidade e ortogonalidadeSe uma linguagem tem um grande nmero de construes, alguns progra-madores no estaro familiarizados com todas. Essa situao pode levar ao uso incorreto de alguns recursos e a uma utilizao escassa de outros que podem ser mais elegantes ou mais eficientes (ou ambos) do que os usados. Pode at mesmo ser possvel, conforme destacado por Hoare (1973), usar recursos desconhecidos acidentalmente, com resultados inesperados. Logo, um nmero menor de construes primitivas e um conjunto de regras con-sistente para combin-las (isso , ortogonalidade) muito melhor do que diversas construes primitivas. Um programador pode projetar uma solu-o para um problema complexo aps aprender apenas um conjunto sim-ples de construes primitivas.

Por outro lado, muita ortogonalidade pode prejudicar a facilidade de es-crita. Erros em programas podem passar despercebidos quando praticamente quaisquer combinaes de primitivas so legais. Isso pode levar a certos absur-dos no cdigo que no podem ser descobertos pelo compilador.

1.3.2.2 Suporte abstraoBrevemente, abstrao significa a habilidade de definir e usar estruturas ou operaes complicadas de forma a permitir que muitos dos detalhes sejam ignorados. A abstrao um conceito fundamental no projeto atual de lin-guagens de programao. O grau de abstrao permitido por uma linguagem de programao e a naturalidade de sua expresso so importantes para sua facilidade de escrita. As linguagens de programao podem oferecer suporte a duas categorias de abstraes: processos e dados.

Um exemplo simples da abstrao de processos o uso de um subpro-grama para implementar um algoritmo de ordenao necessrio diversas ve-zes em um programa. Sem o subprograma, o cdigo de ordenao teria de ser replicado em todos os lugares onde fosse preciso, o que tornaria o programa muito mais longo e tedioso de ser escrito. Talvez o mais importante, se o sub-programa no fosse usado, o cdigo que usava o subprograma de ordenao estaria mesclado com os detalhes do algoritmo de ordenao, obscurecendo o fluxo e a inteno geral do cdigo.

Como um exemplo de abstrao de dados, considere uma rvore binria que armazena dados inteiros em seus ns. Tal rvore poderia ser implementa-da em uma linguagem que no oferece suporte a ponteiros e gerenciamento de memria dinmica usando um monte (heap), como no Fortran 77, com o


uso de trs vetores inteiros paralelos, onde dois dos inteiros so usados como ndices para especificar ns filhos. Em C++ e Java, essas rvores podem ser implementadas utilizando uma abstrao de um n de rvore na forma de uma simples classe com dois ponteiros (ou referncias) e um inteiro. A naturalidade da ltima representao torna muito mais fcil escrever um programa que usa rvores binrias nessas linguagens do que um em Fortran 77. uma simples questo do domnio da soluo do problema da linguagem ser mais prxima do domnio do problema.

O suporte geral para abstraes um fator importante na facilidade de escrita de uma linguagem.

1.3.2.3 ExpressividadeA expressividade em uma linguagem pode se referir a diversas caractersti-cas. Em uma linguagem como APL (Gilman e Rose, 1976), expressividade significa a existncia de operadores muito poderosos que permitem muitas computaes com um programa muito pequeno. Em geral, uma linguagem expressiva especifica computaes de uma forma conveniente, em vez de dese-legante. Por exemplo, em C, a notao count++ mais conveniente e menor do que count = count + 1. Alm disso, o operador booleano and then em Ada uma maneira conveniente de especificar avaliao em curto-circuito de uma expresso booleana. A incluso da sentena for em Java torna a escrita de laos de contagem mais fcil do que com o uso do while, tambm possvel. Todas essas construes aumentam a facilidade de escrita de uma linguagem.

1.3.3 ConfiabilidadeUm programa dito confivel quando est de acordo com suas especificaes em todas as condies. As seguintes subsees descrevem diversos recursos de linguagens que tm um efeito significativo na confiabilidade dos programas em uma linguagem.

1.3.3.1 Verificao de tiposA verificao de tipos a execuo de testes para detectar erros de tipos em um programa, tanto por parte do compilador quanto durante a exe-cuo de um programa. A verificao de tipos um fator importante na confiabilidade de uma linguagem. Como a verificao de tipos em tempo de execuo cara, a verificao em tempo de compilao mais desejvel. Alm disso, quanto mais cedo os erros nos programas forem detectados, menos caro fazer todos os reparos necessrios. O projeto de Java requer verificaes dos tipos de praticamente todas as variveis e expresses em tempo de compilao. Isso praticamente elimina erros de tipos em tempo de execuo em programas Java. Tipos e verificao de tipos so assuntos discutidos em profundidade no Captulo 6.

Um exemplo de como a falha em verificar tipos, tanto em tempo de compilao quanto em tempo de execuo, tem levado a incontveis erros de


programa o uso de parmetros de subprogramas na linguagem C original (Kernighan e Ritchie, 1978). Nessa linguagem, o tipo de um parmetro real em uma chamada funo no era verificado para determinar se seu tipo casa-va com aquele do parmetro formal correspondente na funo. Uma varivel do tipo int poderia ser usada como um parmetro real em uma chamada uma funo que esperava um tipo float como seu parmetro formal, e nem o compilador nem o sistema de tempo de execuo teriam detectado a in-consistncia. Por exemplo, como a sequncia de bits que representa o inteiro 23 essencialmente no relacionada com a sequncia de bits que representa o ponto flutuante 23, se um inteiro 23 fosse enviado a uma funo que es-pera um parmetro de ponto flutuante, quaisquer usos desse parmetro na funo produziriam resultados sem sentido. Alm disso, tais problemas so difceis de serem diagnosticados2. A verso atual de C eliminou esse problema ao requerer que todos os parmetros sejam verificados em relao aos seus tipos. Subprogramas e tcnicas de passagem de parmetros so discutidos no Captulo 9.

1.3.3.2 Tratamento de exceesA habilidade de um programa de interceptar erros em tempo de execuo (alm de outras condies no usuais detectveis pelo programa), tomar medidas corretivas e ento continuar uma ajuda bvia para a confiabi-lidade. Tal facilidade chamada de tratamento de excees. Ada, C++ e Java incluem diversas capacidades para tratamento de excees, mas tais facilidades so praticamente inexistentes em muitas linguagens ampla-mente usadas, como C e Fortran. O tratamento de excees discutido no Captulo 14.

1.3.3.3 Utilizao de apelidosEm uma definio bastante informal, apelidos so permitidos quando possvel ter um ou mais nomes para acessar a mesma clula de memria. Atualmente, amplamente aceito que o uso de apelidos um recurso peri-goso em uma linguagem de programao. A maioria das linguagens permi-te algum tipo de apelido por exemplo, dois ponteiros configurados para apontarem para a mesma varivel, o que possvel na maioria das lingua-gens. O programador deve sempre lembrar que trocar o valor apontado por um dos dois ponteiros modifica o valor referenciado pelo outro. Alguns tipos de uso de apelidos, conforme descrito nos Captulos 5 e 9, podem ser proibi-dos pelo projeto de uma linguagem.

Em algumas linguagens, apelidos so usados para resolver deficincias nos recursos de abstrao de dados. Outras restringem o uso de apelidos para aumentar sua confiabilidade.

2 Em resposta a isso e a outros problemas similares, os sistemas UNIX incluem um programa utilitrio chamado lint, que verifica os programas em C para checar tais problemas.


1.3.3.4 Legibilidade e facilidade de escritaTanto a legibilidade quanto a facilidade de escrita influenciam a confiabilida-de. Um programa escrito em uma linguagem que no oferece maneiras natu-rais para expressar os algoritmos requeridos ir necessariamente usar aborda-gens no naturais, menos provveis de serem corretas em todas as situaes possveis. Quanto mais fcil escrever um programa, mais provavelmente ele estar correto.

A legibilidade afeta a confiabilidade tanto nas fases de escrita quanto nas de manuteno do ciclo de vida. Programas difceis de ler so tambm difceis de escrever e modificar.

1.3.4 CustoO custo total definitivo de uma linguagem de programao uma funo de muitas de suas caractersticas.

Primeiro, existe o custo de treinar programadores para usar a lingua-gem, que uma funo da simplicidade, da ortogonalidade da linguagem e da experincia dos programadores. Apesar de linguagens mais poderosas no necessariamente serem mais difceis de aprender, normalmente elas o so.

Segundo, o custo de escrever programas na linguagem. Essa uma fun-o da facilidade de escrita da linguagem, a qual depende da proximidade com o propsito da aplicao em particular. Os esforos originais de projetar e implementar linguagens de alto nvel foram dirigidos pelo desejo de diminuir os custos da criao de software.

Tanto o custo de treinar programadores quanto o custo de escrever pro-gramas em uma linguagem podem ser reduzidos significativamente em um bom ambiente de programao. Ambientes de programao so discutidos na Seo 1.8.

Terceiro, o custo de compilar programas na linguagem. Um grande im-peditivo para os primeiros usos de Ada era o custo proibitivamente alto da execuo dos compiladores da primeira gerao. Esse problema foi reduzido com a apario de compiladores Ada melhores.

Quarto, o custo de executar programas escritos em uma linguagem amplamente influenciado pelo projeto dela. Uma linguagem que requer mui-tas verificaes de tipos em tempo de execuo proibir uma execuo r-pida de cdigo, independentemente da qualidade do compilador. Apesar de eficincia de execuo ser a principal preocupao no projeto das primeiras linguagens, atualmente considerada menos importante.

Uma escolha simples pode ser feita entre o custo de compilao e a velocidade de execuo do cdigo compilado. Otimizao o nome dado coleo de tcnicas que os compiladores podem usar para diminuir o ta-manho e/ou aumentar a velocidade do cdigo que produzem. Se pouca ou nenhuma otimizao feita, a compilao pode ser feita muito mais rapida-mente do que se um esforo significativo for feito para produzir cdigo oti-mizado. A escolha entre as duas alternativas influenciada pelo ambiente no qual o compilador ser usado. Em um laboratrio para estudantes que esto iniciando a programao os quais geralmente compilam seus programas


diversas vezes durante o desenvolvimento, mas que usam pouco tempo de execuo de cdigo (seus programas so pequenos e precisam ser executados corretamente apenas uma vez) pouca ou nenhuma otimizao deve ser feita. Em um ambiente de produo, onde os programas compilados so executa-dos muitas vezes aps o desenvolvimento, melhor pagar o custo extra de otimizar o cdigo.

O quinto fator o custo do sistema de implementao da linguagem. Um dos fatores que explica a rpida aceitao de Java so os sistemas de com-pilao/interpretao gratuitos que estavam disponveis logo aps seu projeto ter sido disponibilizado ao pblico. Uma linguagem cujo sistema de imple-mentao caro ou pode ser executado apenas em plataformas de hardware caras tero uma chance muito menor de se tornarem amplamente usados. Por exemplo, o alto custo da primeira gerao de compiladores Ada ajudou a pre-venir que Ada tivesse se tornado popular em seus primeiros anos.

O sexto fator o custo de uma confiabilidade baixa. Se um aplicativo de software falha em um sistema crtico, como uma usina nuclear ou uma mqui-na de raio X para uso mdico, o custo pode ser muito alto. As falhas de siste-mas no crticos tambm podem ser muito caras em termos de futuros neg-cios perdidos ou processos decorrentes de sistemas de software defeituosos.

A considerao final o custo de manter programas, que inclui tanto as correes quanto as modificaes para adicionar novas funcionalidades. O custo da manuteno de software depende de um nmero de caractersticas de linguagem, principalmente da legibilidade. Como que a manuteno feita em geral por indivduos que no so os autores originais do programa, uma legibilidade ruim pode tornar a tarefa extremamente desafiadora.

A importncia da facilidade de manuteno de software no pode ser subestimada. Tem sido estimado que, para grandes sistemas de software com tempos de vida relativamente longos, os custos de manuteno podem ser to grandes como o dobro ou o qudruplo dos custos de desenvolvimento (Sommerville, 2005).

De todos os fatores que contribuem para os custos de uma linguagem, trs so os mais importantes: desenvolvimento de programas, manuteno e confiabilidade. Como esses fatores so funes da facilidade de escrita e da legi-bilidade, esses dois critrios de avaliao so, por sua vez, os mais importantes.

claro, outros critrios podem ser usados para avaliar linguagens de programao. Um exemplo a portabilidade, a facilidade com a qual os pro-gramas podem ser movidos de uma implementao para outra. A portabilida-de , na maioria das vezes, fortemente influenciada pelo grau de padronizao da linguagem. Algumas, como o BASIC, no so padronizadas, fazendo os programas escritos nessas linguagens serem difceis de mover de uma imple-mentao para outra.

A padronizao um processo difcil e consome muito tempo. Um co-mit comeou a trabalhar em uma verso padro de C++ em 1989, aprovada em 1998.

A generalidade (a aplicabilidade a uma ampla faixa de aplicaes) e o fato de uma linguagem ser bem definida (em relao completude e pre-ciso do documento oficial que define a linguagem) so outros dois critrios.


A maioria dos critrios, principalmente a legibilidade, a facilidade de escrita e a confiabilidade, no precisamente definida nem exatamente men-survel. Independentemente disso, so conceitos teis e fornecem ideias va-liosas para o projeto e para a avaliao de linguagens de programao.

Uma nota final sobre critrios de avaliao: os critrios de projeto de linguagem tm diferentes pesos quando vistos de diferentes perspectivas. Implementadores de linguagens esto preocupados principalmente com a di-ficuldade de implementar as construes e recursos da linguagem. Os usurios esto preocupados primeiramente com a facilidade de escrita e depois com a legibilidade. Os projetistas so propensos a enfatizar a elegncia e a habilida-de de atrair um grande nmero de usurios. Essas caractersticas geralmente entram em conflito.

1.4 INFLUNCIAS NO PROJETO DE LINGUAGENS

Alm dos fatores descritos na Seo 1.3, outros tambm influenciam o projeto bsico das linguagens de programao. Os mais importantes so a arquitetura de computadores e as metodologias de projeto de programas.

1.4.1 Arquitetura de computadoresA arquitetura bsica dos computadores tem um efeito profundo no projeto de linguagens. A maioria das linguagens populares dos ltimos 50 anos tem sido projetada considerando a principal arquitetura de computadores, cha-mada de arquitetura de von Neumann, cujo nome derivado de um de seus criadores, John von Neumann (pronuncia-se von Noyman). Elas so chamadas de linguagens imperativas. Em um computador von Neumann, tanto os dados quanto os programas so armazenados na mesma memria. A unidade central de processamento (CPU), que executa instrues, se-parada da memria. Logo, instrues e dados devem ser transmitidos da memria para a CPU. Resultados de operaes na CPU devem ser retor-nados para a memria. Praticamente todos os computadores digitais cons-trudos desde os anos 1940 tm sido baseados nessa arquitetura. A estrutura geral de um computador von Neumann mostrada na Figura 1.1.

Por causa da arquitetura de von Neumann, os recursos centrais das lin-guagens imperativas so as variveis, que modelam as clulas de memria; as sentenas de atribuio, baseadas na operao de envio de dados e instrues (piping); e a forma iterativa de repetio nessa arquitetura. Os operandos em expresses so enviados da memria para a CPU, e o resultado da avaliao da expresso enviado de volta clula de memria representada pelo lado esquerdo da atribuio. A iterao rpida em computadores von Neumann porque as instrues so armazenadas em clulas adjacentes de memria e repetir a execuo de uma seo de cdigo requer apenas uma simples instru-o de desvio. Essa eficincia desencoraja o uso de recurso para repetio, embora a recurso seja s vezes mais natural.


A execuo de um programa em cdigo de mquina em uma arquitetura de computadores von Neumann ocorre em um processo chamado de ciclo de ob-teno e execuo. Conforme mencionado, os programas residem na memria, mas so executados na CPU. Cada instruo a ser executada deve ser movida da memria para o processador. O endereo da prxima instruo a ser executada mantido em um registrador chamado de contador de programa. Esse ciclo pode ser descrito de maneira simples pelo algoritmo:

inicialize o contador de programarepita para sempre

obtenha a instruo apontada pelo contador de programa incremente o contador de programa para que esse aponte para a prxima instruodecodifique a instruoexecute a instruo

fim repita

O passo decodifique a instruo no algoritmo significa que a instru-o examinada para determinar que ao ela especifica. A execuo de um programa termina quando uma instruo de parada encontrada, apesar de, em um computador real, uma instruo de parada raramente ser executada. Em vez disso, o controle transferido do sistema operacional a um progra-ma de usurio para sua execuo e retorna para o sistema operacional quan-do a execuo do programa de usurio estiver completa. Em um sistema de

Unidade lgicae aritmtica

Unidadede Controle

Memria (armazena tanto instrues quanto dados)

Instrues e dados

Dispositivos deentrada e sada

Resultados deoperaes

Unidade de processamento central

Figura 1.1 A arquitetura de computadores de von Neumann.


computao no qual mais de um programa de usurio pode estar na mem