| 0 |
Allef Kristian Tavares Rocha |
# Resumo Semana 1
## Aula 1
Apresentação da linguagem de programação Haskell, que será utilizada na disciplina.
Tutorial de instalação do Haskell Stack e Haskell Language Server.
Tutoriais referentes aos principais editores de texto, Vim e Emacs, com sua instalação e configurações iniciais que facilitarão o desenvovimento de codigo em Haskell.
## Aula 2
Principais paradigmas de programação, sendo eles:
- Imperativo
- Estruturado
- Orientado a objeto
- Declarativo
- Funcional
- Lógico
Exemplos de códigos, mostrando que cada linguagem de programação tem um paradigma principal em sua composição, entretanto este não necessariamente é o único que ela incorpora (linguagens multi-paradigma).
Durante a disciplina, o foco será no paradigma Funcional. Por isso foi escolhida a linguagem Haskell, que é puramente funcional. |
| 1 |
Matheus de Amorim Diniz |
|
| 2 |
Anabel Cristina Moreira de Freitas |
Paradigmas de programação são estilos de programação, a forma da estruturação e passagem da ideia para a escrita do código;
Muitas linguagens de programação são multi-paradigmas: apresentam caracteristicas de diversos paradigmas.
+ = Vantagens
- = Desvantagens
Paradigmas mais comuns:
----------------------------------------------------------------------------
IMPERATIVO
Descreve passo a passo o que deve ser feito.
+ Fluxo de controle explicito e completo, eficiente.
- Difícil compreensão, variáveis globais.
----------------------------------------------------------------------------
ESTRUTURADO
Estrutura o código imperativo em blocos lógicos, que contem instruções imperativas
+ Função explícita, melhor leitura, estimulo de variáveis locais
- Informações podem ser utilizadas fora do contexto, usa mudança de estados = +bugs
----------------------------------------------------------------------------
ORIENTADO OBJETOS
Encapsula os dados em classes com seus proprios estagos e métodos
+ encapsula de forma mais segura, evita o uso de variáveis globais, inibe uso indevido de trechos de código
- nem todos os problemas podem ser facilmente modelados como objetos, dificil paralelizar, herança pode bagunçar o fluxo lógico do código
----------------------------------------------------------------------------
Outros paradigmas:
----------------------------------------------------------------------------
DECLARATIVO
O fluxo lógico é implícito, separação entre o que e o como
+ minimiza uso de estados
- nao é uma linguagem geral como as outras, custo extra no desempenho
----------------------------------------------------------------------------
LÓGICO
Especifica fatos e regras de inferência, escrito em forma de pergunta
+ compilador constroi o programa, simples de provar a corretude
- algoritmos complexos podem ser dificeia de expressar dessa forma, mais lento em operações matematicas
----------------------------------------------------------------------------
FUNCIONAL
Baseado no calculo lâmbida
+ expressividade proxima de linguagens declarativas, não tem estado = -bugs
- ausencia de mutabilidade dificulta o gerenciamento de memória, maior uso do garbage collector
Caracteristicas:
- funções puras
não apresentam efeito colateral;
ausencia de estados permite evitar muitos erros de implementação
transparencia referencial
- recursão
leva a um codigo enxuto e declarativo
- avaliação preguiçosa
quando uma expressão é gerada, é criada uma promessa de avaliação
Se voce não usa uma expressão, ela nunca será avaliada
isso permite a criação de listas infinitas, por exemplo
- puramente funcional
- tipagem estática e forte
|
| 3 |
Ana Luiza Ferreira Figueiredo |
|
| 6 |
André Anderson de Jesus Oliveira |
Parte da primeira atividade foi a configuração de todo o ambiente haskell/stack, que não foi muito tranquilo no windows rs
Sobre a lista de exercícios, foi interessante ver o tratamento com floats e como o "stack test" faz a correção automática dos problemas baseando-se no arquivo "spec.hs".
|
| 7 |
Andre Beltrame Kruss |
---------------- Resumo Semana 01 ----------------
Um paradigma de programação é a forma ou estilo utilizado na implementação de algum algoritmo em um ambiente computacional. Há diversos paradigmas, como exemplo: estruturado, imperativo, declarativo, funcional, orientado a objetos e lógico.
Cada paradigma tem sua vantagem e desvantagem, a escolha de um deles irá depender da aplicação em que se está trabalhando. Além disso, a maioria das linguagens de programação não estão encaixadas em apenas um paradigma, são na verdade multi-paradigmas. Por exemplo, Python pode ser programado de forma estruturada, mas também é orientado a objetos e possui características do paradigma funcional (como funções lambda).
Haskell é uma linguagem de programação que se encaixa no paradigma funcional. As linguagens funcionais não utilizam estados e enfatizam o uso de funções e composições de funções. Em específico, Haskell tem como principais propriedades o uso de funções puras, avaliação preguiçosa, tipagem forte e estática e é uma linguagem declarativa.
Funções puras são funções que, em qualquer momento, sempre retornarão o mesmo valor para um determinado conjunto de parâmetros. Avaliação preguiçosa consiste em executar determinadas operações apenas quando for necessário para se obter um resultado. A tipagem em Haskell é forte e estática, significando que a "mistura" de tipos (por exemplo, somar um inteiro com um ponto flutuante) irá causar erros. Por causa de suas propriedades, Haskell se torna uma linguagem que apresenta menos bugs e em geral possui manutenção mais simples, uma vez que os erros que apresentar serão mais explícitos.
|
| 8 |
Andre Ricca Yoshida |
|
| 9 |
Andressa Teixeira Menezes |
|
| 10 |
Angelo Maeda Rojas |
Parte 1
Um paradigma de programação é um estilo de programação. Existem vários paradigmas, irei comentar sobre os mais populares.
Paradigma Imperativo
Uma sequência de comandos que alteram o estado atual do sistema até atingir um estado final.
Paradigma estruturado
Código imperativo, mas em blocos. Utiliza-se de procedimentos e funções.
Orientação a objetos
Utiliza-se objetos que contém dados, estados próprios e métodos que alteram ou recuperam os dados/estados. Um objeto pode se comunicar com outro para forma a lógica do programa.
Paradigma declarativo
O fluxo é implícito, os programadores escrevem o que querem, mas não como. SQL é um exemplo.
Paradigma lógico
programas são avaliações de funções matemáticas sem alterar estados e com dados imutáveis.
Paradigma funcional
Baseado em cálculo lambda, não utiliza estados, declarativo e programas são composições de funções. Pontos positivos: Expressividade próxima de linguagens declarativas, mas sem limitações; não existe estados, diminuindo os bugs. Pontos negativos: Como fazer algo útil sem estados?
Parte 2
Função puras
No paradigma funcional as funções são puras, ou seja, não possuem efeitos colaterais. Efeito colateral é quando uma função altera uma variável global, lê entrada de dados ou imprimi algo na tela. Dessa forma, uma função pura sempre possuirá o mesmo retorno para as mesmas entradas! Se um algoritmo possuir alguma parte impura, ele será impuro como um todo.
Iterações vs Recursões
Em linguagens funcionais os laços iterativos são implementados através de recursão!
Avaliação preguiçosa
Além disso, algumas linguagens funcionais implementam o conceito de avaliação preguiçosa, ou seja, quando uma expressão é criada é gerado uma promessa de execução ou thunk. Só quando for necessário que a promessa será executada.
Haskell
Linguagem puramente funcional, só aceita funções puras, declarativa, avaliação preguiçosa, dados imutáveis e tipagem estática e forte.
|
| 11 |
Antonio Duarte Cantanhede Neto |
Paradigma: estilo de programação.
Paradigma Imperativo: um programa é uma sequência de comandos que alteram o estado do sistema; segue-se um “passo a passo” até chegar no resultado final desejado. O fluxo de controle é explícito e completo. Desvios incondicionais dificultam reprodução dos passos de execução
Paradigma Estruturado: programas contém estrutura de fluxo de controle condicional. Estrutura-se o código em blocos lógicos (procedimentos e funções), os quais possuem no seu escopo instruções imperativas.
Paradigma de Orientação a Objetos : utilizam-se classes e objetos. Objetos contêm dados, estados próprios e métodos que alteram ou recuperam os dados/estados (classes podem ter métodos de classe, compartilhados por todos objetos). Objetos comunicam entre si para compor a lógica do programa. As classes encapsulam códigos imperativos para segurança e reuso.
Paradigma Declarativo: especifica-se o que se deseja realizar, mas sem detalhar os passos de execução. Utiliza DSLs e, por isto, atinge um nível mais alto de abstração que outros paradigmas.
Paradigma Lógico: especifica-se um conjunto de fatos e regras; o interpretador infere respostas para perguntas sobre o programa. O retorno do programa é dado em forma de pergunta corretamente especificada.
Paradigma Funcional: programas são avaliações/composições de funções que não alteram estados; dados são imutáveis. Isso reduz a quantidade de bugs.
-Baseia-se no cálculo lambda;
-Programas são declarativos, mas sem limitações do paradigma declarativo;
-Faz-se uso de um garbage collector para resolver as limitações que a imutabilidade de daso impõe;
-Usa funções puras: funções que não apresentam efeito colateral; para uma mesma entrada, sempre retornam o mesmos valor;
-Os laços iterativos são implementados via recursão;
-Linguagens funcionais podem usar avaliação preguiçosa. Se este for o caso, quando uma expressão é gerada, também é gerada uma promessa de execução. Quando necessário, a promessa é avaliada.
|
| 12 |
Heitor Bellini |
Ñesta primeira semana aprendemos como configurar o ambiente para programar em haskel: instalando/configurando um subsistem linux no host windows, em seguida instalando HLS e wrapper e criando um projeto de teste, onde foi possível executar um teste de compilação com erro. Instalamos e configuramos o editor de texto Emacs, bem como suas configurações pelo Doom Emacs (vimos também as configurações para o Vim). Aprendemos a teoria e quais são os paradigmas da programação, como o paradigma funcinal (o qual a linguagem haskell se enquadra), imperativo (sequencia de comandos), orientado à objetos (define objetos, cria metodos para recuperar dados dos objetos criados), etc. O foco é no paradigma funcional, pois como já mencionei, é o paradigma de haskell. Neste, vimos por exemplo as definições de funções puras (sem efeito colateral, mesma entrata > sempre mesma resposta). Neste paradigma vimos também que os códigos são enxutos e declarativos, com exemplos.
|
| 13 |
Caio Henrique dos Santos Ribeiro |
|
| 14 |
Bruna Ishida |
Paradigmas de Programação é um estilo de programação.
Existe uma série de paradigmas populares: Imperativo, Estruturado, Orientado a objeto, Declarativo, Funcional e o Lógico.
A maior parte das linguagens de programação utilizam de mais de um paradigma, sendo nomeado de multi-paradigma.
|
| 16 |
Bruno Storer Franco Martins |
Paradigmas de programação se refere a forma que
uma ideia é estruturada ao passar para o computador.
Três dos paradigmas mais populares são:
1 — Imperativo: Sequência de comandos ao computador.
2 — Estruturado: Fluxo de comandos seguem uma estrutura como funções ou procedimentos.
3 — Orientado objeto: Dados e comandos se organizam em objetos.
Outros paradigmas importantes, mas menos conhecidos são:
4 — Declarativo: Instrução é dada sem especificar de que forma deve ser executada.
5 — Funcional: Funções matemáticas são a forma de se construir o programa.
6 — Lógico: Fatos e regras são estabelecidos e cabe ao interpretador
se basear nisso para trazer respostas baseando-se nos fatos e regras.
Focando em linguagens funcionais, essas tem como principais características:
1 — Possuem funções puras, sendo estas funções que não apresentam efeito colateral
além de devolver um saída, além disso, para uma mesmo entrada sempre será resultado uma mesma saída.
2 — Recursões são utilizadas nos lugares das iterações.
3 — Uso de avaliação preguiçosa, sendo essa uma técnica
para evitar cálculos desnecessários ou condições de erros
em expressões compostas nos trechos que não serão relevantes
para o resultado que é gerado por esta composição.
Sobre Haskell: É uma linguagem puramente funcional, ou seja,
as 3 características apresentadas anteriormente estão presentes,
além disso, haskell possui uma tipagem estática e forte. |
| 17 |
Caio Argentino de Oliveira |
- paradigmas de programação:
- formas de programar para resolver um problema
- principais paradigmas:
- imperativo: sequência de comandos para chegar na solução do problema
- estruturado: sequência de comandos com adição de estruturas para fluxo de controle e procedimentos e funções (Ex.: C)
- orientao a objetos: programa composto pela interação entre objetos que possuem o próprio estado interno e metódos para alterar seus estados, com o objetivo de resolver um problema através da representação do entidades do mundo real como objetos (Ex.: Java)
- declarativo: especifíca o objetivo do programa, mas não como fazer para alcançá-lo (Ex.: SQL)
- funcional: o programa é composto por funções matemáticas e suas composições, sem alteração de estado e com imutabilidade de dados (Ex.: Haskell)
- lógico: o programa especifíca um conjunto de fatos e regras, e o interpretador infere as respostas para perguntas sobre o programa (Ex.: Prolog)
- linguagens podem ser multi-paradigmas, contendo aspectos de diversos paradigmas combinados
- paradigma funcional:
- baseado no cálculo lambda, programas são composições de funções, não utiliza estados, e é declarativo
- principais características:
- uso de funções puras
- uso de recursão ao invés de iterações
- uso de avaliação preguiçosa
- funções puras:
- funções livres de efeitos colaterais
- efeito colateral: ocorre quando uma função altera algum estado local do sistema: alterar variável global, ler entrada de dados, realizar impressões na tela
- funções puras sempre retornam a mesma saída dada a mesma entrada
- caso uma função com comportamento puro chame uma função impura, ela se torna impura, pois funções impuras sãa virais
- recursão:
- código mais enxuto e autoexplicativo
- avaliação preguiçosa:
- ao gerar uma expressão, uma promessa de execução (thunk) é gerada
- caso seja necessário, o thunk é avaliado
- Haskell:
- declarativa
- linguagem puramente funcional
- somente aceita funções puras
- possui avaliação preguiçosa
- tipagem estática e forte
- dados imutáveis
|
| 18 |
Caue Drummond Gaudie Ley |
|
| 19 |
Carlos Henrique Silva do Carmo |
Paradigmas de programação é um estilo de pensar e organizar suas ideias para resolver um problema, utilizando algum tipo de linguagem de programação. Os paradigmas mais conhecidos são os imperativos, estruturados e orientados a objetos. Entretanto, hoje, as linguagens possuem características multi-paradigmas. No paradigma imperativa, descreve-se passa a passo o que precisa ser feito. Por sua vez, no paradigma estruturado, a construção dos algoritmos são realizadas em blocos lógicos. Na orientação a objetos, o encapsulamento dos dados são realizados com a criação de classes de objetos e esses se comunicam entre si. No paradigma declarativo, a linguagem apresenta uma característica de alto nível onde dizemos somente o que desejamos ser realizado. O paradigma lógico é descrito através de fatos e regras de inferência, onde seus retornos são construídos a partir de perguntas. Por fim, o paradigma funcional é baseado na construção de composições de funções, tendo características declarativas, porém sem a limitações impostas. As principais características que descrevem uma linguagem mais próxima de uma linguagem funcional é a existência de funções puras, recursão e avaliação preguiçosa. Uma função pura apresenta sempre a mesma resposta quando utilizado os mesmo dados de entrada. Estados, em programação, são as principais fontes de bugs que um programa pode ter. Trabalhar com funções puras, elimina grande parte desses problemas. Os processos de iteração, em linguagens funcionais, são implementadas via recursão. Por fim, a característica de ter uma avaliação preguiçosa, que avalia uma expressão somente quando ela vai ser utilizada. |
| 20 |
Daniel Espindola da Silva |
Paradigmas de Programação:
Definem a maneira prevalente de se descrever problemas em uma determinada linguagem de programação.
Imperativo: Descreve passo a passo o que será executado, bem próximo a linguagem de máquina.
Estruturado: Similar ao imperativo, porém com estruturas de controle e repetição adicionadas nativamente (e.g: Linguagem C)
Orientado a Objetos: Similar ao estruturado, porém com a estrutura de Objetos adicionados. Objetos podem conter variáveis e métodos, podem ser instanciados e relacionam-se entre si para descrever a solução do problema (e.g: Java, C#).
Declarativo: A programação se dá definindo o que se quer obter e não o passo a passo de como se obter tal resultado (e.g: SQL)
Funcional: Se fundamenta na avaliação de funções por substituição, sem alterar os dados. Não contém estruturas de repetição, sendo utilizada recursão para casos onde tais estruturas seriam necessárias (e.g: Haskell, Elixir, Clojure).
Lógico: O programa se escreve apenas especificando fatos ou regras matemáticas e o interpretador infere as respostas. (e.g: Prolog)
Paradigma Funcional:
3 características principais da programação funcional são: Funções Puras, Recursão e Avaliação Preguiçosa.
Funções Puras: São funções que não tem efeito colateral, ou seja, não alteram algum estado global do programa, portanto são funções que se chamadas com os mesmos parâmetros sempre darão a mesma resposta.
Recursão: São funções cuja definição contém a própria função, qualquer laço de repetição pode ser substituído por uma função com recursão. Além disso recursão muitas vezes permite definições mais intuitivas e declarativas.
Avaliação Preguiçosa:
Ao invés de avaliar o resultado de uma função imediatamente, linguagens de programação funcionais podem avaliar preguiçosamente, devolvendo apenas a promessa de que a função será executada quando necessário, isso é possível pois as linguagens garantem que todas as funções são puras. |
| 21 |
Rafael Bruno Ferreira Figueiredo |
"Paradigma" é a forma que seu programa lida com o problema. Em geral são utilizado paradigmas imperativos e estruturados na programação por conta, por partes, da limitação dos primeiros compiladores. Nos paradigmas declarativo, funcional e lógico a progamação não diz como fazer e sim o que deve ser feito pelo programa. Algumas linguagens sao 'multi paradigmas' em algumas partes, como Java e python com funções lambda, por exemplo.
Imperativo (Assembly):
descreve-se passo a passo o que deve ser feito (exemplo goto).
Relativamente de baixo nível (desempenho/dificuldade de interpretar)
não há segurança nas variaveis e funções.
Estruturado(C):
Cria estruturas para eliminar os "goto": for, while, funções.
Mais alto nivel mas com bom desempenho. Dividido em blocos lógicos. Variáveis locais por bloco logico.
Usa mudança de estados, o que pode gerar bugs, principalmente onde tem paralelismo e concorrencia.
Orientação a objetos(java, c++):
Classes! Encapsula os blocos em classes, objetos e métodos que podem ser gerais ou personalizados.
Segurança, menos variaveis globais, nem todos os problemas podem ser modelados em objetos. Usa muito estados mutáveis e dificil de paralelizar.
Declarativo(SQL, VHDL):
Fluxo lógico é implicito: o que fazer mas não como.
Menos bugs pois nao usa estados, Linguagem muito especificas a aplicação. Custo no desempenho.
Lógico:
Especifica fatos e regras de inferência.
O compilador cria o programa. simples de provar a corretude. Algoritmos complexos dificeis de implementar e tem execução lenta.
Funcional:
Calculo lambda. Programas sao composição de funções que nao utilizam estados.
Proxima das declarativas, nao tem estados e mutabilidade. Dificuldade de modelar problemas, usa muito garbage collector.
Programação funcional:
Efeito colateral é quando a função altera o estado global do sistema.
Funções puras nao tem efeito colateral.
Funções impuras "contaminam" funções puras.
Ausencia de estados.
Recursoes.
Avaliação preguiçosa: só executa caso o valor seja solicitado!
Haskell:
Puramente funcional! Somente funções puras. Avaliação preguiçosa, dados imutáveis. |
| 22 |
Diego Sousa Santos |
Aula 1.1
O que são Paradigmas de Programação?
-São os estilos de programação, a forma como você estrutura suas ideias e transmite isso para a linguagem computacional e resolver determinados problemas.
Dentre os paradigmas de programação, alguns dos mais populares são:
Imperativo, estruturado, orientado a objetos, declarativo, funcional e lógico.
Todos eles apresentam suas vantagens e desvantagens, apresentando-se como alternativas para cada tipo de problema.
Dentro desse contexto, muitas linguagens de programação são multi-paradigmas! Ou seja, contêm características de diversos paradigmas, apesar de na prática
acabarem favorecendo um paradigma específico que por sua vez acaba titulando a linguagem.
Aula 1.2
Efeito colateral e estados:
Um efeito colateral ocorre quando uma função altera algum estado global do sistema.
Funções puras:
Funções que não apresentam efeito colateral. Com uma mesma entrada, ela sempre terá um mesmo valor como resultado da operação.
Se uma função pura chama outra impura, então ela se torna impura. Ou seja, funções impuras são virais.
Avaliação Preguiçosa:
Quando uma expressão é gerada, ela gera uma promessa de execução ou thunk, que por sua vez é avaliado quando necessário.
Em haskell, por exemplo, se não usamos o valor de uma expressão ela nunca será chamada.
Podemos gerar promessas de listas infinitas sem nunca gerá-las definitivamente, por exemplo.
Algumas das melhores caracteristicas (como a avaliação preguiçosa, por exemplo), estão sendo incorporadas à linguagens mais modernas.
HASKELL:
-Linguagem puramente funcional
-Só aceita funções puras
-Declarativa
-Avaliação preguiçosa
-Dados imutáveis
-Tipagem estática e forte |
| 24 |
Eduardo Akira Ueno |
Paradigmas de programação são estilos de programação que descrevem uma solução de um problema computacionalmente. Os paradigmas mais "comuns"
sao o imperativo, estruturado, orientado a objeto, declarativo, funcional e lógico. Em particular no Paradigma Funcional temos como principais
características as funções puras, as que não tem efeito colateral, avaliação preguiçosa, aonde as avaliações sao atrasadas até quando os valores
sao necessários e o uso de recursão
|
| 25 |
Eduardo Maciel de Souza |
Nessa semana vimos dois assuntos nas aulas: Preparação do ambiente para programação em Haskell e os conceitos sobre os paradigmas de programação.
Na preparação do ambiente vimos a instalação do Stack, ferramenta para gerenciamento de pacotes e dependências de projetos em Haskell, e o Haskell language server, que irá nos auxiliar no dia-a-dia com sugestões e correções na sintaxe de nossos códigos.
Aprendemos sobre os paradigmas de programação (imperativo, estruturado, orientado a objetos, declarativo, funcional e lógico), sendo que o curso será focado no paradigma funcional, que se baseia no uso de funções para representar e solucionar problemas.
Normalmente as linguagens de programação são multi-paradigmáticas, ou seja, possibilitam o uso de vários paradigmas diferentes. Porém, o Haskell como ferramenta de estudo do paradigma funcional, foi escolhido por possuir certas limitações que forçam o uso correto dos conceitos funcionais. Exemplos são a tipagem forte, não mutabilidade, funções Lambda e avaliação preguiçosa, além de favorecer o uso de funções puras e recursões.
As funções puras são funções que não modificam o ambiente ao seu redor e sempre retornam o mesmo valor para uma mesma entrada (assim como as funções matemáticas). Por usar este tipo de funções, este paradigma tem taxa de bugs consideravelmente menor.
A recursão se consiste de funções que chamam a si mesmas durante a sua execução, porém com entradas ligeiramente diferentes. Esse artifício serve também para que laços sejam possíveis mesmo sem a possibilidade de mudança em uma variável de controle. |
| 27 |
Eugenio Veras Maria |
ex01 -> pensei que seria mais dificil comecar, achei interessante o teste buscar o nome da variavel
ex03 -> acabei não entendendo como usar o valor de ex01 e ex02 no ex03 sem repetir o codigo, mas creio que entenderei isso mais para frente
ex04 -> gostaria de printar os valores, usei putStrLn mas nao deu certo, enfim, não focarei muito nisso, acredito que entenderei no futuro |
| 28 |
Fabio dos Santos de Souza |
Nessa primeira semana da disciplina, aprendemos que um paradigma de programação é uma forma de se estruturar e descrever soluções computacionais para problemas. Em seguida, revisitamos os modelos/paradigmas mais conhecidos e padronizados.
Dado um problema, em geral, a sua descrição difere bastante de um paradigma para o outro, pois, cada modelo possui características, vantagens e desvantagens que podem ser relevantes.
Os paradigmas recordados foram :
Imperativo: Sequência de diretivas que alteram estados do sistema, buscando atingir um estado resultante que resolva o problema.
Estruturado: O problema a ser solucionado é descrito em subpartes, chamadas de procedimentos que executadas na ordem certa, resolvem o problema.
Orientado a Objetos: Os ditos objetos encapsulam dados e procedimentos próprios, que modelam uma parte do problema, a comunicação e a sobreposição de objetos gera a solução.
Declarativo: Para se obter uma solução para um dado problema, busca-se descrever características da solução desejada, sem a necessidade de se explicar como ela será construída.
Lógico: Busca especificar afirmações e regras de inferência, visando que ao final da descrição do mundo onde o problema foi caracterizado, se obtenha uma solução.
Fomos apresentados ao paradigma funcional, que é baseado no cálculo lambda de Alonzo Church. No modelo funcional os programas são composições de funções puras, e estados não são utilizados, o que significa que uma expressão não gera efeitos colaterais, e por isso elas podem ser avaliadas conforme são utilizadas.
Com o modelo funcional ganhamos bastante expressividade e consistência, porém, sem perder flexibilidade como no modelo Declarativo.
Fomos introduzidos também a linguagem puramente funcional Haskell, instalamos o Stack, uma gestor de projetos em Haskell e suas dependências; em seguida instalamos o que era necessário para se compilar código em haskell.
Os professores nos indicaram dois editores de código, Emacs e o Vim, e apresentaram como configurá-los.
|
| 29 |
Felipe Assis |
Paradigmas da progamação
São formas de estruturar seu codigo, cada uma tendo suas vantagens e desvantagens. O uso de funções puras ou não, ou seja se ela "para uma mesmo entrada tema a mesma saida?".
Existe recorrencia e como ela vai ser tratada. Que tipo de avalição o codigo sofrerá? será utilizado da avaliação preguiçosa?.
Estas citadas acima são alguns tipos de critérios utilizados na escolha do paradigma a ser utilizado
Alguns exemplos de paradigmas:
Orientada a objeto, são estruturas logicas segmentadas em objetos onde cada um possui seus methos e propriedades
Estruturada, onde utiliza-se da logica para criar uma estrutura de controle
Funcional onde utilizam-se de funções matematicas para descrever o que deve ser feito
|
| 30 |
Felipe Dias Correia |
A primeira aula foi composta sobre alguns paradigmas de programação, citando os mais populares como, Imperativo,
um programa é uma sequência de comandos que alteram o estado atual do sistema até atingir um estado final,
Estruturado, onde programas com uma estrutura de fluxo de controle e uso de procedimento e funções,
Orientado a Objetos, em que organização através de objetos que contém dados, estados próprios
e métodos que alteram ou recuperam os dados/estados. Os objetos comunicam entre si para compor a lógica do programa,
Declarativo, que especifica o que você quer, mas sem detalhar como fazer,
Funcional, onde programas são avaliações de funções matemáticas sem alterar estados e com dados imutáveis,
e por último, Lógico, em que especifica-se um conjunto de fatos e regras, o interpretador infere respostas para perguntas sobre o programa.
A segunda parte da aula foi sobre Paradigma Funcional, onde abordou sobre, Funções Puras, que não apresentam efeito colateral, mas sempre retorna a mesma respostas
Interação vs Recursão, que tem códigos mais enxutos, e Avaliação perigosa, que quando gera a expressão, ela gera também uma promessa de execução ou thunk. |
| 31 |
Felipe Ponsano Franke |
Primeiramente deve-se instalar o compiplador de haskell e preparar o ambiente. O compilador baixado foi o Stack, junto com o haskell language server para suporte. O editor de texto
de escolha foi o Vim,pois eu já sabia usar vim devido aos anos de iniciação científica.
O git também foi preparado, puxando as pastas.
Os paradigmas imperativo, estruturado e orientado a objetos são uma sucessão da abstração da linguagem. O imperativo é o mais próximo da linguagem de máquina.
O estruturado dá ao paradigma imperativo um pouco mais de acúcar sintático e organiza algumas coisas em blocos de repetição. O orientado a objetos já cria
uma linguagem de mais alto nível, onde se pode criar funções imperativas e usalas quando necessário. O código se torna mais conciso e organizado. Exemplos dessas linguagens
são o c++, python, java, etc. Eles são as mais usadas pois são as mais faceis de usar: os algoritmos são uma descrição de ordens e basta que o computador as siga.
O paradigma declarativo envolve linguagens onde se diz ao programa o que se quer. Um bom exemplo são as calculadoras matemáticas, onde se diz "integre a função f", "derive a função g", etc.
Essas lingaugens são de altissimo nível pois o compilador deve ser capaz de traduzir o que se quer para uma lista de comandos.
O paradigma lógico, a meu entender, se baseia em análise booleana. O usuário declara sentenças e o programa é capaz de inferir proposições a partir delas.
Finalmente o paradigma funcional, estudado aqui, se baseia em funções lambda que não alteram o estado do sistema. Em si elas não são tao uteis por não poderem dar uma resposta, já que isso
alteraria o estado do sistema, mas vale lembrar que nenhum paradigma é absoluto e suas transições não são discretas.
|
| 34 |
Gabriel de Mello Fiali |
Tutorial para instalação do stack, com a apresentação dos comandos criação, configuração e execução de um novo projeto de exemplo. Explicação da estrutura básica de um arquivo *Main.hs*. Embate na forma da escolha do melhor editor para ser utilizado.
Apresentação dos principais paradigmas de programação (Imperativo, Estruturado, Orientado a Objeto, Declarativo, Funcional e Lógico); comentando sobre as características e apontando algumas vantagens e desvantagens de cada um.
Início do foco no Paradigma Funcional, que tem como uma de suas principais características se expressar de forma próxima à de linguagens declarativas, sem suas limitações; além de não contar com estados e mutabilidade e necessitar de uma garbage collector para auxiliar o gerenciamento de memória.
Alguns elementos (não necessariamente obrigatórios):
- Funções puras: são funções que não contam com efeitos colaterais (alteração de um estado global do sistema, como uma variável global, por exemplo). Uma mesma entrada sempre retorna uma mesma saída nessas funções.
- Recursão: forma que as linguagens funcionais adaptam o comportamento que seria atrelado a laços iterativos.
- Avaliação Preguiçosa: a execução de funções é feita mediante a um processo de substituição, que contorna passos que seriam considerados desnecessários (por exemplo, parâmetros que não sejam chamados).
Haskell se trata de uma linguagem puramente funcional, com as características esperadas deste paradigma, além de contar com uma tipagem estática e forte. |
| 36 |
Gabriel Rossetto Migliorini |
Dentre os principais paradigmas computacionais existentes estão: estruturado, orientado à objeto, funcional e lógico. Cada um possui vantagens e desvantagens em relação ao outros. Além disso, linguagens de programação não estão restritas ao uso de somente um paradigma.
No paradigma estruturado, as intruções são escritas de modo imperativo. Ou seja, o programador vai dizer o quê e como deve ser feito. Além disso, nesse paradigma há a adição de blocos lógicos à organização do programa. Posteriormente (na cronologia) temos o advento do paradigma orientado à objeto. Nele as intruções (ainda imperativas) são organizadas em classes que contém estados nas quais só podem ser alterados mediante um código interno da classe.
Além do modo imperativo de dar as intruções também existe o modo declarativo. Nele dizemos o que queremos mas não como deve ser feito. Dois paradigmas que utilizam desse conceito são o lógico e funcional. No lógico, o resultado final (a resposta a uma pergunta) é derivado de uma série de fatos e regras previamente inseridas. Já no paradigma funcional, como o próprio nome sugere, as instruções são composições de funções - possui raízes no cálculo lambda.
|
| 37 |
Gabriel Mendonça Farias |
Na semana um, foi nos apresentado o conceito básico de como instalar e utilizar as funções básicas da linguagem Haskell, usando a ferramenta stack, para criar, executar, compilar e testar os projetos. Desta forma, mesmo em diferentes editores é possível acessar informações sobre a execução do projeto e seus erros. Daqui em diante, nos foi apresentado um pouco mais sobre os paradigmas na programação:
Imperativo → Que é como um passo a passo em linguagem de alto nível do que deve ser feito, seguindo metodicamente uma sequência de tarefas.
Estruturado → Aqui existem como blocos de funções, muitas vezes com variáveis locais, que podem ser acessadas por outras partes do código para resolver determinadas situações.
Orientado a objeto → Neste caso, os dados são organizados em classe, como uma árvore de associações que organizam as informações, é possível alterar valores em certas classes em diferentes objetos ao mesmo tempo e assim criar uma ampla interação entre os setores do código. Evitando o uso de variáveis globais.
Declarativo → Linguagem de alto nível onde se escreve o que quer, seguido pelo método a ser utilizado, o que facilita a visualização do que está sendo feito no projeto, mas pode o tornar complexo caso queira criar condições não pré definidas em suas funções.
Lógico → O desenvolvedor, infere suas perguntas e o software proporciona uma solução para o dado problema. O que pode facilitar a criação de códigos simples, mas dado ao limite de reconhecimentos de problemas deste método, determinadas situações se tornam complexas de serem descritas e resolvidas.
Paradigmas Funcionais → Onde temos funções puras (sempre retornam mesmo valor) e impuras (apresenta um efeito colateral, que pode gerar resultados diferentes a depender da situação)
|
| 38 |
Gabriel Murakami Alves |
Paradigmas de programção são tipos de classificação de linguagens baseado em
suas funcionalidades, sendo que uma linguagem pode possuir vários paragidmas ao
mesmo tempo.
Dentre os paradigmas temos os seguintes principais:
1- Imperativo (Ex: Cobol, Pascal)
O paradigma imperativo é executado de forma procedural, intrução por instrução
em uma sequência definida. O foco está em como uma execução deve ser feita.
2- Declarativo (Ex: Mercury, SQL)
O paradigma declarativo, diferente do imperativo, está voltado para o problema
que deve ser resolvido e não em como deve ser resolvido. Ou seja, é um paradigma
com um nível de abstração maior que o anterior.
3- Funcional (Ex: Erlang, Haskell)
O paragidma funcional é voltado para a execução de funções para a resolução de
problemas. O problema é dividido para ser executado em blocos que passarão de
função em função até chegar em um resultado.
4- Lógico (Ex: Mercury, Prolog)
O paradigma lógico é voltado para resolução de problemas por inferência. No corpo
do programa são declarados algumas premissas que se verdadeiras provam a veracidade
do teorema/problema.
5- Orientado a Objetos (Ex: Java, Python)
O paradigma orientado a objetos traz um modelo que tenta de se aproximar do mundo
real transformando "entidades" em objetos com características definidas. Cada
objeto é uma classe, com atributos e métodos (funções) que descrevem seu comportamento.
Sendo que devem implementar herança, polimorfismo e encapsulamento.
6- Estruturado (Ex: Perl, Go)
O paradigma estruturado é voltado para a sequência, decisão e iteração. Normalmente
é executado em um bloco de código, é extremamente direta na resolução e eficiente.
|
| 39 |
Gabriel Albano Santos |
Um paradigma de programação é um estilo de programação, ou seja, é a forma pela qual é descrita a solução computacional de um problema. Existem diversos paradigmas: imperativo, estruturado, orientado a objeto, funcional, etc. Nesse curso iremos focar no paradigma funcional utilizando a linguagem Haskell, uma linguagem puramente funcional. Isso quer dizer que, ao contrário da maioria das linguagens populares de hoje em dia, o Haskell não é multi-paradigma, aderindo somente ao paradigma funcional.
A programação funcional tem como principal filosofia o paradigma funcional, no qual programas são avaliações de funções matemáticas sem alterar estados e com dados imutáveis. O paradigma funcional possui algumas características consideradas fundamentais. Entretanto, isso não quer dizer que elas estão presentes em todas as linguagens que o adotam. Abaixo, três das principais características:
1. Funções puras
São funções que não apresentam efeito colateral (quando uma função altera algum estado global do sistema, como uma variável global, ou lê entrada de dados, ou imprime algo na tela). Ou seja, ao receberem a mesma entrada, sempre devolvem a mesma resposta.
2. Recursão
Em linguagens funcionais os laços iterativos são implementados via recursão, levando geralmente a um código mais enxuto e declarativo.
3. Avaliação preguiçosa
Quando uma expressão é gerada, ela gera uma promessa de execução, ou thunk. Se e quando for necessário, o thunk é avaliado. Isso quer dizer que o Haskell tem a capacidade de detectar quando um termo não é utilizado numa função, e nesse caso, esse termo nunca chega a ser calculado. Essa característica possibilita, por exemplo, trabalhar com listas infinitas. Em Java, esse conceito é implementado com streams.
|
| 40 |
Gabriel Bellomi Meale |
Configuração de ambiente:
Para ambiente linux:
- instalar a ferramenta Stack
- baixar os arquivos do Haskell-Language-Server e configurar a variável PATH
Possíveis erros:
- Foi optado por instalar a máquina virtual no windows com ubuntu. Apesar do
passo a passo do professor estar correto, talvez seja necessário utilizar o
wsl2 conforme documentação: https://docs.microsoft.com/pt-br/windows/wsl/install-win10
Alguns comandos necessários para o ubuntu não funcionavam corretamente na versão do WSL 1.
Aula 1.1:
Um paradigma de programação define principalmente o estilo de programação desejado e,
de forma grosseira, uma forma de organizar o código.
Alguns do paradigmas mais populares são o Imperativo, Estruturado, Orientado a Objetos, Declarativo,
Funcional e Lógico.
Hoje em dia, a maioria das linguagens populares extrai o que há de melhor em cada paradigma,
fazendo um merge dessas informações e montando uma linguagem multi-paradigma. Haskell é uma linguagem de paradigma funcional.
Algumas das principais características desse paradigma é:
Funções puras - são aquelas que não apresentam efeito colateral. Isto é, elas não são capazes de modificar o estado global de um sistema.
Recursão - os laços iterativos são implementados com recursão.
Avaliação preguiçosa - quando uma expressão é gerada, ela gera uma promessa de execução que se ou quando necessário, é avaliada.
|
| 41 |
|
Nessa primeira semana do curso, tivemos a aula de apresentação e aulas focadas em ajudar a preparar o ambiente de desenvolvimento, além de uma para introduzir aos conceitos de programação funcional e outros paradigmas em geral.
Nas aulas de preparação do ambiente de desenvolvimento, foi ensinado como instalar o stack, que é uma ferramenta de compilação e gerenciamento de bibliotecas para projetos em haskell, e como configurar os editores VIM (Up and running), e emacs (nem me dei o trabalho).
A segunda aula, tratou-se da introdução a programação funcional, e vários conceitos foram apresentados. Aprendemos sobre outros paradigmas, e foram apresentadas diversas diferenças, entre vantagens e desvantagens dos mesmos. Por exemplo, no paradigma estruturado, temos como vantagem que o programa é dividido em blocos lógicos, cada qual com uma função explícita (se for bom programador), e como desvantagem, que esse paradigma não evita que certas informações sejam utilizadas fora do seu contexto. Também nessa aula, durante a introdução do paradigma funcional, foi apresentado o conceito de funções puras, que trata-se de um dos conceitos teóricos sobre os quais, a linguagem haskell foi construída.
Funções Puras são funções que não apresentam efeito colateral no estado do programa quando estas são executadas, e consequentemente, ao executar a mesma função com a mesma entrada, sempre se obtém a mesma resposta. Com exemplos na linguagem C, temos a função strlen como função pura, e a função printf como impura. Depois disso, o conceito de avaliação preguiçosa (o jeito que a linguagem haskell avalia o código escrito) foi apresentado. Trata-se de um conceito que basicamente se define como "funções somente são executadas quando chamadas".
Após as duas aulas, tivemos uma lista avaliativa simples, mais para testar a configuração base do ambiente de desenvolvimento.
|
| 42 |
Giovanni Almeida de Sousa |
Os paradigmas de programação são um meio de classificar as linguagens com base em suas funcionalidades. Os principais paradigmas são:
•Imperativo: O programa é composto por uma sequência de comandos que instruem como a máquina deve computar os processos (ex: C, C++ e Java);
•Estruturado: Programas com uma estrutura de fluxo de controle e uso de procedimento e funções (ex: Pascal e Cobol);
•Orientado a objeto: É o mais popular nas empresas por ser escrito como uma coleção de classes e objetos para facilitar a comunicação. Os objetos se comunicam entre si para compor a lógica do programa. (ex: Python, C#, PHP);
•Declarativo: O programa declara as propriedades do resultado desejado, mas não detalha como fazer. (ex: SQL);
•Funcional: Os programas são avaliações de funções matemáticas sem alterar estados e com dados imutáveis. (ex: Haskell);
•Lógico: Especifica-se um conjunto de fatos e regras e o interpretador infere respostas para as perguntas sobre o programa. (ex: Absys e Ciao).
A maioria das linguagens são multi-paradigmas, pois contém aspectos de diversos paradigmas, porém favorecem uma que será sua característica principal.
A disciplina será focada no paradigma funcional. Suas características são:
•Funções puras: não apresentam efeito colateral (quando uma função altera uma variável global do sistema). O programa sempre terá a mesma resposta para a mesma entrada.
•Recursão: código mais enxuto e declarativo.
•Avaliação preguiçosa: A função só é avaliada quando e se necessária. O que também permite a criação de listas infinitas.
Especificamente será utilizada a linguagem puramente fucional, Haskell.
|
| 43 |
GEORGE HARRISON ROCHA |
Paradigmas de Programação: estilo de programação, a forma como o programador descreve a solução computacional de um problema.
Paradigmas mais populares:
• Imperativo: descreve-se passo a passo o que deve ser feito.
- Fluxo de controle explícito;
porém...
- Pode ser difícil racionalizar o resultado dos passos;
- Variáveis globais e funções podem ser usadas/alteradas indevidamente.
• Estruturado: Estrutura o código imperativo em blocos lógicos.
- Estimula o uso de variáveis locais;
porém...
- Usa mudança de estados.
• Orientado objeto: Encapsula os dados em classes cada qual contendo seus próprios estados e métodos.
- Encapsula códigos imperativos para segurança e reuso;
- Evita o uso de variáveis globais;
porém...
- Uso pesado de estados mutáveis;
- Composição de funções pode bagunçar o fluxo lógico do código.
• Declarativo: especifica o que o programador quer, sem detalhar como fazer.
- Utiliza uma linguagem específica para o domínio da aplicação;
- Minimiza uso de estados;
porém...
- Fazer algo não suportado nativamente na linguagem pode levar a códigos complexos;
- Pode ter um custo extra no desempenho.
• Funcional: programas são avaliações de funções matemáticas sem alterar estados e com dados imutáveis.
- Não utiliza estados;
- Expressividade próxima de linguagens declarativas;
porém...
- A ausência de mutabilidade dificulta o gerenciamento de memória;
• Lógico: especifica-se um conjunto de fatos e regras, o interpretador infere respostas para perguntas sobre o programa.
- O compilador constrói o programa baseado em fatos lógicos;
- Provar a corretude do programa é simples;
porém
- Algoritmos mais complexos podem ser difíceis de expressar dessa forma;
- Costuma ser mais lento para operações matemáticas.
|
| 44 |
Miguel Augusto Martins Pedro |
|
| 45 |
Giancarlo Kami Dell Aringa Viana |
Na aula foram introduzidos conceitos de paradigma de programacao, e no exercicio foi explicado a instalacao e execucao de um simples codigo teste. |
| 46 |
Gabriel Rios Souza |
Um Paradigma de Programação é a forma como você descreve a solução computacional de um problema.
Os 6 principais tipos de paradigma são:
- Imperativo: sequência de comandos que parte de um estado inicial até um estado final (receita de bolo - GoTo)
- Estruturado: uso de procedimentos e funções com estruturas de fluxo de controle.
- Orientado a Objeto: uso de objetos e classes com atributos e métodos próprios, os objetos se comunicam entre si.
- Declarativo: Escreve o que você deseja, mas não mostra como fazer.
- Funcional: Não há mudanças nos estados e os dados são imutáveis, baseado em funções matemáticas.
- Lógico: Utiliza um conjunto de regras e premissas, com isso o interpretador infere as respostas desejadas.
Exemplos de Paradigmas em Algumas Linguagens:
- Python: Estruturado, Orientado a Objetos e Funcional.
- Java: Orientado a Objetos e Funcional.
- SQL: Declarativo.
- ProLog: Lógico.
- Haskell: Funcional.
Paradigma Funcional:
- Baseado no cálculo λ.
- Programas são composições de funções.
- Não utiliza estados (reduz a quantidade de bugs).
- Declarativo.
- Em linguagens funcionais os laços iterativos são implementados via recursão (Geralmente leva a um código enxuto e declarativo)
Haskell:
- Linguagem puramente funcional.
- Somente aceita Funções Puras:
Ao executar a mesma função com a mesma entrada sempre se obtém a mesma resposta.
Funções que não apresentam efeito colateral (altera algum estado global do sistema)
- Utiliza Avaliação Preguiçosa:
Quando uma expressão é gerada, ela gera uma promessa de execução ou thunk.
Se e quando for necessário, o thunk é avaliado.
Avaliação Preguiçosa é o oposto da Avaliação Estrita (Avalia todas as partes do código, mesmo se não forem utilizadas).
- Dados imutáveis (não utiliza estados).
- Tipagem estática e forte.
|
| 47 |
Giulia Ribeiro de Carvalho |
|
| 48 |
Lucas Mazim de Sousa |
As aulas desta semana foram sobre: configuração do ambiente de programação e paradigmas de programação. Para a configuração, o haskell stack foi utilizado como ferramenta de gerenciamento de build, enquanto o haskell language server foi configurado para facilitar a experiência de desenvolvimento. Dentre outras características, o haskell language server é capaz de sugerir correções e/ou melhorias no código enquando ele é escrito. Como ferramenta de edição de texto, decidi utilizar o Vim.
No tópico seguinte, revisitamos os conceitos, vantagens e desvantagens dos paradigmas de programação imperativo, estruturado, orientado a objetos, declarativo, funcional e lógico. O foco maior foi dado ao tema da disciplina, o paradigma funcional. Dentre as principais características deste paradigma estão as funções puras, iteratividade como recursão e a avaliação preguiçosa. Estas características dificultam a ocorrência de efeitos colaterais.
|
| 49 |
William de Souza Gomes |
1. A lógica para o exercício 1 foi que em 1 minuto há 60 segundos, então multiplica-se por 42 e soma-se os segundos
2. Descobrimos quantos milhas há em um km pelo fração (1 / 1.61) e dps multiplicamos por quantos km
3. divide-se o tempo que demorou pela quantidade de km percorrida e teremos o tempo que demorou
4. Usamos o resultado da 2, onde sabemos as milhas em 10 km e dps convertemos o tempo para hora pela expressão (42/60 + 42/3600) e dividimos o distancia pelo tempo em horas
5. Quantidade vezes o preço aplicado ao desconto de compra e dps quantidade - 1 vezes o preço para os fretes adicionais mais o primeiro frete. |
| 50 |
GUILHERME FERREIRA GALDINO |
Na primeira semana foi passado a introdução da disciplina Paradigmas de Programação que se resume a apresentar uma forma de descrever a solução computacional de um problema. Os principais paradigmas são Imperativo, Estruturado, Orientado a Objeto, Declarativo, Funcional e Lógico.
O Imperativo seria apenas uma sequência de comandos que devem se seguir até atingir um objetivo. O Estruturado conta um fluxo de controle permitindo o uso de funções e procedimentos. Orientado a Objeto se dá pela organização do código através de objetos que contém estados, dados e métodos, em que cada um possui suas particularidades. O Declarativo especifica apenas o que se deseja sem detalhar como fazer tais operações. Funcional é voltado para avaliação de funções matemáticas sem alterar os estados e com dados imutáveis. E por úlimo, o Lógico, que especifica regras a serem seguidas e o interpretador infere respostas que se adequam a essas regras.
Entre todas esses paradigmas, o curso tomará como base o Paradigma Funcional. Basicamente as principais características deste paradigma além das já citadas são que ela é baseada no cálculo lambda, possui apenas funções puras, utiliza-se da recursão para operações de looping e sua avaliação das funções é dita como preguiçosa.
Primeiramente, ela possui apenas funções puras devido o fato de não alterar o estado do sistema e apenas trabalhar com dados imutáveis, ou seja, não apresenta efeito colateral. Assim, ao executar uma função com a mesma entrada sempre terá a mesma saída. Isso permite que programa possa ser reorganizado e otimizado, pois é possível computar expressões em qualquer ordem.
Por fim, a sua avaliação é dita como preguiçosa pois quando uma expressão é gerada ela não é calculada imediatamente, apenas gera um promessa de execução, conhecida como thunk. Desta forma, permite a criação de listas infinitas já que na prática não vai ser executada realmente.
|
| 51 |
Guilherme Fuzisawa de Sa |
Nesta semana o ambiente de desenvolvimento foi configurado e estudamos/revisamos alguns paradigmas de programação.
Na configuração do ambiente nos foi apresentado dois editores de texto, emacs e vim, deixando à escolha do aluno qual editor ele o preferir. Nunca tinha ouvido falar do Emacs, portanto vou adota-lo durante este quadrimestre para esta matéria. (agora que me dei conta que estou escrevendo esse resumo pelo vim).
Os paradigmas mencionados são: Imperativo, Estruturado, Orientado a objeto, declarativo, funcional e lógico. Sendo a maioria já conhecidos e/ou utilizados por nós mortais.
Linguagens como Python, Java e Scala são linguagens multi-paradigmas, enquanto o Haskell não o é. Devido à esta característica, esta disciplina será ministrada em Haskell.
No paradigma funcional definimos: funções puras, funções impuras e definimos alguns conceitos de avaliação como a preguiçosa e estrita.
|
| 52 |
Gustavo Matheus Lima Santos |
Um Paradigma de Programação pode ser definido como um estilo de programação, ou como a maneira pela qual se descreve a solução computacional de um problema. Os paradigmas mais populares são: Imperativo, Estruturado, Orientado a Objetos, Declarativo, Lógico e Funcional.
- Imperativo: o código é um passo-a-passo do que deve ser feito. Utiliza o “goto”. O fluxo de controle é explícito e completo. Utiliza mudanças de estados.
- Estruturado: o código é estruturado em blocos lógicos que contém instruções imperativas com uma função explícita. Não é necessário utilizar “goto”. Utiliza mudanças de estados.
- Orientado a Objetos: modela o mundo real através de objetos que são instâncias de classes e possuem seus próprios estados e métodos, não compartilhados. Um objeto comunica-se com outro através de troca de mensagens, ou chamadas/invocações de métodos. Utiliza mudança de estados.
- Declarativo: especifica-se apenas “o que” se deseja, não sendo necessário definir o “como”. O fluxo lógico é implícito. Minimiza o uso de estados.
- Lógico: especifica-se apenas os fatos e regras de inferência e o compilador monta o programa. O objetivo, ou retorno, é escrito em forma de pergunta.
- Funcional: o programa é uma composição de funções, baseado em cálculo lambda. É um paradigma, de certa forma, declarativo. Não utiliza estados.
O Paradigma Funcional conta com certas particularidades:
- Funções Puras: não apresentam efeito colateral, ao executar a mesma função com a mesma entrada sempre se obtém a mesma saída
- Funções Impuras: oposto das funções puras. São “virais”, se uma função pura chama uma impura a primeira torna-se impura.
- Laços iterativos são implementados via recursão.
- Avaliação Preguiçosa: uma expressão gera uma promessa de execução, ou thunk. O thunk só é avaliado quando necessário.
Haskell é uma linguagem puramente funcional com tipagem estática e forte.
|
| 53 |
Henrique Augusto de Oliveira |
Um Paradigma de Programação é uma forma ou maneira de estruturar ideias e pensar para sair de um problema e chegar na solução.
Dos Paradigmas existentes, os principais são o Imperativo, Procedural, Orientado a Objetos, Declarativo, Lógico e, o que será estudado na disciplina, o Funcional.
O Paradigma Funcional é baseado no cálculo lambda, utiliza composição de funções e, por não apresentar estado e mutabilidade, favorece a uma redução de bugs.
Uma das características é o uso de funções puras, que não apresentam efeitos colaterais. Um efeito colateral ocorre quando uma função altera o estado global do sistema. Por meio de funções puras, existe o conceito de Transparência Referencial, que, a partir de qualquer lugar que a função é chamada, a semântica e o que o código faz não é alterado.
Uma outra característica que vale ser destacada é a avaliação preguiçosa, que consiste na geração de uma promessa de execução ou thunk e, quando necessário, o thunk é avaliado.
Nas linguagens funcionais, os laços iterativos são feitos via recursão, fazendo com o código seja mais enxuto e declarativo.
Muitas das linguagens existentes são multiparadigma, mas sempre acabam favorecendo um paradigma específico, o que confere o título do paradigma para a linguagem.
A linguagem funcional estudada será o Haskell, que é uma linguagem puramente funcional. O gerenciador de dependências utilizado será o Haskell Stack. Para verificar se o Stack foi instalado, é criado um projeto teste e é feito um build para algumas configurações básicas serem instaladas, como o GHC, que é o compilador do Haskell.
A fim de verificar erros de execução, é instalado o Haskell Language Server, sendo este, possível integrar-se em editores de texto como o Emacs e Vim, por exemplo.
|
| 54 |
Carlos Eduardo de Abreu Batista |
Antes de mais nada, foi efetuado o setup para desenvolvimento em Haskell, - abrangendo a ferramenta de build e compilação e o tooling para a edição de código Haskell em dois editores (vim e emacs - abrangendo desde instalação de plugins até a configuração de language servers) no W10 com WSL e em um Linux (Ubuntu). Segui as recomendações para a utilização em um Manjaro e geralmente oscilo meu desenvolvimento entre o neovim e o VS Code (já tentei algumas vezes entrar para a emacs church, mas, sem sucesso...).
Para build/compilação/dep-man vai ser utilizado o [Stack](https://docs.haskellstack.org/), achei a instalação bem direta, embora eu tenha encontrado em conversa com colegas outras alternativas que pareceram bem interessantes, como o [ghcup](https://www.haskell.org/ghcup/), nos moldes do rustup e subir uma máquina com o [NixOS](https://nixos.org/). Adorei o fato de que o GHC permite configurar mais warnings via descrição no yaml e tanto o gerenciamento de dependências como o sistema de módulos pareceu similar ao de Python, que já estou mais acostumado.
Além disso, na presente semana foi apresentado a definição do objeto de estudo da disciplina, o Paradigma de Programação, mostrando os mais populares: POO, Estruturado, Declarativo, Imperativo, Lógico e Funcional. Por fim, mostrou-se em mais detalhes (ainda sendo apenas um spoiler das próximas semanas) algumas características de Haskell, como: avaliação estrita, stateless, como funcionam funções puras e o que é um side-effect, bem como o fato de que, como todas linguagens funcionais, a relação fundamental com o lambda-calculus do Alonzo Church. |
| 55 |
Heber Camacho Desterro |
Um paradigma de programação é uma forma de resolver um problema computacional, com diferentes estilos de código.
Dentre os paradigmas mais populares (imperativo, estruturado, orientado a objeto, declarativo, funcional e lógico), esta disciplina focará no paradigma funcional, pois os outros paradigmas já foram tratados em outras disciplinas do curso.
As linguagens geralmente são multi-paradigmas, mas sempre algum paradigma se destaca e se torna mais fácil utilizar com cada linguagem específica. No caso do paradigma funcional, vamos aprender a linguagem haskell.
As principais características de uma linguagem funcional são: uso de funções puras, uso de recursão e avaliação preguiçosa.
Funções puras são funções sem efeitos colaterais, ou seja, não alteram o estado global do sistema (por ex. alterando uma variável global).
Mesmo só chamando funções puras, uma função pode ser impura. Uma função que chama funções impuras também é impura.
O fato de se trabalhar com funções puras e sem estados evita muitos bugs causados exatamente pela alteração de estados.
Em linguagens funcionais os laços iterativos são implementados via recursão para tornar o código mais enxuto e declarativo.
A avaliação preguiçosa é uma forma de evitar processamento desnecessário de expressões que nunca são avaliadas. Isso permite, por exemplo, criar listas infinitas, porque os valores que não forem utilizados também não serão calculados.
|
| 56 |
Eduardo Alves Ferreira Junior |
Haskell Stack - Ferramenta para gerenciamento de compilação e dependências de projetos.
Comandos:
* stack build -> compila projetos;
* stack run -> roda o projeto.
Instalações (pontos divergentes do que foi apresentado nas vídeo-aulas):
* Haskell Language Server Linux p/ GHC 8.10.4. Como prefiro o editor Sublime em sistemas com interface gráfica, utilizei o LSP para integrar o Haskell Language Server a ele. Nota: Para que isto funcione, deve-se abrir o diretório do projeto haskell inteiro no editor ("abrir pasta");
* Versão LTS - 17.15.
Paradigma de Programação:
* É a forma que uma solução computacional é descrita (o "estilo");
* Há diferentes paradigmas, cada um com suas principais vantagens e desvantagens (ex: Funcional, Lógico, Estruturado etc);
* Paradigma Funcional, que é o que vamos utilizar na matéria, tem as características principais: Funções Puras, Recursão e Avaliação Preguiçosa;
Paradigma Funcional:
* Funções Puras não têm efeito colateral. Sempre têm o mesmo resultado quando são utilizadas as mesmas entradas. O conceito pode ser um pouco nebuloso e é muito importante verificar os contextos da função para definí-la como pura (dependências etc); funções impuras são "virais".
* Efeito colateral: quando uma função altera algum estado global do sistema;
* Um programa com apenas funções puras não seria útil, pois não receberia entradas externas (teclado, mouse) nem geraria saídas (impressão em tela etc). Ausência de estados.
* Para manter-se útil, o Haskell "reserva" as impurezas para o ambiente de execução, isto é, a linguagem em si permanece pura.
* Avaliação preguiçosa: não "calcula" o resultado de uma função até que seja estritamente necessário.
Obs: hoje a maioria das linguagens mesclam conceitos de diferentes paradigmas. O Haskell é puramente funcional. |
| 58 |
Henrique Fantato Silva de Albuquerque |
Nome: Henrique Fantato RA: 21053916 Professor: Emílio Francesquini
Paradigmas de Programação – Resumo Semana 1
Paradigmas de programação são as formas de estruturar uma solução computacional de um problema.
Existem muitos paradigmas, dentre eles os mais famosos: Imperativo(sequência de comando para alterar o estado inicial até o resultado),
Estruturado(fluxo de controle, uso de procedimentos e funções), Orientado a Objeto(objetos que contém dados, estados e métodos próprios que alteram os dados e estados.),
Declarativo(diz oque quer, mas sem dizer como), Funcional(avaliações de funçoes matemáticas sem alterar dados/estados) e Lógico( conjuntos de fatos e regras,
interpretador infere respostas para perguntas contidas no programa).
Cada paradigma possui vantagens e desvantagens, devendo ser analisado o melhor paradigma para determinado problema.
O paradigma funcional tem por características somente funções puras(não apresentam efeito colateral,
com as mesmas entradas sempre obtemos as mesmas saídas), utiliza recursão(todos os laços iterativos são recursões,
códigos mais enxutos) e possui avaliações preguiçosas(expressões geram promessas de execução(thunk), sendo somente executado quando utilizado).
Funções que chama outras funções impuras, são automaticamente consideradas impuras. Dado a ausência de estados, são evitados muitos problemas de implementação,
sendo o lema da linguagem: “Se compilou, o código está correto!”
|
| 59 |
Ian Lacerda da Silva |
|
| 60 |
Igor Sawaki |
Na programação, existem diversas maneiras ou estilos de se abordar e solucionar um problema, que são chamadas de paradigmas de programação.
Dentre estes paradigmas, temos:
- Imperativo: onde um programa segue uma sequência determinada de passos ou comandos em ordem, alterando estados até chegar em um estado final;
- Estruturado: o programa é organizado em blocos lógicos, que realizam determinadas instruções;
- Orientado a objeto: o programa é descrito através de objetos que contém suas próprias características e funções;
- Declarativo: o usuário declara o que ele deseja fazer, e não como o programa deve fazer o que foi requerido;
- Funcional: o programa utiliza funções matemáticas para realizar o que foi requerido;
- Lógico: o usuário declara fatos e regras, o programa responde as perguntas com base nos dados inseridos.
Cada paradigma pode tratar os dados e funções com ou sem mudanças de estados, e muitas linguagens acabam sendo mais identificadas de acordo com um determinado paradigma mas conter certas características de outros.
No paradigma funcional, são consideradas três características:
- Funções puras: as funções não apresentam efeitos colaterais (alteração de estados ou variáveis);
- Recursão: os laços iterativos são implementados através de recursão;
- Avaliação preguiçosa: utilizando substituições na avaliação das expressões, cálculos desnecessários não são computados.
A linguagem Haskell possui estas características do paradigma funcional, além de:
- ser puramente funcional;
- aceitar comente funções puras;
- trabalhar com dados imutáveis;
- tipagem estática forte;
- ser declarativa.
|
| 61 |
Janusa Maia da Silva |
Preparando o ambiente:
Instalação do Haskel Stack, que simplifica o trabalho de programação, permitindo focar no código ao invés de problemas com bibliotecas.
Instalação do Haskell no Linux:
- Acessar https://docs.haskellstack.org/
- Executar: wget -qO- https://get.haskellstack.org/ | sh
- Adicionar ‘/home/user/.local/bin’ no início do PATH
- Testar: stack new projeto-teste simple
- Compilar: stack build, caso o GHC não seja encontrado ele é instalado e depois compilado
- Executar: stack run
Em https://www.stackage.org/, distribuições de pacotes do haskell.
Haskell Language Server, ferramenta que executa verificando a sintaxe do código, identificando possíveis erros e dando sugestões.
Instalando:
- Acessar https://github.com/haskell/haskell-language-server
- Na release mais recente estável e baixar os arquivos ‘haskell-language-server-Linux-X.XX.X.gz’ (escolher a versão que instalamos no GHC) e ‘haskell-language-server-wrapper-Linux.gz’
- Extrair os arquivos
- Mudar as permissões dos arquivos para serem executados
- Renomear os arquivos, retirando a palavra ‘Linux’
- Criar o diretório bin em .local e incluir no PATH
- Mover os arquivos para esse diretório bin
- Testar, dentro da pasta do projeto-teste, executar o haskell-language-server-wrapper.
Instação do doom-emacs e do VIM;
Paradigmas de programação: estilo de programação, a forma como você descreve a solução computacional de um problema.
Diferentes paradigmas: Imperativo, Estruturado, Orientado a objeto, Declarativo, Funcional e Lógico.
As linguagens são na verdade multi-paradigmas, pois tem características de vários paradigmas, mas são definidas pelo que é mais expressivo na linguagem.
Características de um Paradigma Funcional: Funções puras, recursão e Avaliação Preguiçosa.
Efeito colateral ocorre quando uma função altera algum estado do sistema.
Função impura, se uma função chama uma função impura, ela se torna impura.
Características do Haskell: Puramente funcional, somente funções puras, declarativa, Avaliação preguiçosa, são imutáveis, tipagem estática e forte.
|
| 62 |
Jean Augusto de Araujo |
Na aula 0, foi ensinado o processo de configuração do ambiente Haskell, a instalação do Haskell Stack,
com atualização da PATH do OS.
Foram apresentados os comandos de criação de projeto com "stack new", "stack build" e "stack run".
Também foi ensinado a configurar o haskell language server no emacs doom. Havia um segundo vídeo,
sobre a configuração do ambiente Haskell no editor VIM, mas após experiência contra intuitiva no uso,
migrei a instalação do Haskell Language Server para o Atom, escolhendo esse como editor de texto.
Na aula 1, foi apresentado o conceito de paradigma de programação (imperativo, declarativo, lógico e funcional)
e suas diferenças e, como no geral, as linguagens de programação são multi paradigmas, além dos prós e contras,
já que o paradigma funcional é baseado em cálculo lambda.
Já na aula 1.2 houve maior introdução sobre o paradigma funcional, Haskell e suas características:
funções puras, recursão e avaliação preguiçosa.
As funções puras não geram efeitos colaterais que alteram o estado e como isso colabora para
evitar bugs após compilar. Com o paradigma funcional, recursividade é pode substituir
iterações. A avaliação preguiçosa, gera uma promessa de execução conhecida como "thunk", que
será avaliada e terá o cálculo feito, apenas caso seja necessário. Isso permite, por exemplo,
listas infinitas. Nos exemplos, já foi introduzida o formato de linguagem do Haskell (linguagem enxuta,
com pouco uso de caracteres de demarcação, como parênteses, chaves e ponto virgula).
Haskell é puramente funcional, declarativa, usa apenas funções puras, possui avaliação preguiçosa, dados imutáveis e
tipagem estática e forte.
No material, também foram ensinados os comandos para utilização do git classroom, como "git status", "git add -A",
"git commit -m \"texto\"" e "git push".
|
| 63 |
JHONATA SANTANA LOUZADA DE AGUIAR |
|
| 65 |
Karen Oliveira dos Santos |
Paradigma é o estilo de programação e como vai arquitetar a solução.
Muitas linguagens são multiparadigmas, ou seja, favorecem um paradigma ou outro.
-Paradigmas:
Imperativo: Descreve passo a passo, temos o goto (pular para outra linha, evoluiu para procedural e estruturado. É bem explícito, parecido com linguagem de máquina, devido a falta de estrutura, temos uma dificuldade na leitura do código.
Estruturado: Temos estrutura (if/else/for) e outras possibilidades para evitar goto, estimula variáveis locais, devido a limitação de acessos variado de acordo com o contexto.
Orientação a Objeto: Encapsula dados em classes. Devido ao encapsulamento em classes, uso de estadso mutáveis e a aplicação de Design Patterns, se torna díficil de paralelizar.
Desclarativo: Fluxo lógico é implicito, tem uma boa diferença do que se deseja obter e de como proceder. É bem estruturada, fazer coisas fora do propósito original, pode levar a um código confuso e o fato da instrução conter somente o que o programador deseja, pode gerar cuato de processamento para fazer o planejamento dessa instrução.
Lógica: Especifica os fatos e as regras de inferência, o compilador constrói o programa para você, baseado nos fatos e regras e devido a essa base, também consegue-se provar que o programa está correto e um outro ponto, quanto mais complexo o problema, mais díficil fica expressar isso em código.
Funcional: Tem três características:
-Função Pura: Não tem efeito colateral, ou seja, sempre devolverá a mesma reposta e não tem a alteração do estado global. Isso possibilita alguns cálculos sendo feitos de forma "preguiçosa", facilitando organização e paralelismo, lembrando que caso uma função aparentemente pura que chama funções impuras é impura.
-Avaliação Preguiçosa: Só irá fazer o cálculo quando o resultado for realmente necessário.
-Recursão: Uma função chamar a si mesma (MDC, Fatorial). |
| 66 |
Karoliny dos Anjos Pereira Alves |
|
| 67 |
Kelvin Alves dos Santos |
Ex 01: Foi criada uma função de três variáveis que retorna um número, as variáveis são necessárias para lidar com os valores do enunciado.
Ex 02: Aqui há a recepção de dois valores na função tornando ela um pouco mais simples que o primeiro caso.
Ex 03: Com o auxílio dos exercícios anteriores esta questão foi implementada, nenhum valor adicional foi necessária.
Ex 04: Aqui também foi possível utilizar um resultado anterior na construção da solução, com uma estrutura similar as duas imediatamente anteriores.
Ex 05: Neste caso foi necessário utilizar cinco variáveis, não cheguei a testar uma possibilidade, mas tenho quase certeza que poderia aproveitar estruturas anteriormente implementadas na construção dessa solução. Por maior praticidade não fui por este caminho, a solução como nos dois primeiros casos é stand alone.
|
| 68 |
Kevin Willy Antunes de Freitas |
|
| 69 |
Kevin Martins Tsukioka |
|
| 70 |
Kleverson Nascimento Pinto |
Os paradigmas mais conhecidos são:
- Imperativo
- Estruturado
- Orientado a objeto
- Declarativo
- Funcional
- Lógico
As linguagens de programação que conhecemos se encaixam nestes paradigmas, sendo que muitas delas são multi-paradigmas, ou seja, adotam características de mais de um paradigma, por exemplo: Java é considerada orientada a objeto por ter características predominantes desse paradigma, apesar de ter características de outros paradigmas como o uso de lambda functions que vem do paradigma funcional.
Vamos usar Haskell por ser uma linguagem que usa um único paradigma, o funcional.
Principais características do Haskell:
- Funções puras: são funções que sempre obtém a mesma resposta dada a mesma entrada e não apresentam efeitos colaterais. Funções que usam outras funções impuras são necessariamente impuras. Funções que usam somente outras funções puras não necessariamente são puras, pois ela em si pode ter código impuro.
- Recursão: como evitamos ao máximo a alteração de estados, iterações costumam ser implementadas usando recursão ao invés de laços como for e while, este é um aspecto muito presente no paradigma funcional.
- Avaliação preguiçosa: cálculos e comparações são feitas apenas quando seus resultados serão de fatos utilizados, assim se criarmos uma variável x por exemplo, onde x = 2 * 2, a conta 2 * 2 será feita somente se o valor de x for utilizado, caso contrário isto nunca chegará a ser calculado de fato.
|
| 71 |
Lucas Zocchio |
Um paradigma de programação é uma maneira como se descreve a solução computacional de um problema. Alguns paradigmas mais populares são: imperativo, onde o programa consiste numa sequência de comandos; o estruturado, onde há estruturas de fluxo de controle e uso de procedimentos e funções; orientado a objeto, onde há o uso de objetos e métodos para cirar o fluxo do programa; o declarativo, onde se coloca o que deseja receber sem detalhar os passos; o lógico, onde, a partir de regras, o programa avalia o resultado; e o funcional, onde não há alteração de estado e o programa consiste na avaliação de uma série de funções.
O paradigma funcional possui como principais características o uso de funções puras, recursão e avaliação preguiçosa. Funções puras são aquelas que não alteram o estado global sistema, como uma variável global ou pela entrada e saída de dados. Essas funções sempre entregam um mesmo resultado para um mesmo valor de entrada. Uma função "pura" que utilize funções impuras é considerada impura. De modo geral, a impureza de uma função é viral, portanto uma função não pode ser pura fazendo uso de funções impuras.
A recursividade é usada no lugar de loops while e for. Isso pode permitir uma melhor compreensão do propósito que tem a função. Já a avaliação preguiçosa consiste em avaliar uma função somente quando necessário. Esse tipo de avaliação melhora a performance do programa, pois valores que não forem requisitados também não serão avaliados, e não altera estado de variáveis, pois cada chamada de função entrega uma promessa, ou thunk, e não a execução em si até que o retorno de um valor seja exigido.
O Haskell se diferencia por ser uma linguagem puramente funcional, declarativa, e possuir tipagem estática e forte. |
| 72 |
Larissa Copel Rothman |
Paradigmas de Programação
É um estilo de programação, ou seja, como descrever a forma computacional de resolver o problema.
Principais paradigmas da programação:
- Imperativo: sequência de comandos;
- Estruturado: procedimentos e funções;
- Orientado a objetos: objetos;
- Declarativo: determinação do que quer (e não como);
- Funcional: avaliações de funções matemáticas;
- Lógico: fatos e regras
Imperativo
Vantagens: fluxo de controle explícito e completo e liguagem mais alto nível que de máquina.
Desvantagens: possível dificuldade de racionalizar o resultado e vulnerabilidade das variáveis globais e funções.
Estruturado
Vantagens: organização em blocos lógicos e estimulação do uso de variáveis locais.
Desvantagens: possível uso de informações fora do contexto e uso de mudança de estados (possíveis bugs).
Orientado a objetos
Vantangens: encapsulamento de códigos (segurança e reuso) e pouco uso de variáveis globais.
Desvantagens: limitação na resolução de problemas por orientação a objetos, o fluxo lógico do código pode ser afetado pelo uso de heranças, uso pesado de estado mutáveis e dificuldade de paralização.
Declarativo
Vantanges: alto nível da linguagem e pouco uso de estados.
Desvantagens: escalabilidade da complexidade de acordo com a limitação da linguagem e custo de desempenho.
Lógico
Vantagens: construção do programa pelo compilador e facilidade na comprovação da corretude do programa.
Desvantagens: dificuldade de programar algoritmo complexos e lentidão para operações matemáticas.
Funcional
Vantagens: expressividade próxima de linguagens declarativas e inexistência de estado e mutabilidade.
Desvantages: dificuldade do gerenciamente da memória.
As função puras não alteram nada do ambiente e possuem transpaência referencial, ao contrário das funções impuras, que podem alterar por exemplo uma variável global ou depender de estado que não está em seu escopo.
strlen -> função pura
printf -> função impura
memcpy -> função pura
getc -> função impura
A lazy evalution funciona de forma que a expressão escrita gera um "thunk".
|
| 73 |
Leandro Ribeiro de Almeida |
|
| 74 |
Leandro Victor Ferreira |
Nesse primeiro momento temos uma visão geral de que um paradigma se resume em uma metodologia de estrutura de programação.Sendo os mais populares imperativo, estruturado, objeto orientado, declarativo, lógico e funcional, o qual será o foco dos estudos nesta disciplina. A importância de conhecer os paradigmas mais populares e a possibilidade de compreender mais a fundo a estrutura de algumas linguagens, por serem multi-paradigmas como caso do Java, cujo paradigma que mais se destaca é o orientado a objeto.
Como dito anteriormente, a linguagem é classificada pelo paradigma que mais sobressai, para o funcional, utilizares o Haskell.
As características do programacao funcional são:
-Funções populares
-Recursão
-Avaliação preguiçosa
Função Pura: Funções sem efeitos colaterais, tendo para um determinada entrada uma mesma saída, implicando a vantagem de que se não tem efeito colateral ela não precisa ser calculada, dando mais abrangência para otimização, tendo redução de bugs, pois para rodar, primeiro precisa compilar. Quando compilado a chance de erro são menores.
Recursão: Usa-se da Recursão para realizar as interações, deixando os códigos mais enxutos e mais declarativos.
Avaliação preguiçosa: Há o cálculo de uma promessa de um valor, se o valor for utilizado dai ele será executado, se houver substituições seguidas não será calculado o valor step a step, mas sim só no fim, isso economiza no cálculo computacional e processamento.
|
| 75 |
Leonardo Santiago Hampshire |
Paradigmas:
-> Formas de descrever a solução computacional de um problema
-> Mais populares:
-> Imperativo
-> Estruturado
-> Orientado a Objetos
-> Declarativo
-> ***Funcional*** (Utilizado com Haskell)
-> Avaliação de FUNÇÕES MATEMÁTICAS sem a alternancia de estados
-> Baseado no cálculo Lambida
-> Os dados são IMUTÁVEIS!!
-> Declarativo
-> Lógico
Paradigma Funcional:
-> Funções PURAS
-> Não apresentam "Efeitos Colaterais"
-> Uma mesma função com uma mesma entrada terá sempre o mesmo valor de retorno
-> As iterações são implementadas via RECURSÃO!
-> Código enxuto e declarativo
-> Avaliação preguiçosa
-> PROMESSA DE EXECUÇÃO
-> a expressão é avaliada apenas quando for requisitada, necessária a operação da mesma.
|
| 76 |
Renan Ferreira Lima |
De forma suscinta, um paradigma de programação é a uma forma de modelar uma solução computacional. Há alguns paradigmas como: imperativo, estruturado, orientado a objeto, declarativo, funcional e lógico. No âmbito das linguagens de programação, grande parte preza pelo conceito de multi-paradigmas tendendo a favorecer algum dos paradigmas citados anteriormente, como consequência temos a divisão entre linguagens imperativas,funcionais, entre outras.
Enfatizando o paradigma Funcional, podemos destacar o uso de Funções puras, Recursão e Avaliação preguiçosa por parte das linguagens que seguem essa modelagem. Analisando as funções puras, diferencia-se das funções impuras por não alterarem o estado geral do sistema, um exemplo de função pura é a strlen, enquanto que como função impura, podemos citar a printf. A printf, no caso, altera o estado da tela e isso implica no estado geral do sistema, via de regra, temos que toda função que chama alguma função impura é impura.
Uma característica das linguagens funcionais é que os laços interativos são implementados via recursão, isso acarreta um código mais enxuto e declarativo. Outro ponto importante é o fato de utilizarem o conceito de avaliação preguiçosa, logo se o valor de uma expressão não é utilizado, então ela não é executada. Um bom exemplo de linguagem funcional é o Haskell, uma vez que não é uma linguagem multi-paradigma, razão pela qual será a base do curso. |
| 77 |
FELIPE MOREIRA TEMOTEO DA SILVA |
Paradigma de programação de forma geral é o estilo de programar.
-Alguns paradigmas:
Imperativo;Estruturado;Orientado objeto;Declarativo;Funcional;Lógico
-Muitas linguagens de programação são multi-paradigmas:
-Contém características de diversos paradigmas
-Na verdade, favorecem um paradigma especifico
Algumas características de cada paradigma:
Paradigma Imperativo -> Descreve passo a passo do que tem que ser feito.
Paradigma Estruturado -> Estrutura o código imperativo em blocos lógicos.
Paradigma Declarativo -> O fluxo lógico é implícito.
Paradigma Lógico -> Especifica-se apenas fatos e regras de inferência.
Paradigma Funcional -> Baseado no cálculo lambda.
Algumas características do paradigma funcional são as funções puras, recursão e avaliação preguiçosa.
A função pura são funções que não apresentam efeito colateral (quando uma função altera o estado global do sistema).
Laços iterativos são implementados através de recursão.
E algumas linguagens funcionais implementam o código através de avaliação preguiçosa (que quando uma expressão é gerada, ela gera uma promessa de execução ou thunk).
|
| 78 |
Lucas Silva Amorim |
Configuração do ambiente
* Haskell Stack: Gerenciamento de dependências e bibliotecas (link para doc e download: https://docs.haskellstack.org/en/stable/README/)
* Para criar um novo projeto com o stack: stack new <nome> <template>
* stackage server: servidor de versões estáveis de pacotes haskell.
* ghc: compilador haskell
* Projeto com múltiplos código fonte: Nome do módulo igual ao caminho do arquivo (incluindo o próprio nome do arquivo) + adicionar seção other-modules no arquivo .cabal
* Bibliotecas externas: Incluir seção build-depends no arquivo .cabal
* Haskell Language Server: mecanismo live-server para verificação de sintaxe, indentação e etc...
Paradigmas da Programação
* Paradigma Imperativo: Descreve passo-a-passo o que deve ser feito.
* Paradigma Estruturado: “Evolução” do paradigma imperativo, permitindo estruturar o código em blocos lógicos.
* Orientação a Objetos: Encapsula os dados em classes, aumentando o poder de abstração do código, e permitindo maior controle sobre os estados compartilhados.
* Paradigma Declarativo: Paradigma de alto nível, que permite que o programador escreva somente o que ele deseja fazer. (VHDL, SQL). Geralmente se usa DSL (Domain specific language)
* Paradigma Lógico: Específica apenas fatos e regras de inferência.
* Paradigma Funcional: Baseado em cálculo Lambda, onde os programas são composições de funções.
* Estados imutáveis.
* Mais delcarativo comparado aos paradigmas "tradicionais".
Paradigma funcional
* Funções puras: Funções que não possuem efeitos colaterais (não afetam o estado global da aplicação).
* A saída da função depende apenas das suas entradas (f(x)=y).
* Funções impuras são virais (isto é, chamar uma função impura dentro da sua função, a torna impura).
* Recursão: Os laços são recursivos, tornando os códigos mais enxutos e declarativos.
* Avaliação preguiçosa: Na criação das expressões é gerada uma promessa de execução, essa promessa só é avaliada quando/se necessário.
* Permite a criação de listas infinitas. |
| 79 |
Lucas Brandao Pereira |
Lucas Brandão Pereira - 11201720262
RESUMO
Paradigmas de programação - A forma como você descreve a solução computacional de um problema
As linguagens de programação no geral são multi-paradigmas, ou seja, contém características de diversos paradigmas embutidas em si.
Sendo assim, não é tão fácil distinguir o uso delas, porém na prática cada linguagem favorece o uso de um paradigma
Ex. Python = Orientado a objetos + Funcional
Exemplos:
Imperativo - Comum de se aprender no começo de cursos por ser mais intuitivo,
onde uma sequência de comandos que alteram o estado atual do sistema até atingir um estado final
famoso "go to"
Estruturado - Considerado uma evolução do Imperativo e também comum de ser usado no início dos estudos, pois é estrutura de fluxo de controle e uso de procedimento e funções
Orientado objeto - Organização através de objetos que contém dados, estados próprios e métodos que alteram ou recuperam os dados/estados.
Os objetos comunicam entre si para compor a lógica do programa
Declarativo - Especifica o que você quer, mas sem detalhar como fazer
Lógico - Especifica-se um conjunto de fatos e regras, o interpretador infere respostas para perguntas sobre o programa
Funcional - Programas são avaliações de funções matemáticas sem alterar estados e com dados imutáveis
---//---
Paradigma Funcional
Funções Puras
São funções que não apresentam efeito colateral. Ao executar a mesma função com a mesma entrada sempre se obtém a mesma resposta
Se uma função A chama uma função B que é impura então A também é impura
Programação em Haskell procura deixar o programa o mais puro possível, deixando as impurezas apenas para entrada e saída de dados
Recursão
Em linguagens funcionais os laços iterativos são implementados via recursão
Avaliação Preguiçosa
Em linguagens funcionais, dado um programa, só se computa os valores e operações necessários para retornar o resultado esperado, os demais são "ignorados"
---//---
Haskell
Linguagem puramente funcional (não é multi-paradigma)
Somente aceita funções puras
Declarativa
Avaliação Preguiçosa
Dados imutáveis
Tipagem estática e forte
|
| 80 |
Lucas Akira Hasegava |
Aula 1
Preparando o ambiente ->
primeira aula se resume ao setup inicial para Programação Funcional em Haskell
seus topicos são: instalação inical do stack, utilização do Linux no windows e
utilização de editores de codigos (Emacs e Vim) para o decorrer do curso
Paradigmas de programação ->
primeira introdução de como que será a programação funcional em Haskell
apresentação das diferenças em relação a outros tipos de programação
introdução dos conceitos basicos utilizados em Haskell e suas diferenças para outras linguagens |
| 81 |
Sergio Maracaja Junior |
-- Nome: Lucas Serna Quinto Pardo
-- R.A: 112017490
link para png do resumo e acesso ao draw io do resumo:
https://drive.google.com/file/d/1FuNWhvvwShGeU5UGQpMBpJDfgdjI9Lfn/view?usp=sharing
|
| 82 |
Lucas David Vadilho |
# Resumo
## 1.1 Paradigmas de Programação
Paradigmas de programação são maneiras de organizar as ideias para resolver o problema.
Computadores funcionam de maneira imperativa, logo linguagens de programação mais próximas do hardware seguem essa organização.
- Imperativo: goto
- Estruturado: evolução do imperativo, com condicionais e laços
- Orientado a objeto: dados são modelados em classes, cada uma com seus métodos e propriedades
Todos eles tem em comum a estrutura sequencial.
- Declarativo: especifica objetivo, sem detalhes de como fazer (ex.: SQL)
- Funcional: funções matemáticas, que não alteram estado e com dados imutáveis (ex.: haskell)
- Lógico: conjunto de fatos e regras, interpretador infere respostas (ex.: prolog)
Muitas linguagens são multi-paradigmas.
## 1.2 Paradigma de Programaçao Funcional
- Efeito colateral: altera estado global do sistema. Estado é um conceito bem geral, `printf`, por exemplo, altera o estado ao imprimir algo na tela.
### Características
- Funções puras: não possuem efeito colateral
- O resultado só precisa ser computado se for utilizado
- Facilita paralelização
- Recursão: ver recursão. Laços são implementados via recursão.
- Avaliação preguiçosa: _se_ e _quando_ necessário a promessa (ou _thunk_) é avaliado
- Ausência de estados: evita bugs
### Haskell
- Puramente funcional
- Só funções puras
- Avaliação preguiçosa
- Dados imutáveis
- Tipagem estática e forte |
| 83 |
LUCAS YUDI FUKAZAWA CASSIN |
- Preparativos:
* Preparação do ambiente
* Instalação do Haskell
* Instalação do melhor editor de todos (?)
- Paradigmas:
* Tipos de paradigmas mais populares:
* Imperativo:
* Passo a passo
* Evoluiu para procedural e estruturado
* Possuí um fluxo explicito e completo, porém pode ser difícil enxergar o resultado apenas pelo código
* Estruturado:
* Blocos lógicos com instruções imperativas
* Blocos com funções únicas e explicitas
* Usa mudança de estados que pode levar a bugs
* Orientado a objeto
* Utilizada classes, que cada uma contém seus dados, métodos
* Evita o uso de variáveis e métodos fora do contexto
* Utiliza de instâncias e métodos estáticos, para falar de um objeto em específico ou não, respectivamente
* Traz mais reuso para os códigos e segurança
* Difícil de paralelizar
* Declarativo
* Fluxo lógico implícito
* Linguagem de alto nível que permite dizer o que quer, e não dizer como fazer
* Minimiza o uso de estados
* Pode levar a códigos complexos
* Pode ter custo extra no desempenho
* Funcional
* Lógico
* Especifica-se apenas fatos e regras de inferência
* O retorno esperado é escrito em forma de pergunta
* Compilador escreve o código baseado em fatos lógicos
* Provar corretude é mais fácil
* Mais lento para operações matemáticas
- Paradigma funcional:
* Funções puras:
* Não apresentam efeito colateral
* Efeito colateral:
* Altera algum estado global do sistema
* Se não usa, não calcula.
* Pode ser executado em qualquer ordem
* Funções impuras são virais
* Recursão:
* Laços são feitos com recursão
* Avaliação preguiçosa:
* Só é avaliado quando for necessário
- Haskell:
* Puramente funcional
* Somente funções puras
* Declarativa
* Avaliação preguiçosa
* Dados imutáveis
* Tipagem estática e forte
|
| 84 |
LUCCA IANAGUIVARA KISANUCKI |
Foi feita a instalação do ambiente Linux usando o Windows Subsystem For Linux, e a instalação do vim no mesmo.
Depois disso feito a instalação do Haskell Stack e do git para clonar o repositório disponibilizado pelos professores.
Executando o comando "stack test" deu erro nos 5 testes, porém após preencher os arquivos com as informações corretas todos os erros sumiram. |
| 85 |
Luiz Felipe Leal Gomes Azzolini |
# Aula 1
Para dar os primeiros passos com programação em haskell, foi feito primeiro a instalação do haskell stack, uma ferramenta para criar projetos e gerenciar dependências do mesmo.
O stack também tem algumas opções ao criar o projeto, sendo a mais simples sendo executada pelo comando “stack new nome-projeto simple”, em que “simple” seria o template do mesmo, que vem com o modelo mais simples de projeto compilável e executável.
Além disso também é possível mudar a versão do compilador alterando o campo “resolver” no arquivo stack.yaml. Diferentemente, no arquivo nome-projeto.cabal podemos adicionar as flags de compilação do GHC, permitindo assim ligar a otimização ou habilitar multithreading por exemplo.
É possível utilizar diversos editores de texto para programar em haskell, entre eles o Vim e o emacs, ambos com muitas funcionalidades que ajudam na programação com a linguagem.
# Aula 2
Existem vários tipos de paradigmas de programação, imperativo, em que o programa é uma sequência de comandos que alteram estado do sistema até chegar ao seu fim, estruturado, programas com fluxo de controle, uso de procedures e funções, orientação a objetos, organizada em objetos que se comunicam entre si, cada um com seu próprios dados, estados e métodos, e entre outros paradigmas existentes.
O paradigma em foco será o funcional e a linguagem será haskell devido, entre outros fatores, pela sua característica de ser puramente funcional.
Esse paradigma é baseado no cálculo lambda, não possui estados e seu programa são composições de funções (daí o nome). Suas funções são sempre puras (no caso do haskell), ou seja, não causam nenhum efeito colateral, como alterar uma variável global. Além disso implementa a avaliação preguiçosa, em que as expressões quando compiladas viram promises e só são avaliadas quando e se necessário, e seus laços iterativos são feitos via recursão.
|
| 86 |
Gabriel Silvestre Mancini |
|
| 87 |
Marcelo Cecilio Fagundes da Silva Filho |
Durante primeira semana foi discutido os paradigmas de programação com foco no paradigma funcional.
Paradigmas de Programação de programação são formas de descrever a solução de um problema computacional. Os mais conhecidos são:
Imperativo: Sequência de passos que alteram o estado do sistema até a solução
Estruturado: Parecido com o imperativo porém com estruturas de fluxo (por exemplo for, while) e uso de funções
Orientado a objeto: Organizado através de objetos, com estados e métodos próprios, que se comunicam entre si.
Declarativo: Especificação do objetivo, sem declarar os passos para alcança-lo
Logico: Através de regras e fatos preestabelecidos é capaz de solucionar perguntas feitas ao sistema
Funcional: Conjunto de funções matemáticas e dados imutáveis
O Paradigma Funcional é formado por:
Funções Puras: funções que não alteram o estado global do sistema e que ao passar a mesma entrada o resultado é o mesmo. Um exemplo é a função strlen em c, ao passar a mesma string sua saída será a mesma. Já a função printf é uma função impura, pois altera o estado da tela.
Recursão: A linguagem funcional não possui laços iterativos, portanto, as repetições são implementadas através de recursão, ou seja, chamadas da mesma função.
Avaliação Preguiçosa: em algumas linguagens funcionais quando uma função é gerada, há uma promessa de execução ou thunks. Ou seja, elas só são executadas quando necessárias. Por exemplo, se uma função tem como entrada x*x e 2x + 4, porém só o valor x*x é usado, então só ele é calculado. Com isso é possível gerar coisas como laços infinitos, uma vez que, só os valores usados serão computados.
Muitas linguagens, porém são multi-paradigma, ou seja, dão suporte a mais de um paradigma, porém normalmente há um que se destaca.
|
| 88 |
Marcelo Martins Oliveira |
|
| 89 |
Matheus da Costa Baio |
Paradigma de programação é o estilo de programar, a maneira de organizar as ideias
Imperativo: Sequência de comandos que altera um estado
Estruturado: Estrutura de fluxo e uso de procedimento e funções
Orientado a objetos: Organizado em objetos
Todas essas são elaboradas em sequência de operações
Declarativo: Especifica o que quer sem detalhar (Ex.: SQL)
Funcional: Programas são avaliações de funções matemáticas sem alterar estados
Lógico: As respostas são inferidas
Características do paradigma de programação funcional:
Utiliza funções puras
Função pura: Função que não têm efeito colateral (ou seja, não altera o estado do sistema). Existe transparência referencial.
Laços iterativos geralmente são implementados com recursão
Avaliação preguiçosa
Quando uma expressão é criada ela gera uma promessa de execução. Só será avaliada quando realmente for necessária. Isso permite, por exemplo, a criação de listas infinitas.
Haskell é puramente funcional, todas as funções são puras, é declarativa, tem avaliação preguiçosa, os dados são imutáveis e tem tipagem estática e forte.
|
| 90 |
Matheus de Albuquerque Accioly Rodrigues |
|
| 92 |
Matheus Alexandre de Sena |
Nessa primeira semana aprendemos a como configurar o nosso ambiente para programar em Haskell, instalamos o Haskell Stack que é uma ferramenta utilizada para criar projetos e gerenciar dependências. Para iniciar um projeto com o Stack usamos o seguinte comando:
"stack new nome-projeto simple", sendo nome-projeto qualquer nome que se deseja dar ao projeto e "simple" o template requerido, nesse caso o simples. Para fazer o build, na raiz do projeto executamos "stack build" e para executar o build utiliza-se o comando "stack exec nome-projeto". Também é possível utilizar o comando "stack run" para fazer o build e executar o projeto.
Além disso aprendemos sobre as principais características e diferenças entre os paradigmas de programação.
O paradigma imperativo e estruturado é como se fosse uma receita de bolo, descrevemos passo a passo o que deve ser executado, o computador é de imperativo, o que permite uma tradução mais direta para o Hardware, a POO é uma evolução do paradigma estruturado.
O paradigma declarativo específica o que desejamos executar, mas sem detalhar como fazer, um exemplo é o SQL.
O paradigma lógico especifica um conjunto de fatos e regras, o interpretador infere respostas para as perguntas sobre o programa.
No paradigma funcional os programas são avaliações de funções matemáticas, sem alterar estados e com dados imutáveis, sua base é o cálculo lambda. Algumas características marcantes expostas na aula são:
- Funções puras, que são funções sem efeito colateral, uma entrada sempre retornará o mesmo valor;
- Recursão, usamos recursão ao invés dos laços loop-for, por consequência isso deixa o código mais enxuto;
- Avaliação preguiçosa, um certo código só será executado quando de fato for requerido, isso permite que possamos criar listas infinitas.
|
| 93 |
Mayza Cristina da Silva |
1.1 Paradigmas de Programação
Estilo de programação, estrutura de ideias e como transferi-las do pensado para o código: solução computacional de um problema.
Paradigmas mais comuns:
Imperativo, Estruturado, Orientado a objetos
O que nós queremos e não tanto o como queremos:
Declarativo: o que queremos, mas sem detalhes de como fazer
Funcional: declaração através de funções matemáticas
Lógico: regras que definem o comportamento do interpretador, porém o como será executado fica a critério dele próprio
Muitas linguagens são multi-paradigmas, porém algum paradigma acaba sendo favorecido.
Paradigma Imperativo
Passo a passo o que deve ser feito
Vantagens: O fluxo é visível. Linguagem de mais alto nível que linguagem de máquina.
Desvantagens: é preciso analisar incremento a incremento para entender um resultado.
Paradigma Estruturado
Mesma estrutura dos imperativos, porém organizados em blocos lógicos, que costumam ter um objetivo específico.
Vantagens: blocos lógicos com função explícita e uso de variáveis locais
Desvantagens: Não evita uso de informações fora de contexto. Usa mudança de estados que podem gerar bugs.
Paradigma Orientação a Objetos
Dados encapsulados em classes
Vantagens: Códigos encapsulados para maior segurança e reuso. Evita variáveis globais e uso de trechos de código indevidos.
Desvantagens: Composição de funções é feita através de herança. Uso pesado de estados mutáveis. Difícil de paralelizar.
Paradigma Declarativo
Apenas dizer o que queremos
Vantagens: nível mais alto que outros paradigmas. Minimiza uso de estados (menos bugs).
Desvantagens: uso de outros paradigmas em casos de códigos mais complexos.
Paradigma Lógico
Fatos e regras
Vantagens: O Compilador constrói, baseado em fatos lógicos. Maior corretude.
Desvantagens: Difícil de expressar algoritmos mais complexos. Mais lento para operações matemáticas.
Paradigma Funcional
Baseado no cálculo λ.
Vantagens: expressividade próxima das linguagens declarativas. Não existe estado e mutabilidades (menos bugs)
Desvantagens: Difícil ser útil sem ter estados. Gerenciamento de memória dificultado.
|
| 94 |
Diogo Akio Balboni Miyake |
Foi apresentado sobre as diferenças de paradigmas de programação e explicado que será utilizado o haskell
como linguagem de programação da disciplina por ser uma linguagem criada sobre o paradigma de programação funcional.
|
| 95 |
Yuri Guerrero Moreno |
|
| 97 |
Murilo Guimarães Balle |
A aula da semana 01 compreendeu breves explicações de cinco paradigmas de programação, com seus lados positivos e negativos: imperativo, estruturado, orientado a objetos, declarativo e lógico. Também foi citada o paradigma Funcional, a esse dado maior ênfase.
O paradigma Funcional tem como característica o uso de funções puras, recursão e avaliação preguiçosa.
Funções puras são aquelas funções que não apresentam efeitos colaterais, ou seja, quando executadas com a mesma entrada, sempre retornaram o mesmo resultado.
Recursão se refere a fazer diversas chamadas da mesma função, ao invés de escrever uma função que realiza diversas iterações.
A avaliação preguiçosa significa que, ao executar um código, não será realizada uma avaliação estrita das expressões contidas nele, apenas será gerada uma promessa de execução ela só será avaliada se esse valor for necessário em algum momento da execução.
|
| 98 |
Nathalia Correa dos Santos |
Existem diversos paradigmas de programação, entre eles temos:
1. Imperativo
2. Estruturado
3. Orientado a objetos
4. Funcional
1. O paradigma imperativo descreve passo a passo o que deve ser feito pelo programa, e foi evoluido depois para
o paradigma estruturado. Como vantagem desse paradigma temos que ele é bastante explicito nos comandos passados para
a máquina, mas como desvantagens temos a dificuldade de se pensar passo a passo para chegarmos no resultado esperado.
2. O paradigma estruturado mantém os códigos estruturados em blocos lógicos. Uma desvantagem desse paradigma é que
ele utiliza mudança de estados, o que pode levar a bugs no sistema.
3. Orientado a objetos encapsula os dados em classes, protegendo assim suas váriaveis e métodos, além de permitir o reuso.
Como ponto negativo temos a dificuldade em paralelizar códigos orientados a objetos.
4. O paradigma funcional é baseado em cálculo lambda, não utiliza estados e seus programas são montados a partir de
composição de funções. Sendo esse o paradigma encontrado na linguagem Haskell que usaremos na disciplina.
Por ser um paradigma que não utiliza estados, ao utilizamos apenas funções puras evitamos o que chamamos de efeito colateral.
Um efeito colateral ocorre quando uma função altera algum estado global do sistema, afetando o funcionamento ideal do código. |
| 100 |
Natalia Regina Costanzi |
Um paradigma de programação é basicamente a forma como é descrita a solução computacional para um dado problema.
Dentre os paradigmas mais populares estão:
-Imperativo: Descreve o passo a passo do processo. Seu fluxo de controle explícito e completo e o nível da linguagem um pouco mais alto que a linguagem de máquina. Utiliza variáveis globais.
-Estruturado: Estrutura o código imperativo em blocos lógicos onde cada instrução imperativa é feita para um objetivo específico. Estimula uso de variáveis locais. Por utilizar mudança de estados, pode ocasionar bugs.
-Orientado a objetos: Encapsula dados em classes proporcionando segurança e reúso. Objetos podem se comunicar entre si e variáveis globais são evitadas. Métodos são divididos em métodos de instância e de classe. Entretanto, nem todos os problemas podem ser modelados como objetos.
-Declarativo: Fluxo lógico implícito. Utiliza Domain Specific Language (DSL), atingindo um nível mais alto que outros paradigmas. Possui menos bugs devido à minimização de uso deestados. Entretanto, é mais complexo fazer algo não suportado nativamente.
-Lógico: Especifica-se apenas fatos e regras de inferência. O retorno é escrito em forma de pergunta. O compilador constrói o programa, sendo simples de provar sua corretude. Neste paradigma é difícil de expressar algoritmos mais complexos e pode ser mais lento para operações matemáticas.
-Funcional: Baseado no cálculo lambda. Os programas são composições de funções. É declarativo e não utiliza estados, isso dificulta a criação de algo útil. É semelhante as linguagens declarativas, mas sem limitações. Não há estado de mutabilidade, reduzindo a quantidade de bugs.
Algumas de suas características são:
>Funções Puras, ou seja, que não apresentam efeito colateral (ao executar função com mesma entrada, a saída é sempre a mesma);
>Recursão;
>Avaliação preguiçosa (quando a função é gerada, não executa, mas gera uma promessa de execução, permitindo criação de listas infinitas).
'
|
| 101 |
Natalia Leite Vares de Souza |
Paradigma de programação pode ser definido como a forma que a solução de um problema computacional é descrita. É possível listar pelo menos 6 tipos de paradigmas, sendo eles:
- Imperativo: apresenta descrição, passo-a-passo, do que deve ser feito. Uma desvantagem é que mesmo chegando no resultado, pode ser difícil entender qual será esse resultado;
- Estruturado: semelhante à estrutura do paradigma imperativo, porém com implementação de blocos, permitindo utilização de procedimentos e funções.
- Orientado à objetos: aloca os dados em classes, que apresentam estados e métodos não compartilhados. Os objetos podem se comunicar com outros, evitando que seja necessário a utilização de variáveis globais. Uma desvantagem é que nem sempre é fácil ou possível modelar os problemas como objetos.
- Declarativo: o fluxo lógico para execução dos comandos desejados está implícito. Declara o que é desejado, mas sem detalhar como será possível chegar ao resultado. Uma desvantagem é que, para problemas mais complexos em que os comandos desejados não são suportados nativamente pela linguagem, pode haver um custo extra de desempenho.
- Lógico: necessário especificar apenas fatos e regras de inferência. O compilador constrói o programa baseado nos fatos lógicos. As desvantagens são que para algoritmos mais complexos, pode ser difícil expressar na forma lógica, além disso é mais lento para processar operações matemáticas.
- Funcional: é semelhante ao paradigma declarativo, porém não utiliza estados, que podem ser limitadores. Uma das dificuldades está em como fazer algo útil sem utilizar os estados.
O paradigma funcional tem como características:
- Funções puras, onde não são apresentados efeitos colaterais, assim a mesma entrada sempre resulta na mesma saída
- Recursões, resultando em um código enxuto e declarativo
- Avaliação preguiçosa, quando uma expressão é gerada temos uma promessa de execução, que será executada apenas se for necessário.
|
| 102 |
Natalia Arruda Wazny |
|
| 103 |
Ivo Vecelic Neto |
Paradigmas de programação
São a forma logica que o seu código é montado, elas são imperativo, uma sequência de comandos que se alteram até chegar no estado final.
Estruturado, onde a lógica segue uma estrutura de controle.
Orientado objeto, onde as estruturas logicas do programa são objetos e chamam seus métodos.
Declarativo, se declara o que deve ser feito, mesmo sem explicar como.
Funcional, utiliza de funções matemáticas para obter resultados
Lógico, através de regras logicas responde a perguntas declaradas no programa
Cada uma desses paradigmas tem suas vantagens e desvantagens para o desenvolvimento de programas. Além disso dentro desses paradigmas temos as funções que são a força motriz de qualquer lógica, e elas podem ser classificadas como puras quando todas variáveis, que são trabalhadas na função ou são recebidas por esta ou declaradas na mesma, e impuras quando existe ao menos uma variável que é declarada fora da função mas é utilizada dentro de uma função, Outro ponto a ser avaliada nas funções interações e recursividade que é como a função interage em ser chamada por ela mesma.
Outro ponto de paradigmas de programação é a avaliação do uso de funções quando as variáveis são funções , temos a avaliação estrita, que segue uma linha sequencial de avalia”cõ de funções e avaliação preguiçosa que espera os resultados das funções internas .
|
| 104 |
Giovanna Nogueira |
Um paradigma é um estilo de programação, a forma como as ideias são transmitidas no código. Entre eles temos:
• Imperativo: consiste em uma sequência de comandos até atingir um estado final (go to). São linguagens de pouco mais alto nível que a linguagem de máquina;
• Estruturado: Utilizando fluxos de controle e o uso de procedimentos e funções, o código imperativo fica em blocos lógicos, com um único objetivo explícito; promove o uso de variáveis locais;
• Orientado Objeto: utiliza objetos (com estados e métodos próprios) que se comunicam entre si para organizar o programa e compor a lógica necessária. Evita o uso de variáveis globais pela comunicação entre objetos, e seus métodos manipulam objetos específicos;
• Declarativo: especificamos o que queremos, sem dizer como; são linguagens de alto nível, específicas para o ambiente de aplicação;
• Funcional: utiliza-se de funções matemáticas para essas descrições, sem utilizar estados, e declarativo;
• Lógico: descreve uma série de regras, tendo o objetivo é declarado em forma de pergunta.
As linguagens atuais tendem a ser multi-paradigmas.
Focando mais no paradigma funcional: uso de funções puras, uso de recursão e avaliação preguiçosa (nem todas as linguagens têm todas as características).
Funções puras são aquelas que não apresentam efeito colateral; a mesma entrada devolve a mesma resposta; marcada pela transparência referencial;
Uso de recursões também para criar laços iterativos, criando um código mais enxuto.
Avaliação preguiçosa consiste em cada expressão gerar uma promessa de execução, que só é avaliado caso seja necessário. |
| 105 |
MARIANA MIWA OKUMA MIYASHIRO |
Na primeira aula da semana, Preparando o Ambiente, demos os primeiros passos com o Haskell Stack, criando o primeiro projeto simple,
compilando e executando-o em seguida. Com isso, pudemos verificar a estrutura do diretório que é criada com o projeto e os conteúdos
de cada um dos arquivos. Dentro do diretório src, é criado o arquivo Main.hs que é o módulo principal e que no projeto que criamos
vem com uma instrução que imprime ‘hello world’.
Na segunda aula, sobre Paradigmas de Programação, tivemos um conteúdo mais teórico, passando por diversos paradigmas de programação,
ou seja, formas diferentes de escrever soluções computacionais. Vimos sobre o paradigma imperativo, que altera o estado atual do
sistema até atingir um estado considerado como final; o estruturado, que possui fluxo de controle, uso de procedimentos e funções;
o orientado a objeto, que é organizado através de objetos que se comunicam entre si e possuem estados, métodos que os alteram;
declarativo, que apenas especifica o que se quer; funcional, que avalia funções matemáticas sem alterar estados, e lógico,
que especifica fatos e regras a serem interpretadas. Muitas linguagens são multi-paradigmas como python, por exemplo, mas no geral
favorecem algum paradigma específico como Java que é uma linguagem orientada a objeto na sua concepção.
Na aula, também pudemos ver vantagens e desvantagens de cada paradigma, bem como exemplos de utilização. No curso em si, haverá foco
no paradigma funcional, que é baseado no cálculo λ, composto de funções, declarativo e não usa estados. Tem bastante expressividade,
poucas limitações e bugs reduzidos. Ele possui apenas funções puras que são aquelas sem efeito colateral, os laços iterativos devem
ser implementados via recursão e também possui avaliação preguiçosa, que só avalia um trecho de código quando necessário.
|
| 106 |
Paulo Henrique Eiji Hayashida |
Paradigmas de Programação são modelos que descrevem como os programas são implementados, ou seja, através de quais estruturas são escritos os programas.
Alguns exemplos de paradigmas de programação são imperativo, estruturado, orientado a objetos, declarativo, lógico e funcional.
No paradigma imperativo o programa é composto por comandos sequenciais que alteram diretamente o estado atual do sistema até que um estado final seja atingido.
No estruturado, temos ainda o sequenciamento de comando com a adição de laços iterativos, que dados algumas condições repetem trechos de código em quantidades finitas.
Orientado a objetos, onde há a noção de classes encapsuladas com caracteristicas e métodos respectivos de cada classe, a partir desses são criados objetos que herdam as caracteristicas das classes e podem possuir caracteristicas e métodos proprios.
Declativo, especifica-se as operações a serem realizadas, sem colocar como será executado, como por exemplo a linguagem VHDL que dados as funções do programa ,monta o esquema elétrico dos componentes.
Lógico, através de proposições e regras, realiza inferencias da resposta, dada uma pergunta a ser solucionada.
Por fim, o paradigma funcional, baseia-se no calculo lambda, assim os programas são composições de funções, não realizando alterações de estados. Para uma linguagem utilizar o paradigma funcional algumas caracteristicas como o uso de funções puras, recursão e avaliação preguiçosa.
Uma função é chamada de pura quando não alteram variáveis globais e não fazem leitura de entradas de dados nem impressão de saídas na tela. Implicando em funções que sempre retornam o mesmo resultado dadas as mesmas entradas.
Avaliação preguiçosa é um conceito que cria uma promessa de execução de uma expressão, ou seja, apenas quando o valor da expressão seja requisitado durante a execução do programa, então sera calculo, caso contrário o valor a expressão não será avaliada
|
| 107 |
Pedro Braga dos Santos Bacellar |
############################################################################################################################
Stack
Compilador: ghc
Cabal eh um systema gerenciador de pacotes que usa o ghc
Stack eh uma utilidade gerenciadora de projetos que utiliza o cabal
O projeto minimo do stack contem stak.yaml, projeto.cabal e main.hs
############################################################################################################################
Paradigmas
Imperativo:
Manipulacao de variaveis e seus valores para processamento (mudanca de estados)
Assembly de antigamente, gotos, tudo global
Melhorias:
Estruturado (C):
blocos logicos (for, case, if else)
permite variaveis locais
Procedural (C):
procedures, funcoes
Orientado a objeto (java):
encapsulamento dados + comportamento
+ isolamento de variaveis e estados
maior reusabilidade
forte uso de manipulacao de estados
Declarativo (vhdl, sql):
Alta expressividade do que se quer do programa
O fluxo logico eh implicito (nao eh uma receita de bolo, faca isso, faca aquilo...)
Declara-se o que se quer do computador e nao como ele deve fazer isso
Depende mais de compilador e/ou interpretador
Tipos:
Logico (prolog):
fatos, predicados e regras de inferencia
provar a corretude do programa eh bem mais facil
mais lento
Funcional (haskell :))
nao existe mutabilidade:
sem efeitos colaterais
dificulta o gerenciamento de memoria (alto uso de GC)
facilidade de paralelismo
Hoje em dia a tendencia eh multi paradigmas, vide python
############################################################################################################################
Funcional
Recursao:
eh a lei (nao ha iteracao)
Ausencia de mutabilidade:
menos bugs
Efeito Colateral:
Funcao altera algum estado global (inclusive externo ao programa! (ex tela do usuario))
Funcao Pura:
Nao causa efeito colateral
Transparencia referencial:
Qualquer chamada de uma funcao com essa caracteristica pode ser substituida pelo codigo contido na funcao
funcoes puras apresentam essa caracteristica
Haskell eh completamente puro:
Precisa de truques para "ser util" (IO)
Avaliação Preguiçosa:
O compilador gera uma promessa de execucao (thunk) e soh executa as expressoes quando (se) forem necessarias
Isso permite definir listas infinitas e usar apenas o que for necessario runtime |
| 108 |
Pedro Machado Nery dos Santos |
Paradigmas de programação se referem a formas de concepção, escrita e estilização de soluções computacionais. Entre eles, pode-se citar os paradigmas imperativo, estruturado, procedural, orientado a objeto, declarativo, lógico e funcional, entre outros. Grande parte das linguagens de programação oferece suporte à múltiplos paradigmas.
O paradigma imperativo se aproxima de linguagens de máquina ao enunciar comandos sequencialmente e controlar o fluxo de controle e estados de variáveis explicitamente. Paradigmas estruturados e procedurais dele derivados oferecem um nível superior de abstração, especialmente em relação a blocos lógicos e escopos, visando clarificar a codificação. O paradigma orientado a objeto encapsula comportamentos em abstrações chamadas classes que possuem seus próprios métodos e atributos, usando conceitos de herança e polimorfismo para sua composição e ampliando a segurança e reuso de código. Este paradigma também otimiza o escopo de variáveis, mas muitos problemas são de difícil modelagem e paralelização no mesmo. Seu fluxo lógico é menos facilmente traduzido à linguagem de máquina, bem como nos paradigmas a seguir. No paradigma declarativo se enunciam os resultados desejados, deixando o fluxo lógico implícito, mas sendo específico a certo domínio de aplicação. No paradigma lógico, por sua vez, são enunciadas regras de inferência da qual são derivados os resultados desejados, enunciados como pergunta. Por fim, o paradigma funcional é baseado no cálculo lambda, utilizando a composição de funções e também se aproximando de paradigmas declarativos. No entanto, não utiliza estados, o que pode dificultar seu uso em alguns casos.
No paradigma funcional, funções puras, recursão e a avaliação preguiçosa são características marcantes. Funções puras são aquelas que não apresentam efeitos colaterais, isto é, não alteram o estado global do sistema (não altera variáveis globais, não leem entradas de dados e não imprimem algo na tela) e não dependem de funções impuras. A linguagem Haskell somente aceita funções puras.
|
| 109 |
Pedro Antunes Negrão |
Na primeira semana da matéria Paradigmas de Programação foi apresentado como configurar o ambiente em que será desenvolvido a disciplina, utilizando diversas ferramentas para isso, como o Haskell Stack, que auxilia na criação de novos projetos em Haskell (por exemplo instala o compilador GHC automaticamente) e também o Haskell Language Server, que é uma ferramenta que roda em segundo plano por trás da aplicação do editor que fica verificando se a sintaxe do código está correta, e caso não esteja ele recomenda algumas alterações.
Além disso, a segunda playlist da semana se refere à introdução sobre os paradigmas de programação existentes, dando mais ênfase para o paradigma funcional. O professor citou que os paradigmas podem ser divididos em dois grupos: os paradigmas no qual o programador precisa descrever “o que” e “como” o computador deve executar o programa – linguagem semelhante à linguagem de máquina (paradigma imperativo, estruturado e orientado a objetos); e os paradigmas no qual o “como” não precisa ser descrito, apenas “o que” o computador precisa fazer.
Começando pelo paradigma imperativo, nele o programa precisa ser escrito de maneira sequencial, linha por linha, não existindo palavras-chaves como while, for, etc. Já o paradigma estruturado todo o código é escrito em estruturas lógicas, utilizando procedimentos e métodos. O paradigma orientado a objetos utiliza de recursos como classes, objetos, métodos estáticos, encapsulamento, herança, etc. Agora no declarativo o programador apenas escreve o que ele quer (ex. SQL). No paradigma lógico é necessário especificar fatos e regras de inferência que o computador calcula por indução automaticamente. E por fim o paradigma funcional, no qual o programa é comporto apenas por funções. Nesse paradigma é utilizado alguns recursos como funções puras (não apresentam efeito colateral), recursões e avaliação preguiçosa.
|
| 110 |
Paulo Gabriel Massa |
|
| 111 |
Louis Phillipe Sarda Dubois |
Semana 1 – Aula 1:
Setup do Haskell Stack, comandos básicos:
- stack new <project_name> simple # cria novo projeto
- stack setup # instala GHC para poder buildar o projeto
- stack build # builda o projeto
- stack exec # executa o projeto
Arquivos importantes:
stack.yaml arquivo de parâmetros
package.yaml packages do projeto, author e licença
src/Main.hs é o arquivo principal do projeto
Flags de compilador:
-rtsopts – opções de RTS (???)
-Wall – habilita todos os warnings
-threaded – perimite multithread
-O2 – nível de optimização 2 (máximo)
Múltiplos códigos fontes: devem ser adicionados em other-modules do arquivo .cabal
Para bibliotecas deve-se adiciona-las em build-depends do mesmo arquivo
Semana 1 – Aula 2:
Comparação de diferentes paradigmas:
- Imperativo:
- Vantagens: fluxo de controle é explícito; linguagem baixo nível (fácil de ser convertida para o código da máquina);
- Desvantagens: difícil de enxergar rapidamente o resultado de um código mais complexo; não tem controle de acesso de variáveis e funções;
- Estruturado:
- Vantagens: programa dividido em blocos lógicos, podendo seguir o single responsability principle; estimula o uso de variáveis dentro de um escopo;
- Desvantagens: não evita o uso de certos blocos fora de seu contexto; trabalha com mudança de estados, podendo levar à bugs;
- O.O.:
- Vantagens: encapsulamento e regras de acesso; evita o uso de variáveis globais;
- Desvantagens: nem tudo pode ser facilmente modelado como objetos; uso de estados mutáveis; dificuldade de paralelizar
- Declarativo:
- Vantagens: alto nível, minimiza o uso de estados
- Desvantagens: desempenho ruim;
- Lógico:
- Vantagens: fácil de provar que o programa está correto;
- Desvantagens: lento para operações matemáticas;
- Funcional:
- Vantagens: não existe estados e mutabilidade, evitando bugs;
- Desvantagens: intenso uso de GC;
Funções impuras não tem efeitos colaterais, não afetam o estado do sistema.
|
| 112 |
Pietro Di Consolo Gregorio |
Os paradigmas imperativo, estruturado e orientado a objeto são a porta de entrada de muitos cursos que envolvem programação como Computação e Engenharia. Outros paradigmas populares são o declarativo, o funcional e o lógico. O paradigma imperativo é caracterizado pela descrição dos passos a serem feitos pelo algoritmo; o paradigma estruturado é uma evolução do imperativo, porém estruturada em blocos lógicos; o paradigma orientado a objetos encapsula os dados em classes com seus estados e métodos específicos; o paradigma declarativo permite ao programador dizer apenas o que desejam e, portanto, possuem um fluxo lógico implícito; o paradigma funcional é baseado no cálculo Lambda e os programas são composições de funções e não utilizam estados e, por fim, o paradigma lógico baseia-se em fatos e regras de inferência para retornar a resposta de uma pergunta ou objetivo.
As características de uma linguagem funcional são: funções puras, recursão e avaliação preguiçosa. As funções puras são funções que não apresentam efeito colateral (não altera variável global, não lê entrada de dados e não imprime algo na tela), desta forma, uma função pura retorna sempre a mesma resposta para uma mesma entrada. Os laços iterativos em uma linguagem funcional é implementado via recursãi. A avaliação preguiçosa é definida como a criação de uma promessa de execução (ou thunk) quando uma expressão é gerada, ou seja, apenas quando for necessário o thunk será avaliado. |
| 113 |
Pietro Rischi Nunes |
Linguagens Funcionais surgem com o intuito de possuir uma sintaxe declarativa porém com uma maior abrangência.
Nelas não existe estado e mutabilidade, o que diminui a quantidade e bugs, porém a falta de mutabilidade dificulta o gerenciamento de memória, aumentando o uso do Garbage Collector. |
| 114 |
Rafael Caran Fernandes |
|
| 115 |
Rafael Fernandes Rodrigues |
|
| 116 |
Rafael Pauwels de Macedo |
A primeira semana de aula foi divido entre uma seção prática que explicava como deveriamos configurar os ambientes de desenvolvimento e o básico de um programa Haskell que utiliza Stack como ferramenta de gerenciamento. Durante a aula teórica da semana vimos uma introdução aos diferentes paradigmas com um foco no paradigma funcional, comparamos os pontos fortes e fracos de cada paradigma e onde eles se encaixam na história, falendo brevemente também do uso de cada um desses paradigmas. Além do funcional vimos os paradigmas: imperativo, estruturado, orientado a objeto, declarativo e lógico.
Dentro do paradigma funcional alguns conceitos receberam destaque especial, entre eles temas como funções puras, que são aquelas que não apresentam efeito colateral, recursão vs iteração e avaliação preguiçosa. |
| 117 |
Raphael Ramos da Silva |
Paradigma de programação: estilo utilizado para organização das ideias.
- Imperativo: ações sequenciais / passo a passo (receita de bolo) (uso de goto).
- Estruturado: código estruturado em blocos, com funções e procedimentos (uso de laços).
- Orientado a Objetos: encapsulamento em classes, com atributos e métodos próprios.
- Declarativo: foco no objetivo de interesse (e não no modo).
- Lógico: baseado em regras lógicas, o compilador se auto-organiza para dar uma resposta.
- Funcional: baseado em funções matemáticas e suas composições (foco da disciplina).
- As evoluções nos compiladores contribuíram para a disseminação e uso de vários paradigmas de programação. Grande parte das linguagens são multi-paradigmas.
Paradigma Funcional: funções puras + recursão + avaliação preguiçosa
- Função pura: não altera o estado final do sistema (alteração de variáveis globais, leitura e escrita de dados). Essa independência viabiliza o paralelismo. Se uma funçãochama uma função impura, ela também se torna impura.
- Recursão: substitui os laços (código mais legível).
- Avaliação preguiçosa: só utiliza / executa os parâmetros necessários para computação. Isso permite a criação de listas infinitas.
Na disciplina usaremos uma linguagem Haskell, puramente funcional, com tipagem estática e forte.
|
| 119 |
Renan Goncalves Miranda |
Paradigma de programação é como é estruturado a programação, ou seja, como é organizada as ideias para a construção de um programa.
Os paradigmas mais comuns e mais populares são o imperativo, estrutura e orientado a objeto, onde são descritas sequencias de operações de o que e como o computador deve fazer. Porém existem outros tipos de paradigmas que descrevem o que queremos fazer e não tanto como, exemplos, o declarativo, funcional e o lógico.
Todos os paradigmas existem vantagens e desvantagens, tudo dependo do que o programador quer fazer.
O paradigma funcional é baseado no cálculo lambda, onde os programas são composições de funções, por não possuir estado e mutabilidade, o paradigma funcional reduz a quantidade de bugs, entretanto a ausência de mutabilidade aumento o uso de Garbage collector.
Os características que definem uma linguagem funcional é a utilização de funções puras, a utilização da recursividade e a avaliação preguiçosa.
Funções puras não apresentam efeito colateral (altera algum estado global do sistema), ou seja, ela sempre devolve a mesma resposta dado os mesmos parâmetros. Uma função impura é viral, ou seja, se uma função aparentemente pura chama uma função impura essa função se torna impura. E se uma função aparentemente pura só chama funções puras, essa função não necessariamente é pura.
Os erros de implementação são evitados com a ausência de estados.
A avaliação preguiçosa nada mais é que avaliar se o que a função faz está sendo usado, as que não são usadas não serão executadas, com isso é possível a criação de listas infinitas.
O Haskell é puramente funcional, todas suas funções são puras, é uma linguagem declarativa, com uma tipagem estático e forte e possui a avaliação preguiçosa.
|
| 120 |
Henrique Magro de Souza |
Paradigmas de Programação existentes e exemplos de linguagem:
- Funcional - Javascript, Haskell
- Orientado a Objetos - Java, C#, C++
- Estruturado - C, Fortran
- Declarativo - SQL, VHDL
- Imperativo - Assembly
- Lógico - Prolog
Muitas dessas linguagens são multi-paradigmas, ou seja, podem apresentar várias características de vários paradigmas diferentes em seu código.
Nessa disciplina iremos focar no paradigma Funcional pois, deduzo eu, que os outros paradigmas já são tratados em outros cursos (PE, POO, BD, etc).
E também utilizaremos Haskell que é uma linguagem puramente funcional (não sendo multi-paradigma).
O paradigma funcional é baseado em:
- Funções puras.
- Cálculo lambda. - Veremos nas próximas aulas com mais detalhes
- Composições de funções.
- Avaliação preguiçosa.
Funções puras são aquelas que não possuem efeito colateral, e portanto possibilitam uma compreensão melhor do código (não preciso entender o todo para saber o que aquela porção de código faz).
Efeito colateral acontece quando a função altera algo que está fora de seu escopo, por exemplo:
- Alterar uma variável global ou estática.
- Imprimir algo na tela.
- Ler entrada de dados.
Se uma função pura usa uma função impura, ela se torna impura.
Porém se uma função usa só funções puras, isso não significa que ela mesma não seja impura.
A avaliação preguiçosa permite que você encadeie funções (composição de funções), para que uma execute após a outra. |
| 121 |
Rodolfo Azevedo dos Santos |
|
| 122 |
Rodrigo Amador Medeiros Magalhaes |
Foi estudado como fazer calculos matemáticos básicos e reutilização de funções, mantendo as funções puras
|
| 123 |
LARISSA RODRIGUES DE ALMEIDA |
Aprendi a preparar o ambiente de programação do Haskell: instalei o Ubuntu (dual boot) e os editores de textos recomendados.
Após isso, houve uma aula teórica que explica as características dos diferentes tipos de paradigmas da programação, incluindo o que será estudado que será a programação funcional.
Os principais atributos deste paradigma são:
- Não utiliza estados (redução de bugs).
- Declarativo.
- Possui funções puras (não possuem efeitos colaterais, ou seja, sempre obtém a mesma resposta).
- Possui recursão (torna o código enxuto e declarativo).
- Possui avaliação preguiçosa (Apenas avalia conteúdos que estão sendo utilizados).
A linguagem utilizada nessa matéria será o Haskell, que possui todos os atributos do paradigma funcional.
|
| 125 |
Samuel Esdras Navarro da Silva |
Topico 1: preparando o ambiente
comandos de terminal aprendidos:
1-stack new nome-do-projeto simple
2-stack build
3-stack run
Haskell Language Server - se atentar a versao do ghc
Topico 2: apresentacao dos paradigmas de programacao
Foco no paradigma funcional
|
| 126 |
Jean da Silva Neves |
O que se entende por paradigma de programação?
É uma forma de se estruturar uma ideia de forma a conseguir transmitir ela ao computador.
Então consiste em organizar o fluxo de pensamento para se resolver um problema e para passar isso ao computador existe algumas abordagens que são os paradigmas.
Alguns tipos de paradigmas são:
Imperativo:
Consiste de operações lógicas e aritméticas , e de saltos (goto).
Então o programa consiste em uma sequência de passos bem definidos para se chegar a solução do problema.
Estruturado:
Tenho blocos de código lógico, como funções e laços de repetição.
Orientado a Objeto:
Passo a fazer uso de classes, que são objetos com atributos (variáveis) e funções, onde a ideia é, preferencialmente, isolar os atributos das classes do restante do programa, tornando eles acessíveis apenas com a utilização das funções de classe.
Declarativo:
Digo o que eu quero, mas não como eu quero. Um exemplo é a linguagem SQL.
Lógico:
Específica apenas fatos e lógicas de inferências, o que torna simples a prova de corretude do programa.
Funcional:
As funções não alteram o estado do sistema.
Laços interativos são realizados através de recurção.
Avaliação preguiçosa, uma expressão lógica gera uma promessa de execução e apenas quando o resultado da expressão se torna necessário é que ela é em fim executada.
|
| 127 |
Lucas de Souza |
A primeira semana de aula iniciou com preparação do ambiente para o curso, principalmente no que diz respeito à instalação do Stack, para criar e gerenciar projetos em Haskell e do Haskell Language Server, que detecta erros no algoritmo e dá sugestões de melhoria para o código. Como não sou aluno da bcc e fiz poucas disciplinas do curso, resolvi prosseguir com o curso no SO windows que possuo na minha máquina, sendo necessária instalar uma máquina virtual de Ubuntu conforme o tutorial disponível no curso. Também decidi utilizar o Vim como editor, pois ainda não possuo nenhum editor favorito. Assim, apesar de ainda não ter tomado a coragem para trabalhar num SO Linux durante o curso, pretendo aprender bastante com a disciplina, tanto no que se trata à programação funcional e o haskell em si, como no uso de editores mais robusto e me acostumar com a utilização do terminal Ubuntu, que não havia sido necessário em outras disciplinas de programação que cursei anteriormente (BCC, PI, PE, AED1).
A segunda parte da primeira semana introduziu os diferentes paradigmas de programação que existem, enfatizando suas principais diferenças e particularidades. No que diz respeito ao paradigma funcional, entendo que sua principal característica é o fato de ser declarativo, diferente dos paradigmas mais comuns de linguagens de programação que aprendemos em disciplinas iniciais do curso de ciência da computação, que são primordialmente imperativos. Outra característica muito importante é o uso majoritário de funções puras, que são funções que não apresentam nenhum efeito colateral, mantendo as variáveis do sistema inalteradas. Além disso, outro aspecto muito interessante do paradigma funcional e, em particular, do Haskell, é a Avaliação Preguiçosa, em que apenas são computadas as expressões que serão de fato utilizadas, permitindo, por exemplo, a criação de listas infinitas.
|
| 128 |
Tamires Christyne da Silva |
Aula 1
Foram apresentados paradigmas de programação, como orientação a objetos (onde informações são trocadas por meio dos objetos),estruturado (onde se explicita o fluxo de ocorrências) e outros; também foi abordado o paradigma funcional que será abordado ao longo dessa disciplina, baseados em funções matemáticas onde estados e dados não se alteram ainda nesse tema foi abordado o conceito de efeito colateral que se distingue em função pura e impura e que os problemas com repetição são resolvidos nesse paradigma por meio de recursão.
|
| 129 |
Renato Vinicius Turtienski Possa |
Preparando o ambiente: não houve grandes dificuldades, estou usando o Ubuntu como SO e rodei pelo terminal
os comando sugeridos. Quanto aos editores, entre Emacs e Vim, fiquei com Vs Code(até já instalei uma
extensão para contar a quantidade de palavaras e não passar as 300 nos resumos),
por ter melhor familiaridade, mas vou evoluindo ao longo do curso com os dois editores sugeridos
(confesso que o Emacs foi meu favorito entre a disputa dos editores, 1x0 Emacs por enquanto).
Paradigmas da Progamação: Assistindo a aula entendi que, conforme necessidades de estruturação de algoritmos
e maneiras para resolução de problemas(de acordo com as abstrações necessárias) os paradigmas foram surgindo.
Sendo importante o conhecimento dos diversos paradigmas para poder lidar com suas limitações e poder sempre
ter opções para montagem das soluções
Paradigma Funcional: Suncitamente as características do paradigma funcional:
- funções puras: não há efeito colateral de estado global do sistema, i.e, uma função não consegue
fazer a alteração das variáveis foram setadas fora dela, e seu retorno sempre será o mesmo dado o mesmo
parâmetro. Também não há a escrita ou leitura de arquivos, ou até mesmo a impressão na tela(alteração
do estado do sistema)
- Recursão: simplificando, as iterações não são feitas por while ou for e sim por funções recursivas, o que
deixa o código mais enxuto e melhor entendimento
- Avaliação Preguiçosa: Com a promessa de execução, a expressão somente é gerada se houver necessidade, com
isso podemos criar listas infinitas, pois o resultado de interação só será computadado até onde for
suficiente. Evita assim cálculos desnecessários.
|
| 130 |
VITTORIA ARIEL DOS SANTOS BOROTTO |
Existem muitos paradigmas de programação que são maneiras de programar para chegar em uma solução, entre eles:
- Imperativo: basicamente em uma sequência de comando que alteram estado atual ate um estado final. Evoluiu para procedural e estruturado.
- Estruturado: uma estrutura com uso de processos e funçōes, organizando melhor
- Orientado a objeto: que é uma outra maneira de organizar o código que tenha dados, estados, e metodos que podem alterar, recuperar os dados e ate mesmo os estados. Utilização de objetos é bem comum na lógica.
Pode-se notar que foi melhorarando, a estrutura e as maneiras, cada um ideal para cada problema, da mesma forma temos outros mais distintos paradigmas, como:
- Declarativo: diferentemente do imperativo que usava o como fazer, nesse o foco do programa fica em o que quer, sem o passo a passo.
- Funcional: não é completamente declarativo, mas com base em funçōes matemáticas indicando o que quer que o programa faça e com dados imutaveis. Baseado em cálculo lambda, composição de funcōes, não utiliza estados. Reduzindo quantidade de bugs.
- Lógico: uma série de fatos e regras e o compilador se vira com o programa.
Tendo isso em mente, parece que cada linguagem pode ter um único paradigma mas hoje em dia a maioria das linguagens sao MULTI-PARADIGMAS,
ou seja não se limitam a uma única maneira de programar. Podendo uma ter mais caracteristicas funcionais do que imperativa ou vice-versa.
Nessa matéria iremos lidar com a linguagem funcional que tem como principais características: funcoes puras(nao apresentam efeito colateral), recursao, avaliacao preguicosa.
Efeito colateral: quando uma função altera um estado global do sistema(alterar variavel global, ler entrada de dados, imprimir algo na tela).
Essas caracteristicas veremos no Haskell, linguagem puramente funcional. |
| 131 |
Victor Lourenco Borges |
|
| 132 |
Victor Santana Ribeiro |
|
| 133 |
Vinicius de Oliveira Campos dos Reis |
Um dos temas das aulas é paradigmas de programação, que podemos pensar como a forma como instruiremos os algoritmos para realizar determinada tarefa. Quando iniciamos o aprendizado de programação, costumamos encontrar linguagens que funcionam em torno de paradimas mais comuns, como orientado a objetos (Java, Python, C++), ou declarativo (SQL).
Um ponto a se destacar é que muitas linguagens não possuem uma fronteira clara entre quais tipos de paradigmas elas seguem, quer dizer, a maioria delas utilizam múltiplos paradigmas na sua implementação.
Durante as aulas conheci um paradigma de programação da qual não estava acostumado a trabalhar, e que é foco dos nossos estudos, o paradigma funcional. Este paradigma funciona estritamente em torno de funções matemáticas, não altera estados e trabalha com dados imutáveis.
Diversas linguagens de programação possuem características do paradigma funcional, Python por exemplo possui funções como função lambda, map, e filter, por exemplo. Em nossos estudos a linguagem escolhida foi o Haskell, que é estritamente funcional, para que o aprendizado do paradigma seja mais assertivo do que trabalhando com uma linguagem multi-paradigmas.
Na segunda aula, abordamos o tópico de funções puras e impuras, onde as funções puras retornam sempre o mesmo resultado de acordo com uma dada entrada, e não altera o estado geral do sistema, isto é, não possui efeito colateral. Diferente das funções impuras, que não cumprem este papel.
Porém, é importa ressaltar que programas 100% puros, não nos é útil, já esgtes não alteram em nenhum nível o estado do sistema. Em Haskell, ainda que nosso foco seja ter funções 100% puras, precisamos que a parte impura fique apenas para o ambiente de execução, para que tenhamos programas puros, e úteis. |
| 134 |
Vinicius Lourenco da Silva |
Existem alguns tipos de paradigmas mais populares:
* Imperativo;
* Estruturado;
* Orientado a objeto;
* Declarativo;
* Funcional;
* Lógico.
O paradigmas imperativo descreve o que deve ser feito (não possui ifs, while, etc)
As vantagens são o fluxo de comandos completo e ser mais próximo da linguagem de máquina.
as desvantagens são a dificuldade de ler o código e debugá-lo, e o uso de variáveis globais.
O paradigmas estruturado evolui do imperativo, onde agora cada "grupo" de comandos é agrupada em blocos lógicos.
O paradiga estimula o uso de funções e variáveis locais com escopo.
Como desvantagem, o paradigma não evita que informações sejam usadas fora de contexto e as mudanças de estados pode levar a bug.
O paradigma Orientado a objeto é similar ao estruturado, porém, o código é organizado em classes não compartilhadas.
Como vantagem, o código é encapsulado para segurança e reuso, como desvantagem tem a da herança de classes que pode bagunçar o fluxo e é difícil de paralelizar.
O paradigmas declarativo, usado por exemplo no SQL, é construido com "ordens" do que se deseja ser feito, mas não como.
Como vantagem temos a facilidade da utilização, e desvantagem minimiza os estados porém pode ter um custo extra de desempenho e maior dificuldade de extensão de funções externas.
O paradigmas lógico define regras lógicas.
Como vantagem, temos que provar a corretude é simples e o compilador cria o programa com base em fatos, porém programas complexos são difíceis de serem definidos e costumam ser lentos.
O paradigmas funcional é baseado em cálculo lambda e em funções, não utiliza estados e é declarativo.
Como vantagem temos a facilidade de expressão, a redução de bugs pela falta de mutabilidade, mas fica mais difícil fazer programas sem estados e possui um intenso uso do garbage colector |
| 135 |
Vitor Dias Bellucci |
|
| 136 |
Vitor Rubens Sniquer Leao Martins |
|
| 137 |
Vitor Marini Blaselbauer |
|
| 138 |
Walter Oscar Trujilo |
Paradigmas de Programação
O que é um paradigma de progamação:
- Estilo de programação; Forma na qual a solução computacional de um problema é descrita.
Paradigmas existentes e suas características:
- Imperativo: sequência de comandos.
- Estruturado: sequência de comandos estruturados em blocos, uso de procedimentos e funções.
- Orientado a objeto: organização através de objetos que contém dados, estados próprios e métodos que alteram e/ou recuperam seus dados e estados.
- Declarativo: especifica-se o que quer, sem especificar como fazer.
- Funcional: avaliações de funções matemáticas sem alteração de estados e com dados imutáveis.
- Lógico: especifica-se um conjunto de fatos e regras, o interpretador infere respostas para perguntas sobre o programa.
Obs:
- Todos os paradigmas possuem pontos positivos e negativos.
- Dependendo do problema a ser resolvido, o uso de um determinado tipo de paradigma pode ser mais adequado do que outro.
- Muitas das linguagens de programação atuais são consideradas multi-paradigmas e acabam sendo classificadas de acordo com o paradigma mais presente.
Paradigma Funcional - Características:
- Funções puras: Não altera nenhum estado global do sistema.
- Não há iteração, há recursão: Como nenhum estado global do sistema é alterado, não é possível haver iterações. Recursão deve ser utilizada.
- Avaliação preguiçosa: Somente expressões que são de fato chamadas são avaliadas;
|
| 139 |
Wesley Axel de Barros |
Resumo sobre a atividade 01 de paradigmas da computação:
Atividade simples, com a intuição de verificar se o ambiente haskell está funcionando corretamente,
Unico objetivo era realizar os calculos propostos e modificar os valores no arquivo src/Exercicios.hs
Realizei os calculos e executei o comando stack test para verificar se estava tudo correto,
Na primeira vez acertei apenas 2 questões, e pelo proprio teste vi que as que estavam erradas era por conta das casa decimais das respostas,
Arrumado as respostas com as devidas casas decimais pedidas, e executando o teste novamente, tudo correu certo e os 5 testes passaram. |
| 140 |
Wesley Batista Soares |
Podemos simplificar o conceito dos paradigmas de programação como a "forma que você organiza suas ideias",
alguns dos paradigmas existentes são o Imperativo, Estruturado e Orientado a Objeto (podemos dizer que eles seguem a ideia de algoritmo de serem uma "sequência de operações de como fazer" ou receita de bolo).
Outros paradigmas existentes são: Declarativo, Funcional e Lógico. Possuem a ideia de "dizermos apenas o que desejamos como resultado".
Muitas linguagens de programação são multi-paradigmas como Python e Java (com Lambda Functions).
Algumas das características do paradigma funcional são: funções puras, recursão, avaliação preguiçosa.
Para entender melhor os conceitos acima, devemos entender o conceito de efeito colateral, que é o fato de uma função alterar o estado global do sistema.
Alguns conceitos de funções puras, são que não possuem efeito colateral, além de que uma função pura que chama uma função impura também é impura.
Outro conceito importante é a avaliação preguiçosa: é quando uma expressão é gerada, ela gera uma promessa de execução e somente quando necessário ela é avaliada.
|
| 141 |
Willian Comar Sanches |
|
| 142 |
William Sena Silva |
|
| 143 |
Willian Cortez |
RESUMO AULA 01 - PARADIGMAS DE PROGRAMAÇÃO
Aula 0
Na primeira semana do curso de paradigmas da programação, foi realizado a configuração
do ambiente de trabalho haskell.
Foi demonstrado três tipos de ambientes, o primeiro utilizando as ferramentas emacs mais
distro linux; o segundo utizando o Vim mais distro linux e por último em ambiente windows com
visual studio.
Eu escolhi para ester curso aprender Vim, por recomendações de amigos/ colegas, achei mais
intuivo que o emacs.
Para a configuração do haskell foi necessário fazer o download do package tanto do
haskell-language-server quanto o haskell-language-server-wrapper.
Realizado as configurações necessárias no vim, instalando plugins e outros pacotes, no final
rodou conforme o esperado, o famigerado "Hello World".
Aula 1.1
A liguagem haskell é do tipo funcional, aonde programas são avaliações de funções matemáticas
sem alterar estados e com dados imutáveis.O paradigma é do tipo Funcional, aonde é baseado
no cálculo lambda, os programas são compoições de funções, não utiliza estados e é Declarativo
Os prós:
- Expressividade próxima de linguagens declarativas, mas sem limitações
- Não existe estado e mutabilidade, isso reduz a quantidade de bugs
Os contras:
- Como fazer algo útil sem estados?
- A ausência de mutabilidade dificulta o gerenciamento de memória, intenso uso de Garbage
Collector.
Aula 1.2
Definição de função pura, é quando não é necessário um estado anterior para que a função
funcione.Não tendo efeitos colaterais sobre o sistema. Exemplos:
- strlen: pura
- printf: impura
- memcpy: pura
- getc: impura
Algumas características do Haskell:
- Linguagem puramente funcional (não é multi-paradigma)
- Somente aceita funções puras
- Declarativa
- Avaliação Preguiçosa
- Dados imutáveis
- Tipagem estática e forte
|