Introdução à Programação Sistemática – Locais e Abstração (Semana 7)

A semana 7 trouxe os conceitos de expressões locais e abstratas. Como parece ser o meu caso, esta semana foi metade de uma revisão de outros cursos que foi agradável e refrescante, e depois BAM, um novo conceito que me jogou completamente para um loop.

Não estou reclamando disso em si, porque acho que é uma ótima maneira de adicionar coisas à minha caixa de ferramentas conceitual (revisando coisas antigas e depois lançando algo novo), mas *é* um pouco de montanha-russa.

Lição 1: Introdução às expressões locais

O primeiro elemento empolgante desta semana é outra atualização de idioma! Agora estamos passando para a Linguagem do Aluno Intermediário. Pontuação.

No que diz respeito às expressões locais, aprendemos nesta lição introdutória que expressões locais são expressões que possuem funções e constantes que funcionam apenas em uma parte de um programa. Isso é tudo o que temos aqui. Mais sobre isso mais tarde ...

Lição 2: Expressões Locais – Formação e Intuição

Atualizar nossas vidas para a Linguagem do Aluno Intermediário nos dá a capacidade de utilizar expressões locais, conforme vagamente definido na lição 1. Basicamente, as expressões locais são expressões pequenas e empacotadas com suas próprias funções e variáveis que não podem interagir com o restante do programa, fora de seu contêiner local. Aqui está a anatomia de um local:

Neste exemplo, ambos os "define" são definições para variáveis que só existirão dentro deste contêiner local, o que significa que se "a" for referenciado no nível superior do programa, ou seja, fora deste local, tudo o que fizermos para a dentro deste local NÃO IMPORTA para as outras instâncias de "a". Por que? Porque se "a" é usado em um local, ele existe APENAS dentro desse local e não tem interação com nenhum outro "a" que possa estar dentro do programa. Isso significa que você também pode usar "a" em todos os seus locais, e nada acontecerá entre eles, desde que você estruture seu local corretamente.

Lição 3: Expressões Locais – Escopo Lexical

Os contornos de escopo respondem às suas perguntas sobre onde você pode acessar suas definições locais. O escopo lexical afirma, essencialmente, que você usa a definição de uma função ou variável que está dentro da área de fechamento mais interna de onde sua expressão está sendo avaliada.

Lição 4: Expressões Locais – Regras de Avaliação

Como mencionado anteriormente, os locais são expressões, eles não afetam as coisas fora de seu alcance. Aqui estão os passos para avaliação!

1. Renomeação– Pegue as definições no local, encontre todas as referências a elas, crie novos nomes globalmente exclusivos para elas e substitua todas as instâncias do nome antigo por este novo e exclusivo.
2. Levantamento– Mova as definições renomeadas para o nível superior.
3. Substituir– Substitua todo o local apenas por seu corpo, com as definições renomeadas.

É interessante notar que, ao avaliar sua expressão local dessa maneira, você está realmente eliminando sua existência como local e, portanto, seu programa poderia, teoricamente, ter sido escrito no Idioma Básico do Aluno!

Lição 5: Expressões locais – encapsulamento

Encapsulamento é pegar cada parte de um programa e transformá-lo em um pequeno pacote que interage apenas com alguns itens pequenos no nível superior. Essencialmente, está fazendo funções únicas com os locais dentro delas. Quando você encapsula uma função, é importante lembrar que você não pode mais acessá-la globalmente. NO ENTANTO, isso também significa que, como uma função encapsulada, você não precisa escrever assinaturas e testes, o que acabará economizando muito tempo. MAS, você ainda pode querer testá-los, então não se esqueça de fazer isso!

Como você pode saber se uma função é uma boa candidata para encapsulamento? POÇO....

• Ele existe como uma função com ajudantes intimamente ligados?
• O programa externo REALMENTE só precisa chamar a função principal, não os auxiliares?

Se você respondeu sim a ambos, provavelmente está olhando para um ótimo candidato para encapsulamento!

How do you encapsulate a function?

1. Agrupe todas as funções que você deseja encapsular.
2. Abra sua definição com um novo nome de função global e os parâmetros necessários.
3. Abra uma expressão local e, em seguida, a parte de definição do local com [, logo antes da definição da função original.
4. Feche a parte de definição com um ] após a definição da função original.
5. Adicione uma chamada de trampolim da função, definida no local, ao final.
6. Exclua testes, assinaturas e stubs desnecessários.
7. Renomeie os testes e os stubs necessários
8. RUN FREE! YOU GOT IT!

Também é importante observar que você pode ter encapsulamento em seus modelos, mas lembre-se de que, se você fizer isso, isso impedirá sua capacidade de testar um caso base.

Notas adicionais desta lição:

Outro tópico abordado nesta lição é a refatoração, que é uma mudança estrutural em um programa que NÃO altera o comportamento do programa. Você pode, no entanto, refatorar algo e TAMBÉM alterar seu comportamento, mas não é recomendado fazer essas duas alterações ao mesmo tempo (é mais fácil cometer erros tentando fazer muito de uma vez!).

Lição 6: Expressões Locais – Evitando o Recálculo

FINALMENTE, estamos chegando ao conceito de eficiência de código nesta classe. Esta lição começa com a ideia de que você deve se preocupar com a eficiência do código DEPOIS que seu programa funcionar. De certa forma, concordo com isso, principalmente para iniciantes, mas também discordo um pouco. Acho que a eficiência do código deve estar enraizada desde o início de sua carreira de codificação, para que se torne uma maneira natural de pensar, em vez de uma reflexão tardia. Dito isso, esta lição se concentra na eliminação do crescimento exponencial. Essencialmente, a solução aqui é muito situacional, então não quero entrar muito nisso. No entanto, a conclusão é que, quando você está trabalhando com árvores de aridade, se puder localizar sua pesquisa, isso tornará seu código mais sucinto e eficiente. J

Lição 7: Introdução à abstração

A abstração, na programação, é a maneira de gerenciar a complexidade em seu programa. #IAbstractedThatLessonForYou

Lição 8: Abstração de Exemplos, Parte 1

Quando você está abstraindo, você precisa separar as partes comuns das funções em funções abstratas. (Nota: as diferentes partes são chamadas de "pontos de variação".)

Em uma função, você a renomeia como mais geral, coloca um parâmetro para representar o ponto de variância e substitui o ponto de variância pelo parâmetro que você renomeou (lembre-se de passar o parâmetro em todas as recursões também!).

Por que você deseja abstrair funções?

POÇO!

Uma função de ordem superior pode consumir mais de uma função. Também pode produzir uma função.

Então, acostume-se com isso. É melhor. Prometer.

Lição 9: Abstração de Exemplos, Parte 2

A lição 9 funciona principalmente com um exemplo contínuo da lição 8, então vou operar como de costume e me livrar do exemplo e dar a você as conclusões importantes:

1. As funções podem consumir outras funções como argumentos.
2. A abstração existe e funciona na maioria das linguagens de programação.
3. Para abstrações, declarações de propósito são muito difíceis de escrever, então comece a praticar.

Lição 10: Abstração de Exemplos, Parte 3

Escrever a assinatura vem por último ao fazer uma abstração, porque é ainda mais difícil do que escrever uma declaração de propósito. Aqui está uma dica sobre como trabalhar com isso: Use a inferência de tipo! A inferência de tipo é mais ou menos assim:

1. Encontre a coisa mais básica que uma função produz, que se torna o resultado na assinatura.
2. Encontre os argumentos que são passados/necessários. Esses são os tipos de argumento para a assinatura.

Parece fácil, mas há tanta coisa acontecendo com a abstração que pode ser bastante desconcertante. Não desanime, apenas tente se concentrar em simplificar o que você está trabalhando, como você faz com toda a teoria da receita de design, e você ficará bem.

Notas adicionais desta lição:

1. Quando uma função é passada como um argumento, escreva sua assinatura em () na assinatura maior.
2. As listas podem ser escritas de forma alternativa. Agora você pode usar (listof X) no lugar de ListOfX

Lição 11: Usando funções abstratas internas

Map e Filter são duas das funções abstratas integradas mais comumente usadas, e a página de idioma no curso do coursera lista todas elas. (Se você não estiver fazendo a aula do coursera, aqui está um link externo que você pode conferir com as mesmas informações: Funções abstratas integradas da BSL.)

Os resumos embutidos são muito legais, e a realidade é que, se for um sentimento bastante genérico, confie na sua iniciativa e confira a lista - provavelmente é um embutido!

Lesson 12: Closures

Às vezes, a função que você está passando como argumento para uma função abstrata ainda não existe.... Se esse for o caso, você sempre pode defini-lo com um local.

HOWEVER

Em alguns casos, você não tem escolha. Você DEVE parar e defini-lo.

Quando é isso?

Quando o corpo de uma função que você deseja passar para uma função abstrata refere-se a um parâmetro na função externa. A definição da função externa, portanto, fecha EM TORNO da interna, tornando-a um fechamento. (Lembra daquele escopo lexical? SIM!)

Lição 13: Funções de dobra abstrata

Esta lição fornece uma visão geral rápida sobre como ir diretamente de modelos para funções abstratas, literalmente cortando toda a gosma no meio, otimizando seu tempo escrevendo seu código. YAY. Resumindo, uma função de dobra é uma função abstrata baseada diretamente no modelo.

Week 7 Summary

Como mencionei no início, essa lição foi loooooooooooooooooong no segundo tempo, porque muito disso era novo para mim. Se você tiver alguma dica ou truque relacionado a funções abstratas, me avise! Também! A semana 8 é a última semana de aula, então o próximo blog será o último da série. Não se preocupe, tenho muitos planos para as próximas entradas.