Conceitos de Linguagens de Programação

MATA56 - Paradigmas de Linguagens de Programação

Universidade Federal da Bahia

Prof. Rodrigo Rocha <rodrigo@dcc.ufba.br>

Formas de implementação

Compilada: código-fonte => código nativo
- Ex.: .c => .exe
Interpretada: código-fonte
- Ex.: Python, Ruby
Híbrida: código-fonte => representação intermediária
- Ex.: .java => .class (bytecode)
- Ex.: .py => .pyc

É uma característica da implementação da linguagem. Ex.: existem compiladores e interpretadores de C.

Responsabilidades

Um compilador/interpretador deve:
- reconhecer código-fonte válido
- informar erros no código-fonte
- gerar código executável ou intermediário

Sintaxe

Se refere à forma de escrever código-fonte válido na linguagem de programação
É o que diz se uma linguagem de programação vai ser bonita (legível, fácil de escrever...)

Pascal
if c then begin b1 end else begin b2 end
C
if (c) { b1; } else { b2; }

LISP

(if c b1 b2)

Haskell

e | c = b1 | c2 = b2 | otherwise = b3

Fonte: http://rigaux.org/language-study/syntax-across-languages/CntrFlow.html#CntrFlowIfTheEls

código-fonte

(sintaxe concreta)

análise

léxica

sintática

árvore de sintaxe abstrata

(AST)

gerador

código-objeto

frontend

backend

Sintaxe concreta e abstrata

Sintaxe concreta: detalhamento caractere a caractere de como escrever programas
- if (expr) { ... }
Sintaxe abstrata: descreve a estrutura do programa (geralmente por meio de uma árvore)

Analisador léxico (lexer)

Identifica os elementos da linguagem presentes no código-fonte.
- Converte uma sequência de caracteres em uma sequência de tokens
- Ex.: i, f, (, n, u, m, =, =, 1, ) ==>
  INSTR_IF, ABRE_PARENTESES, IDENTIFICADOR (num), COMPARADOR_IGUALDADE, LITERAL_NUMERICO (1), FECHA_PARENTESES

Analisador léxico (lexer)

A especificação dos tokens da linguagem é geralmente feita usando-se expressões regulares
Ex.:
- LITERAL_NUMERICO: [0-9]+
- LITERAL_STRING: ".*?"
- COMPARADOR_IGUALDADE: ==
- IDENTIFICADOR: [a-zA-Z_][a-zA-Z0-9_]*
- INSTR_IF: if

Analisador sintático (parser)

Um parser obtém como entrada uma sequência de tokens (saída do lexer) e gera uma árvore de sintaxe abstrata de acordo com uma gramática (geralmente escrita no formato BNF ou EBNF)
Ex.:
- STMT_IF ::= INSTR_IF, ABRE_PARENTESES, EXPR, FECHA_PARENTESES, STMT
- ATRIBUICAO ::= IDENTIFICADOR, OP_ATRIB, EXPR
Nesse passo pode-se detectar erros no código
- Ex.: o programa "if if" é inválido, pois a gramática define que depois do if tem de vir um abre-parênteses.

Analisador sintático (parser)

Árvore de sintaxe abstrata (abstract syntax tree, AST)

Analisador sintático (parser)

Problema do else pendente

Semântica

Se refere à interpretação do significado de um programa
Um programa pode ser sintaticamente bem-formado mas ser semanticamente inválido
Algumas questões sobre semântica:
- O identificador "pi" é uma variável? uma função? uma constante?
- A variável x é declarada antes de usar?
- Existe código que nunca é executado?
- A expressão if true then s1() else s2() pode ser simplificada?
- Quais os tipos das variáveis na expressão a + b? O operador + está definido para esses tipos?

Identificadores

Identificadores são nomes dados a vários elementos de um programa, tais como variáveis, constantes, tipos e funções
Cada linguagem define suas regras para identificadores:
- número máximo de caracteres?
- diferencia maiúsculas e minúsculas?
- quais os caracteres permitidos?
- palavras-chave (if, while, for...) podem ser usadas como identificadores? Se não, dizemos que as palavras-chave são palavras reservadas.
- Ruby: variáveis começam com minúscula; constantes começam com maiúscula

Tabela de símbolos

Estrutura de dados usada pelo interpretador ou compilador que guarda informações sobre os identificadores no código-fonte de um programa

outros atributos: posição na memória, tamanho (array, strings), número e tipo dos argumentos (funções)...

Variáveis

Variável = célula de memória + identificador
Assume um valor que pode mudar com o tempo
Características: nome, endereço, valor, tipo, tempo de vida e escopo

L-value e R-value

Considere a atribuição:
x = x + 1;
As duas ocorrências de x representam coisas diferentes:
- L-value (left-value): o primeiro x denota a posição de memória onde o resultado será armazenado
- R-value (right-value): o segundo x denota o conteúdo da memória antes do cálculo da expressão
Em alguns compiladores, a expressão (x+1) = 5 resulta no erro de compilação "L-value required"

Vinculação

Uma vinculação (amarração ou binding) é uma associação entre entidades de programação. Ex.:
- Variável e valor
  - Ex.: a variável x tem valor 5
- Identificador e tipo
  - Ex.: o identificador x é uma variável
- Símbolo matemático e operação correspondente
  - Ex.: operação de soma e símbolo +

Tempo de vinculação

Momento em que uma vinculação é feita. Pode ser:
- vinculação estática
  - tempo de projeto de linguagem
  - tempo de implementação da linguagem
  - tempo de compilação
  - tempo de carga
- vinculação dinâmica
  - tempo de execução

Tempo de vinculação

Exemplo (Java): count = count + 5;
- o tipo de count é vinculado em tempo de compilação
- o significado do operador + é vinculado em tempo de compilação (pode ser soma ou concatenação)
- o valor de count é vinculado em tempo de execução

Tempo de vida (variável)

É o tempo em que uma variável fica vinculada a uma posição de memória
Quanto ao tempo de vida, as variáveis podem ser
- estáticas
- stack-dinâmicas
- heap-dinâmicas

Variáveis estáticas

São alocadas (i.e., vinculadas a uma posição de memória) antes do início da execução do programa e desalocadas somente com o término do programa.
Ex.: variáveis static em C:
- void incrementa() {
- static int x = 0;
- x++;
- printf("%d\n", x);
- }
Ex.: variáveis globais
Vantagem: eficiência no acesso (posição fixa), só aloca uma vez
Desvantagem: ocupa memória mesmo quando não está sendo usada

Variáveis stack-dinâmicas

O armazenamento é vinculado (i.e., a variável é alocada) em tempo de execução, no momento da declaração da variável
Todas as variáveis stack-dinâmicas compartilham uma região de memória, a pilha (stack, last in first out)
Ex.: variáveis locais de funções em C (são alocadas no início da execução da função e desalocadas no final)
int somatorio(int n) {
int i, soma = 0;
for (i = 0; i < n; i++) { soma += i; }
return soma;
}

Variáveis heap-dinâmicas

Variáveis alocadas/desalocadas em tempo de execução, em uma área chamada heap
Podem ser alocadas e desalocadas a qualquer momento, não precisar seguir last in, first out
Flexível o suficiente para construir estruturas de dados dinâmicas (listas encadeadas, árvores etc.)
Ex.: malloc/free em C, new/garbage collector em Java
Riscos:
- ponteiro pendente: desaloca memória, mas ainda há ponteiro para aquela posição
- vazamento de memória: a memória ainda está alocada, mas nenhum ponteiro aponta para ela
- compartilhamento: dois ponteiros apontam para a mesma posição de memória

https://en.wikipedia.org/wiki/Memory_safety

Gerenciamento de memória (da heap)

Manual: programador é responsável por desalocar a memória alocada (ex. em C: malloc/dispose)
- Bom: maior controle
- Ruim: fácil cometer erros (ex.: ponteiro pendente)
Coleta de lixo (garbage collection): automaticamente libera memória que não está sendo usada pelo programa
- Bom: menor preocupação do programador
- Ruim: menor controle

Garbage collection por contagem de referência

Cada variável tem um contador, que é incrementado quando é referenciada e decrementado quando deixa de ser referenciada. Ao atingir 0, é desalocada.
- Ex.: Swift: automatic reference counting (ARC)
  - referências weak, strong e unowned
- Ex.: Objective-C 1.x: [var retain], [var release]
Risco: referências circulares
O programador ainda precisa ter algum conhecimento do seu funcionamento para escrever um programa

Garbage collection por contagem de referência

Garbage collection por tracing

Muitas vezes chamado simplesmente de garbage collection
Periodicamente o garbage collector (GC) libera células de memória que não podem ser acessadas através de uma busca em grafo.
O programador pode forçar a execução do GC
Bom: o programador quase não precisa se preocupar com gerenciamento de memória
Bom: evita ponteiros pendentes e certos vazamentos de memória
Ruim: o GC pode ser demorado e causar "soluços" imprevisíveis na aplicação

Garbage collection por tracing

Escopo e ambiente de referenciamento

O escopo de um nome é a região do programa no qual o nome é visível, isto é, pode ser referenciado
- Ex.: nomes de variáveis, nomes de funções
Na maioria das linguagens, o escopo de uma variável é determinado estaticamente (i.e., antes da execução do programa)

Escopo

var glob = 123;     // 1
console.log(glob);  // 2
function teste() {  // 3
    var x = 2;      // 4
    console.log(x); // 5
}                   // 6
glob = 456;         // 7

Qual o escopo da variável glob?

Qual o escopo da variável x?

Escopo

var glob = 123;     // 1
console.log(glob);  // 2
function teste() {  // 3
    var x = 2;      // 4
    console.log(x); // 5
}                   // 6
glob = 456;         // 7

glob tem escopo global: é acessível de qualquer parte do programa, a princípio (existem exceções, como veremos)

x tem escopo local: só é acessível no bloco de código da função teste.

Ambiente de referenciamento

var glob = 123;     // 1
console.log(glob);  // 2
function teste() {  // 3
    var x = 2;      // 4
    console.log(x); // 5
}                   // 6
glob = 456;         // 7

Qual é o ambiente de referenciamento da linha 7?

E da linha 5?

É o conjunto de nomes visíveis em uma região do programa.

/* 1  */ var glob = 1;
/* 2  */ 
/* 3  */ function externa() {
/* 4  */     var xext = 2;
/* 5  */ 
/* 6  */     function interna() {
/* 7  */         var xint = 3;
/* 8  */         console.log(xext);
/* 9  */     }
/* 10 */     interna();
/* 11 */ }
/* 12 */ externa();

JavaScript permite funções aninhadas ==> escopos aninhados.

O que vai acontecer ao executar a linha 8?

A variável xext faz parte do amb. de referenciamento da linha 8?

/* 1  */ var x = 1;
/* 2  */ 
/* 3  */ function externa() {
/* 4  */     var x = 2;
/* 5  */ 
/* 6  */     function interna() {
/* 7  */         var x = 3;
/* 8  */         console.log(x);
/* 9  */     }
/* 10 */     interna();
/* 11 */ }
/* 12 */ externa();

Na linha 8, o nome x se refere à variável declarada em qual linha?

/* 1  */ var x = 1;
/* 2  */ 
/* 3  */ function externa() {
/* 4  */     var x = 2;
/* 5  */ 
/* 6  */     function interna() {
/* 7  */         var x = 3;
/* 8  */         console.log(x);
/* 9  */     }
/* 10 */     interna();
/* 11 */ }
/* 12 */ externa();

A declaração de x na linha 4 mascara a variável x da linha 1 (sombreamento)

Qual o escopo das diferentes vinculações de x?

Tipos

Um tipo (de dados) determina
- um conjunto de valores possíveis,
- as operações que podem ser feitas sobre o tipo
- o significado
- e a forma de armazenamento
Ex.: unsigned short int (em C)
- valores: de 0 a 65535
- operações: +, -, *, /, %, ==, !=, <, <=, dentre outros
- significado: número inteiro
- armazenamento: 2 bytes
  - a implementação define endianness (ordem dos bytes)

Tipos

Podem ser:
- embutidos/predefinidos
- customizados/definidos pelo usuário
  - ex.: structs, enums, classes
Podem ser:
- primitivos
  - ex.: int, float, char
- compostos: definidos a partir dos primitivos
  - ex.: string (char *), arrays, structs
- Ex. em Java: int é primitivo, Integer não

Tipos

Podem ser:
- numéricos (inteiro, ponto flutuante, decimal)
- booleanos
- caracter
- ordinais (inclui os anteriores)
  - enumeração. Permite <, >, =. Ex. (Pascal):
    - type colortype = (red, green, blue);
    - enums em C e Java
  - subrange. subsequência de um tipo ordinal
    - ex.: type tx = 1..10; upcase = 'A'..'B'

Tipos

Podem ser:
- mutáveis: o valor pode ser alterado após inicialização
  - Ex.: NSMutableArray (Objective C)
  - Ex.: listas em JavaScript, Ruby, Python
- imutáveis: o valor não pode ser alterado
  - Ex.: String em Java
  - Ex.: NSArray (Objective C)
  - Ex.: tuplas em Python
Atenção: um tipo imutável pode conter valores mutáveis (ex.: tuplas contendo listas)

Tipo String

Vetor de caracteres ou primitivo
Como calcular o comprimento?
- C usa byte 0 para indicar término - O(n)
- BASIC armazena contagem de caracteres - O(1)
- Pascal preenche string com espaços
Concatenação de strings (A + B). Ex. (Java):
- "Não use + para concatenar strings!"
- Strings são imutáveis; A + B gera nova string
- StringBuffer: concatenação nem sempre gera nova alocação de memória

Tipo Array

É um tipo composto homogêneo, i.e., os elementos são do mesmo tipo
Os elementos são indexados
- C: a partir de 0
- R: a partir de 1
- Pascal: arbitrário (você escolhe)
Podem ser uni ou multidimensionais (matrizes)
- Matrizes: row major vs column major order
JavaScript, Python e Ruby possuem listas, que são tipos compostos heterogêneos (pode misturar elementos de tipos diferentes)
Tipo set/conjunto: não admite elementos repetidos

Tipo array associativo

Estrutura chave-valor
Também chamado de dicionário, hash, mapa
Ex.:
{"pedra": "ametista",
"cor": "amarelo",
"tamanho": 4}

Outros:

Tipo registro (struct em C)
- Tipo composto heterogêneo
Tipo union
Tipo ponteiro, tipo referência
Tipos genéricos (Java) / templates (C++):
- Ex.: Array<Integer>, HashMap<String, Integer>

Vinculação de tipos

Pode ser
- estática. Os tipos das variáveis podem ser determinados sem executar o programa.
  - ex.: Java, C
- dinâmica. O tipo é definido em tempo de execução.
  - ex.: Python, Ruby
Pode ser
- explícita. Os tipos são declarados.
  - int x; String y;
- implícita. Os tipos não são declarados.
  - if (random()) x = a; else x = b. <== vinculação dinâmica
  - x = 1. Em algumas linguagens pode-se inferir o tipo estaticamente, em tempo de compilação

Tipificação: forte vs. fraca

Ou tipagem. As definições são imprecisas
Forte: consegue detectar a maioria dos erros de tipo
- ex.: "3" + 2 (tipo string + tipo inteiro)
- ex.: int *x; float *y; x = y; ... *x; (ponteiro)
- ex.: char x[10], y[20]; strcpy(x, y); (buffer overflow)
- ex.: printf("%s", 12)
- ex.: int x = 3.5 + 1; (truncamento)
- ex.: acesso de ponteiro nulo
Fraca: contrário de forte
Note que uma linguagem pode ter tipificação dinâmica e forte. Ex.:
- a = "3"
- b = 2
- c = a + b <== erro em tempo de execução

Tipificação: forte vs. fraca

Gotchas
- JavaScript
  - http://www.codeproject.com/Articles/182416/A-Collection-of-JavaScript-Gotchas
  - http://brian.io/slides/dotjs-2012/
  - "3" + 2
  - "3" - 2
  - 0.1 + 0.2

Conversão de tipos

Às vezes é necessário converter o tipo de um dado (ex.: expressões com tipos mistos)
Pode ser
- explícita (cast). Ex.: int x; float y = (float)x / 2;
  - Ex. (Ruby): 1.to_f / 2.0
- implícita (coerção). Ex.: int a = 1; float b = 0.5, c = a + b;
Pode ser
- ampliadora (widening, >) - conversão para um tipo que inclui (ao menos aproximadamente) o tipo original. Ex.: int => float
- redutora (narrowing, <) - o contrário. Ex.: float => int (perde informação!)
Java: boxing (int => Integer) e unboxing (Integer => int)

Subrotinas

Uma subrotina ou subprograma é uma sequência de instruções empacotadas como uma unidade
A depender do contexto, são chamadas de procedimentos, funções, rotinas, métodos...
Possuem um cabeçalho: nome, tipo de retorno, lista de parâmetros

Parâmetros

Considere a declaração:
- int soma(int a, int b)
- a e b são parâmetros formais da função soma
Considere a chamada:
- int x = soma(3, 4);
- 3 e 4 são parâmetros reais ou argumentos da chamada à função soma

Vinculação entre parâmetros e argumentos

A vinculação entre argumentos e parâmetros geralmente se dá por posição (1o parâmetro recebe o 1o argumento etc.). Ex.:soma(3, 4)
Algumas linguagens admitem parâmetros nomeados, de forma que os argumentos podem ser passados em qualquer ordem. Ex.:soma(b=4, a=3)
Algumas linguagens permitem parâmetros opcionais com valores default. Ex.: soma(b=4) ou soma(3).
Algumas linguagens permitem número variável de argumentos. Ex.: soma(1, 2, 3, 4, 5, 6, 7).

Passagem de parâmetros

Existem diversos mecanismos para passagem de parâmetros durante a chamada, de acordo com 2 dimensões:
- o valor é transferido para a função (in) vs o valor é transferido da função para o chamador (out) ou ambos (inout)
- o valor é copiado para a função vs. uma referência é passada para a função

Passagem de parâmetros

Chamada por valor: o argumento é avaliado e copiado para a subrotina (in)
Chamada por referência: uma referência para o argumento é passada para a subrotina (in/out)
Chamada por valor-resultado: o argumento é copiado para a subrotina e, ao fim de sua execução, é copiado de volta para o chamador (in/out). Ex.: rede

Passagem de parâmetros

C#: palavra-chave ref para passar por referência.
Passagem por referência é mais rápida e usa menos memória para objetos grandes. E se eu quiser passar por referência mas não ter o comportamento in/out?
C++: palavra-chave const
C tem passagem por referência?
Exemplo clássico de passagem por referência: função swap (troca).
Java usa passagem por valor ou por referência? Exemplo de função que recebe uma lista e adiciona um elemento a ela.

Avaliação estrita vs preguiçosa

Todos esses casos são estratégias de avaliação estrita: os argumentos de uma função são avaliados antes da chamada da função.
Considere o seguinte exemplo em C:
- 1 + 1 == 2 ? printf("A") : printf("B");
- Se pensarmos no operador ternário (?:) como uma função de três parâmetros, ela segue uma avaliação estrita?
- ternario(1 + 1 == 2, printf("A"), printf("B"))
- Como criar a função ternario em C?

Passagem de parâmetros

Avaliação não-estrita: os argumentos são avaliados apenas seu valor é requisitado. Aplicação: listas infinitas. Alguns tipos:

Chamada por nome: o texto do argumento é passado como parâmetro e avaliado dentro da função (in/out). Usado em Scala. Ver exemplo. #define em C. Aplicação: logging.
Chamada por necessidade: igual ao anterior, mas avalia parâmetro só uma vez (faz caching do resultado). Ex.: função fibonacci recursiva.

Funções como valores

Nas linguagens com suporte ao paradigma funcional, uma função é um valor (assim como números, strings etc.)
Nesse caso dizemos que funções são cidadãos de primeira classe
Isso significa que é possível
- atribuir uma função a uma variável
- passar uma função como parâmetro para outra
- criar funções que retornam funções
Esse tópico será detalhado na unidade sobre programação funcional

Sobrecarga de subrotinas

A sobrecarga ocorre quando há duas ou mais funções com o mesmo nome dentro do mesmo ambiente de referenciamento
A função chamada depende da lista de parâmetros
- número de parâmetros
- tipo dos parâmetros

Sobrecarga de subrotinas

Considere as duas declarações a seguir:
1. int soma(int a, int b)
2. float soma(float a, float b)
Uma chamada a soma(3, 5) invocará qual das funções?
E se for soma(3, 5.0f)? E se for soma(x, y), onde x e y são do tipo double?

Sobrecarga de subrotinas

Considere as duas declarações a seguir:
1. int fibonacci(int n);
2. long fibonacci(int n);
Considere a seguinte chamada:
- long x = fibonacci(10)
Qual das funções será chamada? E se a chamada for:
- float x = fibonacci(10)
Em C, não há como distinguir funções somente pelo tipo de retorno.

Ecossistema da linguagem

Bibliotecas e frameworks (ex.: rails, junit)
Automação de build (ex.: make, ant)
Gerenciamento de dependências (ex.: maven)
Documentação de APIs (ex.: javadoc)
Gerenciador de instalações (ex.: rvm)
Outros
- Analisador de código (ex.: sonar)
- Integração contínua (ex.: jenkins, travis)