Diário de Bordo

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

Agosto Setembro          Outubro Novembro          Dezembro

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

• 19 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 (assunto a ser continuado na próxima aula).

• 21 de agosto (aula 2):
  • Introdução à linguagem Erlang (capítulo 2 do Armstrong):
    • "Variáveis" com atribuição única (single assignment)
    • Números, átomos, tuplas, listas, strings
    • Casamento de padrões

• 26 de agosto (aula 3):
  • Programação sequencial em Erlang:
    • Módulos e funções.
    • Processamento de listas. O exemplo da lista de compras.
    • Funções com mesmo nome e número de argumentos ("arity") diferente.
    • Uso da técnica de "acumuladores" para converter em recursão de cauda (tail recursion) certos casos de recursão que é "quase de cauda".
    • Funções anônimas (funs).
    • Funções (de ordem superior) que recebem funções como argumentos.
    O material visto foi o capítulo 3 do Armstrong, até a página 45, mais a parte sobre acumuladores e recursão de cauda.

• 28 de agosto (aula 4):
  • Programação sequencial em Erlang (continuação):
    • 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, triplas pitagóricas, 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).
    O material visto foi o capítulo 3 do Armstrong, da página 45 até a página 58, mais as observações sobre a implementação de listas imutáveis e sobre a complexidade das operações com listas.

• 2 de setembro (aula 5):
  • Programação sequencial em Erlang (continuação):
    • 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.
    • Construção eficiente de listas. Uso de acumuladores.
    O material visto foi o final do capítulo 3 do Armstrong, a partir da página 58.
  • Exceções em Erlang. Vimos o capítulo 4 do Armstrong, até a página 70.

• 4 de setembro (aula 6):
  • Exceções em Erlang (continuação). Vimos o restante do capítulo 4 do Armstrong, a partir da página 71.
  • Uma visão bem rápida sobre outros tópicos de programação sequencial em Erlang:
    • Built-in functions (BIFs).
    • Binaries. As duas formas de uso de binaries:
      • Por meio da bit syntax, que permite controle total sobre o empacotamento/desempacotamento de dados.
      • Por meio das BIFs term_to_binary(Term) e binary_to_term(Bin), que oferecem funcionalidade análoga à da seriação Java.
    • O pré-processador: -include, -define, -ifdef, ...
    • Notação para códigos de caracteres: $a, $b, $c, ...
    • Igualdade (X == Y, X /= Y) e identidade (X =:= Y, X =/= Y).
    • Operadores booleanos com "avaliação em curto-circuito": andalso e orelse.
    • Referências. A BIF erlang:make_ref().
    • O process dictionary.
    Esse material está no capítulo 5 do Armstrong.
  • Compilação e execução de programas fora da Erlang shell (capítulo 6 do Armstrong, páginas 113 e 114).
  • Programação concorrente em Erlang:
    • Introdução.
    • Processos (ou atores) em Erlang. O modelo de atores.
    • As primitivas de concorrência:
      • Pid = spawn(Fun)
      • Pid ! Msg
      • receive ... end
    O material visto foi o capítulo 7 e o início do capítulo 8 (até a página 134) do Armstrong, mais as observações sobre o modelo de atores.

• 9 de setembro (aula 7):
  • Programação concorrente em Erlang:
    • 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. Exemplos:
      • função sleep(Time)
      • função flush_mailbox()
      • função priority_receive()
      • temporizador simples
    • O funcionamento da primitiva receive ... end.
    O material visto foi o capítulo 8 do Armstrong, da página 134 à 146, mais a seção 8.9, sobre recursão de cauda.

• 11 de setembro (aula 8):
  • Programação concorrente em Erlang:
    • 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: seções 8.7, 8.8 e 8.10.
  • 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).

• 16 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) e a primitiva erlang:monitor(process, Item).
    O material visto foi o capítulo 9 do Armstrong, exceto a seção 9.8.

• 18 de setembro:
  • Aula cancelada.

• 23 de setembro (aula 10):
  • Programação distribuída em Erlang:
    • Erlang distribuído:
      • O conceito de nó (node) Erlang.
      • Exemplo: servidor de nomes simples
      • 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()
      • Exemplo de spawn remoto.
      • Proteção baseada em cookies.
    O material visto foi o capítulo 10 do Armstrong, até a seção 10.2 (inclusive), mais a seção 10.4.

• 25 de setembro (aula 11):
  • Programação distribuída em Erlang (continuação):
    • 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 foram as seções 10.3 e 10.5 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).

• 30 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.
    • Servidor "oco".
    O material visto foi o capítulo 16 do Armstrong, até a página 295.

• 2 de outubro (aula 13):
  • A plataforma Erlang/OTP (continuação):
    • 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.

• 7 de outubro (aula 14):
  • 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".
    O material visto foram os capítulos 19 e 20 do Armstrong, até a seção 20.3.
  • Conversa inicial sobre MapReduce. A operação de redução (reduce, ou fold, ou ainda accumulate).

• 9 de outubro (aula 15):
  • Erlang para programação de CPUs multicore (continuação):
    • MapReduce em Erlang.
    • Aplicação: contagem de ocorrências das palavras nos arquivos de um diretório.
    O material visto foi a seção 20.3 do Armstrong.
  • Conversa inicial sobre a linguagem Scala. Leitura recomendada: capítulo 1 do Odersky.

• 14 de outubro (aula 16):
  • 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.
    Vimos o capítulo 2 e as duas páginas iniciais do capítulo 3 do Odersky.

• 16 de outubro (aula 17):
  • Mais Scala:
    • 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.
    • O companion object de uma classe. Outro caso de uso de apply: método "fábrica" (factory method) definido no companion object 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.
    Vimos a continuação do capítulo 3 do Odersky, até a página 49.

• 21 de outubro (aula 18):
  • Primeira prova.

• 23 de outubro (aula 19):
  • Mais Scala:
    • 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".
    • Classes, campos e métodos.
    • 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.
    • Precedência e associatividade.
    • Rich wrappers.
    Vimos o restante do capítulo 3, o capítulo 4 e o capítulo 5 do Odersky. [Note to self: Esqueci de dizer que parâmetros de métodos são vals (p. 62) e de falar sobre igualdade de objetos (pp. 89-90).]

• 28 de outubro (aula 20):
  • Mais Scala (dois tópicos curtos que ficaram para trás na aula anterior):
    • Parâmetros de métodos são vals (capítulo 4 do Odersky, p. 62) .
    • Igualdade de objetos (capítulo 5 do Odersky, pp. 89-90).
  • "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).

• 30 de outubro (aula 21):
  • Estruturas de controle de fluxo primitivas (built-in) de Scala (capítulo 7 do Odersky):
    • 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.
    • Uma primeira visão das expressões match. Além dos exemplos do capítulo 7, vimos também o exemplo isort (insertion sort) da página 301 (capítulo 16) do Odersky.

• 4 de novembro (aula 22):
  • Funções e fechamentos em Scala (capítulo 8 do Odersky):
    • 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.
    • 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.

• 6 de novembro (aula 23):
  • Abstrações de controle em Scala (capítulo 9 do Odersky):
    • 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.
    • Passagem de parâmetros por nome (by-name parameters).

• 11 de novembro (aula 24):
  • Composição e herança em Scala (capítulo 10 do Odersky):
    • 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.
    • Uso de um objeto fábrica.
    • Uso de classes privadas por um objeto fábrica.

• 13 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.
  • Uma primeira visão sobre feições ou 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.
  • Case classes e casamento de padrões em Scala (capítulo 15 do Odersky, até a seção 15.1):
    • Exemplo: função simplificadora de expressões aritméticas.

• 18 de novembro (aula 26):
  • Case classes e casamento de padrões em Scala (capítulo 15 do Odersky, da seção 15.2 à 15.6):
    • Tipos de padrões: coringa, constante, variável, construtor, sequência (como List ou Array) e tupla. Padrões tipados e type erasure.
    • Guardas.
    • Classes "seladas" (sealed).
    • O tipo Option.

• 25 de novembro (aula 27):
  • Case classes e casamento de padrões em Scala (capítulo 15 do Odersky, seção 15.7):
    • Outros usos de padrões. Funções parciais.
  • Feições Scala como modificações empilháveis (capítulo 12 do Odersky, seção 12.5).
  • Em Scala variáveis reatribuíveis são propriedades (capítulo 18 do Odersky, seção 18.2).

• 27 de novembro (aula 28):
  • Parametrização de tipos em Scala (capítulo 19 do Odersky, até a seção 19.7):
    • O exemplo da "fila funcional".
    • Information hiding: construtores privados, classes privadas.
    • Variância: tipos covariantes, tipos contravariantes e tipos não variantes.
    • Type parameters (parâmetros que são tipos) com limites inferiores.
    • Tipos variantes com campos mutáveis privativos de objetos (private[this]).

• 2 de dezembro (aula 29):
  • 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.

• 4 de dezembro (aula 30):
  • A biblioteca de atores Scala (capítulo 30 do Odersky, até a seção 30.5):
    • A feição scala.actors.Actor. Métodos para envio (!) e recebimento (receive) de mensagens.
    • Reuso de threads: o método react.
    • Boas práticas de programação com atores.

• 9 de dezembro (aula 31):
  • Segunda prova.

Last modified: Fri Dec 4 19:28:49 BRST 2009
Francisco Reverbel
reverbel at ime.usp.br