Aula 0

• compila para um arquivo auto-contido que roda na plataforma de destino: – C com compilação estática
• cada linha do programa é interpretada (+tabela de símbolos) – BASIC, Bash (sh, csh)

for i in {0..9}
do
ssh -N  -L 900${i}:${nos[${i}]}:22 wainer@ssh.recod.ic.unicamp.br &
pid[${i}]=$!
sleep 1
done
echo -n ${pid[@]} > ~/.pidssh

• interpretado precisa processar a linha "pid[\\({i}]=\\)!" 9 vezes onde processar significa – fazer a analise sintática e descobrir se há erros – entender o comando – fazer o que o comando manda: computa o pid do processo (\$!) e

atribui à entrada i do array pid

• analise sintática: os comandos estao corretos
• analise semântica: arvore de operações/comandos
• otimização não especifica da arquitetura. ex: invariantes fora do loop

i = 0
for x in lista:
    i = 1

i = 0
for x in lista:
    pass
i=1

i = 0
i = 1

i = 1

• otimização especifica de arquitetura: registradores
• geração de código de maquina

1. compila para um arquivo mas ele não é auto-contido, bibliotecas – C com compilação dinâmica
2. "compila" para uma "linguagem de maquina" que não roda no hardware mas precisa de um "interpretador" – Java com o JRE (interpretador) – byte-code – todas as tarefas de um compilador sem a otimização especifica
3. analisa a sintaxe do programa inteiro, faz a análise semântica, converte para uma "linguagem de maquina" falsa, que precisa de um interpretados, mas o interpretador e o compilador são o mesmo programa – Python, Perl, Lisp

1.5) Compila para linguagem de maquina apenas alguns trechos que codigo que sao auto-contidos e são usados muito – Java com compilação JIT (de métodos) – Lisp com compilação de algumas funções e não outras

• variáveis tem tipo e ele é fixo - e normalmente declarado mas não NECESSARIAMENTE
• C, Java
• se a variável tem tipo, é possível em tempo de compilação definir exatamente o que fazer com uma operação na variável

a+b

isso é uma soma (inteiros? reais? complexos?) ou uma concatenação (Python)

• a linguagem pode ser estática mas não ter declaração de variáreis. O compilador infere o tipo da primeira atribuição e não permite que valores de outros tipos sejam atribuídos a essa variável. (veremos em Haskell)
• OO estraga esse conhecimento em tempo de compilação do que deve ser feito

public class A {
  public void m() {
    System.out.println("Hello World!");
  }
}

public class B extends A {
  public void m() {
    System.out.println("Bye World!");
  }
}

A x;

... x = new A()  ou x = new B()

x.m();

• dados tem tipos, e variáveis apontam para dados

x=4
x="qwerty"
x=[3,4,5]

• tipagem dinâmica é mais lenta – indireção – decisão em tempo de execução o que fazer – gasta mais memória (apontador + tags)
• tipagem dinâmica é útil em modo iterativo
• tipagem estática garante uma programação mais segura

def soma(a,b)
  return 4*(a+b)
  ou  return (a+b)/4

soma(3,4)
soma("casa","azul")

• linguagens dinâmicas estão cada vez mais permitindo declaração/hints de tipo para argumentos de funções! Python Mas ainda não esta claro o que o interpretador faz com essas declarações

Em C, lista ligada de inteiros e de float são códigos diferentes, apenas por causa das declarações dos argumentos das funções, o resto do codigo é igual

struct IntLinkedList{
    int data;
    struct IntLinkedList *next;
 };

typedef struct LinkedList *inode;

struct FloatLinkedList{
    float data;
    struct FloatLinkedList *next;
 };

typedef struct LinkedList *fnode;

inode addiNode(inode head, int value){
...}

fnode addfNode(fnode head, float value){
...}

• parametric typing

struct LinkedList(X){
    X data;
    struct IntLinkedList *next;
 };

typedef struct LinkedList(X) *node(X);

node(X) addNode(node head, X value){
...}

um exemplo real e mais simples em C++

template <class T>
T max(T a, T b) {
 return a > b ? a : b;
}

• mas o tipo T precisa ser um que aceira a comparação \(>\). Restrições nos tipos
• veremos isso em Haskell

• Go (golang) - da google
• Scala (prog funcional + oo)
• Julia (Python-like, R-like mas compilado)
• F# ou OCaml (prog funcional menos complexa/pura que Haskell)
• Ruby (ruby-on-rails)
• R (data science)
• Erlang (paralelo)
• Rust
• Swift (IOs)
• Perl (bioinformatica)
• Kotlin (Android)
• FORTRAN (computação científica)

• Prolog
• PHP
• SQL