Diário de Bordo

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

	Agosto
	Setembro

	Outubro
	Novembro

Dezembro

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

Agosto

10 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.8):
  - Números e operações aritméticas
  - "Variáveis" com atribuição única (single assignment variables)
  - Átomos
13 de agosto (aula 2):
- Introdução à linguagem Erlang (capítulo 2 do Armstrong, de 2.9 a 2.12):
  - Tuplas, listas, strings.
  - Casamento de padrões.
- Programação sequencial em Erlang:
  - Módulos e funções (capítulo 3 do Armstrong, seção 3.1).
17 de agosto (aula 3):
- Programação sequencial em Erlang (continuação):
  - Processamento de listas. O exemplo da lista de compras.
  - 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.
  O material visto foi o capítulo 3 do Armstrong, da seção 3.2 à parte inicial da 3.6 (paramos antes do exemplo quicksort), mais as observações sobre recursão de cauda.
20 de agosto (aula 4):
- Programação sequencial em Erlang (continuação):
  - Exemplos de list comprehensions: triplas pitagóricas, quicksort, anagramas.
  - 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.
  - Guardas (guards).
  - Records.
  - A expressão case. Exemplo de uso: função filter(P,L).
  - A expressão if. Uso da guarda true em expressões if.
  O material visto foi o capítulo 3 do Armstrong, de 3.6 a 3.10, mais as observações sobre a implementação de listas imutáveis e sobre a complexidade das operações com listas.
24 de agosto (aula 5):
- Programação sequencial em Erlang (continuação):
  - Construção eficiente de listas. Uso de acumuladores.
  Vimos o final do capítulo 3 do Armstrong (seções 3.11 e 3.12).
- Exceções em Erlang. Vimos o capítulo 4 do Armstrong.
- Built-in functions (BIFs) de Erlang. Vimos o início (a seção 5.1) do capítulo 5 do Armstrong.
27 de agosto (aula 6):
- Uma visão rápida sobre outros tópicos de programação sequencial em 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.
  - A BIF apply(Mod, Func, [Arg1, ..., ArgN]).
  - O pré-processador: -include, -define, -ifdef, ...
  - Block expressions: begin Expr1, ..., ExprN end.
  - Referências a funções (function references).
  - O process dictionary.
  - Referências. A BIF erlang:make_ref().
  Esse material está no capítulo 5 do Armstrong.
- Introdução ao modelo de concorrência de Erlang (capítulo 7 do Armstrong).
31 de agosto (aula 7):
- Programação concorrente em Erlang:
  - Processos (ou atores) em Erlang. O modelo de atores.
  - 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.
  - 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 as observações sobre o modelo de atores.

Setembro

3 de setembro (aula 8):
- 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.
  - A importância da recursão de cauda para a implementação de servidores.
  - 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).
7 de setembro:
- Não haverá aula (Semana da Pátria).
10 de setembro:
- Não haverá aula (Semana da Pátria).
14 de setembro (aula 9):
- 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.
    - Conjuntos de processos interligados.
  - Monitores (ligações unidirecionais entre processos).
  - Exemplo ingênuo (com um bug): função keep_alive(Name, Fun), que cria um processo registrado e o mantém sempre vivo.
    - Tarefa de casa: Corrigir essa função!
  O material visto foi o capítulo 9 do Armstrong.
17 de setembro (aula 10):
- 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)
      - disconnect_node(Node)
      - monitor_node(Node, Flag)
      - node()
      - node(Arg)
      - nodes()
      - is_alive()
  O material visto foi o capítulo 10 do Armstrong, até a seção 10.2 (paramos antes do exemplo de spawn remoto).
21 de setembro (aula 11):
- 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, mais parte da seção D.2 do apêndice D (as informações sobre a arquitetura de intermediários da lib_chan).
24 de setembro (aula 12):
- 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 penúltimo ítem (Server 4: Transactions and Hot Code Swapping) da seção 16.1.
28 de setembro (aula 13):
- Introdução ao OTP (continuação):
  - Servidor "oco".
  - Visão geral (bem rápida) dos seguintes comportamentos (behaviours) do OTP: gen_server, gen_fsm, gen_event e supervisor.
  - O comportamento gen_server.
  - Árvores de supervisão. O comportamento supervisor.
  O material visto foi o restante do capítulo 16 do Armstrong, mais a seção 18.5.
- 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.
  Vimos os capítulos 19 e 20 do Armstrong, até a seção 20.2.

Outubro

1 de outubro (aula 14):
- Erlang para programação de CPUs multicore:
  - Dois experimentos simples para verificar o efeito da regra "small messages, big computations".
  - 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).
  O material visto foi o restante do capítulo 20 do Armstrong.
5 de outubro (aula 15):
- Primeira prova.
8 de outubro (aula 16):
- Visão geral da linguagem Scala. Leitura recomendada: capítulo 1 do Odersky.
- 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.
  Vimos o capítulo 2 e as quatro páginas iniciais do capítulo 3 do Odersky.
12 de outubro:
- Não haverá aula (Padroeira do Brasil).
15 de outubro:
- Não haverá aula (semana de break do BCC).
19 de outubro (aula 17):
- Mais Scala:
  - O objeto acompanhante (companion object) de uma classe. Outro caso de uso de apply: método "fábrica" (factory method) definido no objeto acompanhante de uma classe.
  - Listas.
  - 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.
22 de outubro (aula 18):
- Mais Scala:
  - Classes, campos e métodos. Parâmetros de métodos são vals.
  - Inferência de separadores de comandos.
  - Singleton objects. O objecto acompanhante (companion object) de uma classe.
  - Aplicações Scala.
  - A feição Application.
  - Visão rápida dos tipos básicos. Sintaxe para raw strings.
  Vimos o capítulo 4 e as duas primeiras seções do capítulo 5 do Odersky.
26 de outubro (aula 19):
- Mais Scala (tópicos restantes do capítulo 5 do Odersky):
  - Igualdade de objetos.
  - Precedência e associatividade.
  - Rich wrappers.
- "Objetos funcionais" em Scala (capítulo 6 do Odersky).
  - 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, sobrecarga de métodos e de operadores, conversões implícitas (uso de implicit).
29 de outubro:
- Não haverá aula (recesso escolar).

Novembro

5 de novembro (aula 20):
- Estruturas de controle de fluxo primitivas (built-in) de Scala (capítulo 7 do Odersky, até 7.4):
  - 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.
  - Expressões throw (lançamento de exceções) e try (tratamento de exceções). O tipo de uma expressão throw: scala.Nothing, que é subtipo de qualquer outro tipo.
9 de novembro (aula 21):
- Estruturas de controle de fluxo primitivas (built-in) de Scala (capítulo 7 do Odersky, de 7.5 a 7.8):
  - Uma primeira visão das expressões match. Além dos exemplos do capítulo 7, vimos também o exemplo isort (insertion sort) do capítulo 16 (seções 16.4 e 16.5) do Odersky.
  - Escopo de variáveis.
- 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.
12 de novembro (aula 22):
- Funções e fechamentos em Scala (capítulo 8 do Odersky, de 8.6 a 8.10):
  - Fechamentos.
  - Funções com número variável de parâmetros.
  - 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.
16 de novembro (aula 23):
- 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.5):
  - 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.
19 de novembro (aula 24):
- Composição e herança em Scala (capítulo 10 do Odersky, de 10.6 a 10.15):
  - Campos paramétricos.
  - Construção de superclasses.
  - O modificador override.
  - Uso de um objeto fábrica.
  - Uso de classes privadas por um objeto fábrica.
23 de novembro (aula 25):
- 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 "fina".
  - A feição Ordered.
26 de novembro (aula 26):
- 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?
- Visão rápida das case classes de Scala. As consequências de declarar uma classe com o modificador case (capítulo 15 do Odersky, seção 15.1).
- Em Scala, variáveis públicas reatribuíveis são propriedades (capítulo 18 do Odersky, seção 18.2).
- Conversa inicial sobre a relação entre tipos parametrizados e herança: o conceito de variância (relativa a um parâmetro) de um tipo parametrizado. Tipos não variantes, tipos covariantes e tipos contravariantes.
30 de novembro (aula 27):
- Parametrização de tipos em Scala (capítulo 19 do Odersky, até a seção 19.7):
  - O exemplo da "fila funcional" parametrizada (Queue[T]).
  - Information hiding: construtores privados, classes privadas.
    O material sobre information hiding não foi visto em classe. Tarefa de casa: ler a seção 19.2, que contém esse material.
  - Variância de um tipo em relação a um parâmetro: tipos não variantes, tipos covariantes e tipos contravariantes.
  - Type parameters (parâmetros que são tipos) com limites inferiores (lower bounds). Exemplo: def append[U >: T](s: U) = ...
  - Tipos variantes com campos mutáveis privativos de objetos (private[this]).

Dezembro

3 de dezembro (aula 28):
- Membros abstratos em Scala (capítulo 20 do Odersky, até a seção 20.8):
  - Type members (membros que são tipos).
  - Campos val e var abstratos.
  - Inicialização de campos val abstratos. Campos val preguiçosos (lazy).
  - Abstract types (membros abstratos que são tipos).
  - Tipos dependentes de caminho. Aplicação: enumerações.
7 de dezembro (aula 29):
- Segunda prova.

Last modified: Mon Feb 7 11:59:58 BRST 2011
Francisco Reverbel
reverbel at ime.usp.br