Diário de Bordo

Programação Funcional Contemporânea - Segundo Semestre de 2011

	Agosto
	Setembro

	Outubro
	Novembro

Dezembro

Esta página estará em permanente construção até o final do semestre...

Agosto

9 de agosto (aula 1):
- Apresentação da disciplina. Motivação.
- Visão inicial (e bem geral) da programação funcional.
- Breve histórico das linguagens funcionais.
- Introdução à linguagem Erlang (capítulo 2 do Armstrong, até 2.9):
  - Números e operações aritméticas
  - "Variáveis" com atribuição única (single assignment variables)
  - Átomos
  - Tuplas. Uso de casamento de padrões para extrair os campos anônimos de uma tupla.
11 de agosto (aula 2):
- Introdução à linguagem Erlang (capítulo 2 do Armstrong, de 2.9 a 2.12):
  - Tuplas (continuação), listas, strings.
  - Casamento de padrões.
- Programação sequencial em Erlang (capítulo 3 do Armstrong, até 3.2):
  - Módulos e funções.
  - Processamento de listas. O exemplo da lista de compras.
16 de agosto (aula 3):
- Programação sequencial em Erlang (continuação):
  - Funções com mesmo nome e número de argumentos ("arity") diferente.
  - Recursão de cauda (tail recursion).
  - Funções anônimas (funs).
  - Funções (de ordem superior) que recebem funções como argumentos.
  - Funções (de ordem superior) que devolvem funções.
  - Uso de funções de ordem superior para definir abstrações de controle de fluxo.
  - Uso de funções de ordem superior em processamento de listas.
  - List comprehensions. Exemplos: quicksort e triplas pitagóricas.
  O material visto foi o capítulo 3 do Armstrong, da seção 3.3 à 3.6 (paramos antes do exemplo Anagrams), mais as observações sobre recursão de cauda.
18 de agosto (aula 4):
- Programação sequencial em Erlang (continuação):
  - Mais um exemplo de uso de list comprehensions: anagramas.
  - Guardas (guards).
  - Comentário rápido sobre os records de Erlang: são uma maneira de associar um nome a cada campo de uma tupla.
  - A expressão case. Exemplo de uso: função filter(P,L).
  - A expressão if. Uso da guarda true em expressões if.
  - Observações sobre a implementação típica de listas imutáveis numa linguagem funcional. Complexidade das operações de construção de lista ([H|T]) e de concatenação (L1 ++ L2) de listas.
  - Construção eficiente de listas. Uso de acumuladores.
  - Built-in functions (BIFs) de Erlang.
  - Binaries. As duas formas de uso de binaries:
    - Por meio das BIFs term_to_binary(Term) e binary_to_term(Bin), que oferecem funcionalidade análoga à da seriação Java.
    - Por meio da bit syntax, que permite controle total sobre o empacotamento/desempacotamento de dados.
  - Referências a funções (function references).
  - Operadores booleanos com avaliação "normal" (and e or, que têm funcionamento diferente dos operadores correspondentes de C e de Java) e com avaliação em curto circuito (andalso e orelse, que funcionam como os operadores booleanos de C e de Java).
  O material visto foi o restante do capítulo 3 do Armstrong (a partir do exemplo Anagrams ao final da seção 3.6, menos os detalhes sobre records na seção 3.9), as observações (que não aparecem no texto do Armstrong) sobre a implementação de listas imutáveis e sobre a complexidade das operações com listas, o início do capítulo 5 do Armstrong (até a seção 5.2, mais um comentário rápido sobre o poder da bit syntax descrita na seção 5.3), e os itens Function References, Booleans, Boolean Expressions e Short-Circuit Boolean Expressions da seção 5.4.
23 de agosto (aula 5):
- Programação sequencial em Erlang (continuação):
  - A BIF apply(Mod, Func, [Arg1, ..., ArgN]) (item apply da seção 5.4 do Armstrong).
- Exceções em Erlang (capítulo 4 do Armstrong).
- Execução de programas Erlang previamente compilados e acesso aos argumentos passados a um programa na linha de comando (seção 6.3 do Armstrong).
- Introdução ao modelo de concorrência de Erlang (capítulo 7 do Armstrong). Contextualização: o modelo de atores (os processos de Erlang são atores).
- Comparação entre a abordagem mais usada pelas JVMs para implementar threads (cada thread Java corresponde a uma thread do sistema operacional) e a usada pelas VMs de Erlang para implementar processos/atores (muitos processos Erlang rodam numa mesma thread do sistema operacional). Vantagens e desvantagens de cada abordagem.
25 de agosto (aula 6):
- Programação concorrente em Erlang:
  - As primitivas de concorrência:
    - Pid = spawn(Fun)
    - Pid ! Msg
    - receive ... end
  - Exemplo de uso das primitivas de concorrência.
  - Uma aplicação cliente/servidor simples. RPC.
  - A importância da recursão de cauda para a implementação de servidores.
  - Qual é o custo da criação de um processo?
  - Recepção de mensagens com temporização.
    - Exemplo: função sleep(Time)
  O material visto foi o capítulo 8 do Armstrong, até o início da seção 8.5, mais a seção 8.9.
30 de agosto (aula 7):
- Programação concorrente em Erlang:
  - Exemplos de recepção de mensagens com temporização:
    - função flush_mailbox()
    - função priority_receive()
    - temporizador simples
  - O funcionamento da primitiva receive ... end.
  - Registro de processos. Exemplo: processo registrado que representa um relógio.
  - Esqueleto inicial de um programa concorrente.
  - Outra forma de spawn: spawn(Mod, FuncName, Args)
  O material visto foi o restante do capítulo 8 do Armstrong, da seção 8.5 ao final do capítulo.
- Mais programação concorrente em Erlang:
  - Tradução para Erlang de uma classe Java que implementa um contador incrementável atomicamente.
  - Um módulo "servidor genérico".
  - Uma nova implementação do contador incrementável atomicamente, agora empregando o servidor genérico.
  Esse material é do artigo Erlang for Concurrent Programming, de Jim Larson, publicado na ACM Queue de outubro de 2008 (a primeira versão do artigo) e na Communications of the ACM de março de 2009 (a segunda versão do artigo).

Setembro

1 de setembro (aula 8):
- Arquitetura de Erlang para tratamento de erros em programas concorrentes:
  - Conceitos fundamentais:
    - Ligações (links) entre pares de processos. O conjunto de processos ligados a um dado processo (link set do processo).
    - Sinais de saída (exit signals).
    - Captura de sinais de saída (o flag trap_exit) e a noção de "processo de sistema".
  - Primitivas para tratamento de erros em programas concorrentes:
    - spawn_link(Fun)
    - process_flag(trap_exit, true)
    - link(Pid)
    - unlink(Pid)
    - exit(Why)
    - exit(Pid, Why)
  - Utilização desses conceitos e dessas primitivas:
    - Função on_exit, que instala um exit handler.
    - Possibilidade de tratamento remoto de erros.
    - Três esquemas simples (programming idioms) para lidar com erros em programas concorrentes.
  O material visto foi o capítulo 9 do Armstrong, até a seção 9.5.
13 de setembro (aula 9):
- Conjuntos de processos interligados (seção 9.6 do Armstrong).
- Programação distribuída em Erlang:
  - Erlang distribuído:
    - O conceito de nó (node) Erlang.
    - Exemplo: servidor de nomes simples.
      - Cliente e servidor no mesmo nó.
      - Cliente e servidor em nós diferentes na mesma máquina.
      - Cliente e servidor em máquinas diferentes na mesma rede local.
      - Cliente e servidor em máquinas diferentes na Internet.
    - Primitivas de distribuição:
      - spawn(Node, Fun)
      - spawn(Node, Mod, Func, Arglist)
      - spawn_link(Node, Fun)
      - spawn_link(Node, Mod, Func, Arglist)
      - node()
      - node(Arg)
      - nodes()
    - Uso da primitiva send (!) no Erlang distribuído: Pid ! Msg ou {RegName, Node} ! Msg.
  O material visto foi o capítulo 10 do Armstrong, até a seção 10.2 (paramos antes do exemplo de spawn remoto).
15 de setembro (aula 10):
- Programação distribuída em Erlang (continuação):
  - Erlang distribuído (continuação):
    - Exemplo de spawn remoto.
    - Proteção baseada em cookies.
  - A biblioteca lib_chan:
    - Uso de intermediários (middle men).
    - Arquivo de configuração da lib_chan.
    - Funções da lib_chan:
      - start_server()
      - start_server(Conf)
      - connect(Host, Port, Service, Passwd, ArgsC)
    - Exemplo: acesso remoto ao servidor de nomes simples.
  O material visto foi o restante do capítulo 10 do Armstrong.
20 de setembro (aula 11):
- Programação distribuída em Erlang (continuação):
  - A arquitetura de intermediários da lib_chan (seção D.2 do apêndice D do Armstrong).
- Comentários sobre os capítulos de 11 a 15 do Armstrong.
- Introdução ao OTP:
  - Servidor genérico básico.
  - Servidor genérico com "transações".
  - Servidor genérico com troca dinâmica de código.
  O material visto foi o capítulo 16 do Armstrong, até o ítem "Server 3: Transactions and Hot Code Swapping" da seção 16.1.
22 de setembro (aula 12):
- Introdução ao OTP (continuação):
  - Servidor genérico com troca dinâmica de código (continuação).
  - Servidor "oco".
  - O comportamento (behaviour) gen_server do OTP. Exemplo simples de uso do gen_server.
  - Visão geral (e bem rápida) sobre outros comportamentos do OTP: gen_fsm, gen_event e supervisor.
  O material visto foi o restante do capítulo 16 do Armstrong.
27 de setembro (aula 13):
- Tópico final de OTP (seção 18 do Armstrong):
  - O comportamento supervisor. Árvores de supervisão.
- Erlang para programação de CPUs multicore:
  - Características de um programa Erlang que rode eficientemente numa CPU multicore.
  - pmap e funções assemelhadas. Paralelização de código sequencial por meio de pmap.
  - Dois experimentos simples para verificar o efeito da regra "small messages, big computations".
  Vimos os capítulos 19 e 20 do Armstrong, até a seção 20.3.
29 de setembro (aula 14):
- Erlang para programação de CPUs multicore (continuação):
  - MapReduce em Erlang.
    - Aplicação simples: contagem de ocorrências das palavras nos arquivos de um diretório.
    - Outra aplicação: indexação de texto (construção de um índice invertido).
  Vimos o restante do capítulos 20 do Armstrong.
- Conversa inicial sobre a linguagem Scala. Leitura recomendada: capítulo 1 (disponível em pdf) do Odersky.

Outubro

4 de outubro (aula 15):
- Introdução à linguagem Scala:
  - Definição de variáveis com atribuição única (vals), de variáveis que aceitam reatribuições (vars) e de funções (defs).
  - Inferência de tipos.
  - Scripts simples.
  - Iterações no estilo imperativo (while).
  - Funções anônimas (function literals) e "iterações" no estilo funcional (foreach e for).
  - Vetores.
  - Parametrização de tipos.
  - Tratamento uniforme de métodos e de operadores. As notações (equivalentes) de chamada de método e de operação.
  - Os métodos apply e update. Caso de uso: acesso aos elementos de um vetor.
  - Listas.
  Vimos o capítulo 2 (disponível em pdf) e as duas primeiras seções do capítulo 3 do Odersky.
6 de outubro (aula 16):
- Mais Scala:
  - Tuplas.
  - Conjuntos. As feições (traits) scala.collection.Set, scala.collection.immutable.Set, scala.collection.mutable.Set e as classes scala.collection.immutable.HashSet e scala.collection.mutable.HashSet.
  - Mapas (maps). As feições scala.collection.Map, scala.collection.immutable.Map, scala.collection.mutable.Map e as classes scala.collection.immutable.HashMap e scala.collection.mutable.HashMap. O método "->" e a notação "chave -> valor".
  Vimos o restante do capítulo 3 do Odersky, exceto a última seção ("Read lines from a file"), cuja leitura fica como tarefa de casa.
- Classes e objetos em Scala:
  - Classes, campos e métodos. Parâmetros de métodos são vals.
  - Singleton objects. O objecto acompanhante (companion object) de uma classe.
  - Exemplo de programa de aplicação em Scala.
  Vimos o capítulo 4 do Odersky, exceto a seção 4.5, que ficou obsoleta na versão 2.9 de Scala.
18 de outubro (aula 17):
- Primeira prova
20 de outubro (aula 18):
- Tipos básicos e operações em Scala (uma olhada muito rápida no capítulo 5 do Odersky):
  - Tipos básicos. Sintaxe para raw strings.
  - Igualdade de objetos.
  - Rich wrappers.
- "Objetos funcionais" em Scala (capítulo 6 do Odersky, até 6.9).
  - Exemplo: Classe que modela os números racionais como objetos imutáveis.
  - Tópicos de programação orientada a objetos em Scala: parâmetros de classes, construtores, redefinição de métodos (uso de override), pré-condições (uso de require), auto-referências (uso de this), membros privados.
25 de outubro (aula 19):
- "Objetos funcionais" em Scala (continuação do capítulo 6 do Odersky, a partir de 6.10).
  - Versão final da classe que modela os números racionais como objetos imutáveis.
  - Tópicos de programação orientada a objetos em Scala: sobrecarga de métodos e de operadores, conversões implícitas (uso de implicit).
- Estruturas de controle de fluxo nativas (built-in) de Scala (capítulo 7 do Odersky, até 7.3):
  - Expressões if.
  - Laços while e do-while.
  - Expressões for. Os dois empregos de for: iteração sobre coleções e produção (yield) de coleções.
27 de outubro (aula 20):
- Estruturas de controle de fluxo nativas (built-in) de Scala (restante do capítulo 7 do Odersky):
  - Mais um exemplo de produção de coleções com for e yield.
  - Conversa bem rápida sobre expressões throw (lançamento de exceções) e try (tratamento de exceções).
    (Nota para mim mesmo: ainda não falei do tipo Nothing.)
  - Uma primeira visão das expressões match. Além dos exemplos da seção 7.5, vimos também o exemplo isort (insertion sort) do capítulo 16 (seções 16.4 e 16.5) do Odersky.
  - Tarefa de casa: ler as seções do capítulo 7 que não foram vistas em aula: 7.4, 7.6, 7.7 e 7.8.
- Funções e fechamentos em Scala (capítulo 8 do Odersky, até 8.6):
  - Funções locais.
  - Funções de primeira classe: literais e valores funcionais.
  - Formas abreviadas de literais funcionais. A sintaxe de placeholders.
  - Funções parcialmente aplicadas.

Novembro

1 de novembro (aula 21):
- Funções e fechamentos em Scala (capítulo 8 do Odersky, de 8.7 a 8.10):
  - Fechamentos.
  - Formas especiais de chamada de função: passagem de um número variável de argumentos, argumentos nomeados (named arguments), parâmetros com valores default.
    (Named arguments e default parameter values surgiram na versão 2.8 de Scala e portanto não aparecem na primeira edição do Oderski, que é a disponível na Internet.)
  - Otimização da recursão de cauda. Os casos em que não há otimização.
- Abstrações de controle em Scala (capítulo 9 do Odersky, até 9.4):
  - Uso de funções de ordem superior para reduzir a duplicação de código e para simplificar os clientes de uma API.
  - Currying.
  - Definição de novas estruturas de controle.
3 de novembro (aula 22):
- Abstrações de controle em Scala (capítulo 9 do Odersky, seções 9.5 e 9.6):
  - Passagem de parâmetros por nome (by-name parameters).
- Composição e herança em Scala (capítulo 10 do Odersky, até 10.11):
  - Métodos abstratos e classes abstratas.
  - Métodos sem lista de parâmetros (parameterless methods) e métodos com lista de parâmteros vazia (empty-paren methods). O princípio do acesso uniforme.
  - Herança. Sobrescrita de métodos e e de campos.
  - Campos paramétricos.
  - Construção de superclasses.
  - O modificador override.
8 de novembro (aula 23):
- A hierarquia de tipos de Scala (capítulo 11 do Odersky):
  - As classes Any, AnyVal e AnyRef.
  - As classes Null e Nothing.
- Feições (traits) Scala (capítulo 12 do Odersky, até a seção 12.4):
  - Definição e uso de feições.
  - Emprego de feições para "enriquecimento" de uma interface "magra".
  - A feição Ordered.
10 de novembro (aula 24):
- Feições (traits) Scala (capítulo 12 do Odersky, de 12.5 a 12.8):
  - Feições como modificações empilháveis.
  - Comparação entre feições e herança múltipla.
  - Quando usar feições?
- Case classes e casamento de padrões em Scala (capítulo 15 do Odersky):
  - As consequências de declarar uma classe com o modificador case
  - Uso de case classes no casamento de padrões. Padrões que tem o formato de uma construção de instância de case class (constructor patterns).
  - Classes "seladas" (sealed classes).
  - O tipo Option.
  - Funções parciais (sequências de casos). Uma sequência de cases é um literal que representa uma função definida sobre parte dos elementos de um certo tipo.
22 de novembro (aula 25):
- ...
24 de novembro (aula 26):
- ...
28 de novembro (aula 27):
- ...

Dezembro

1 de dezembro (aula 28):
- Segunda prova.
6 de dezembro (aula 29):
- ...

Last modified: Mon Nov 21 01:06:01 BRST 2011
Francisco Reverbel
reverbel at ime.usp.br