<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="3.10.0">Jekyll</generator><link href="https://lerax.me/feed.xml" rel="self" type="application/atom+xml" /><link href="https://lerax.me/" rel="alternate" type="text/html" /><updated>2026-01-01T13:34:51+00:00</updated><id>https://lerax.me/feed.xml</id><title type="html">Manoel V. Machado</title><subtitle>That place is where I talk about my projects and my life.</subtitle><entry><title type="html">Pai init</title><link href="https://lerax.me/personal/pai-init/" rel="alternate" type="text/html" title="Pai init" /><published>2025-12-31T20:34:00+00:00</published><updated>2025-12-31T20:34:00+00:00</updated><id>https://lerax.me/personal/pai-init</id><content type="html" xml:base="https://lerax.me/personal/pai-init/"><![CDATA[<div id="outline-container-orgde5f942" class="outline-2">
<h2 id="orgde5f942">Introdução</h2>
<div class="outline-text-2" id="text-orgde5f942">
<p>
Esse ano não foi fácil. 2025 foi um ano bem desafiador&#x2026; Tão
desafiador que eu não sei exatamente como fiz pra fazer ele funcionar
olhando em retrospectiva nesse final de ano.
</p>

<p>
O primeiro ano <b>INTEIRO</b> como pai. E também o ano que descobri que teria meu
segundo filho, de uma forma bem surpreendente pra mim, pra minha
esposa e pra todos. De fato, planejamos ter mais de um filho, mas não
em 2025! Foi o elemento surpresa do ano.
</p>
</div>
</div>
<div id="outline-container-orgc9373e2" class="outline-2">
<h2 id="orgc9373e2">2025.1: Mais um filho chegando</h2>
<div class="outline-text-2" id="text-orgc9373e2">
<p>
O começo do ano teve suas dificuldades inerentes da adaptação de se
tornar pai, a Briana crescer e suas recorrentes novelas pra regular
seu sono, que se mantém com problemas até hoje (pense numa bixinha
hiperativa a noite!).
</p>

<p>
Tive algumas disciplinas a serem feitas no ITA, entre elas uma matéria
de metodologia científica, mas nada em especial que fosse realmente
difícil. Nesse caso foi mais uma disciplina trabalhosa pra montar o
mapeamento sistemático da literatura que iria servir como guia pra
minha dissertação de mestrado. Muitos artigos pra ler, resumir e
comparar.
</p>

<p>
E, aí&#x2026; Descobri que iria ser mais uma vez pai no final de abril pra
início de maio. Dessa vez de um menino! Eu estava com planos pra ir
a São José dos Campos, mas não imaginava uma segunda gravidez nessa
altura do campeonato.
</p>

<p>
Isso praticamente fez eu desistir de ir pra São José dos Campos,
porque iria complicar consideravelmente tudo. Por outro lado, a partir
desse ponto eu já teria me tornado aluno regular no mestrado do ITA e
sem essa ida no próximo semestre pra completar as disciplinas
presenciais faltantes, certamente no ano seguinte eu não poderia
viajar pra poder fazer as aulas e iria ter que desistir do mestrado!
</p>

<p>
Então&#x2026; Decidimos ir, após uma grande insistência da Taiene para que
eu não desistisse de tudo nessa altura do campeonato por conta da nova
gravidez. Combinamos ir logo depois do aniversário da Briana, que
seria feito de forma antecipada em julho por conta da viagem.
</p>

<p>
<img src="/assets/posts/pai-init/briana-birthday.jpg" alt="nil"/>
</p>
</div>
</div>
<div id="outline-container-org1bf20fc" class="outline-2">
<h2 id="org1bf20fc">2025.2: São José dos Campos</h2>
<div class="outline-text-2" id="text-org1bf20fc">
<p>
Chegamos em 1 de agosto em SJC, fomos de carro dessa vez. Esse dia
completava um ano de vida da Briana. Foi uma viagem divertida, apesar
das dificuldades de viajar com uma criança e também de ter acabado o
combustível na estrada no meio do deserto que é Tocantins.
</p>

<p>
De toda forma&#x2026; Esse semestre foi difícil, muito difícil mesmo. Foi
interessante ter que sair do Pará e passar por um período como pais
independentes longe de todos, exercitando nossa capacidade de
gerenciar tudo sozinho, com o agravante da Taiene estar grávida
novamente.
</p>

<p>
A Briana eventualmente aprendeu a andar, e então a correr&#x2026; Explorar
tudo. Mas infelizmente não aprendeu a dormir direito, sempre trazendo
muitos desafios durante o período da noite.
</p>

<p>
Tivemos complicações na gravidez, no mês de outubro, no exame de
ultrassom morfológica de segundo semestre recebemos um diagnóstico de
colo curto em que aumentaria a chance de parto prematuro. Isso
complicou as coisas, tivemos que fazer uma intervenção emergencial pra
diminuir os riscos de parto e planejar uma volta imediata da Taiene e
a Briana&#x2026; Mas eu não poderia voltar com elas e ficar por lá,
infelizmente.
</p>

<p>
Durante esse período, eu ainda estava tendo aulas presenciais em duas
disciplinas e só teria férias depois de um mês, e uma em especial
certamente foi a disciplina mais difícil que tive no mestrado:
Estrutura de Dados, Análise de Algoritmos e Complexidade Estrutural
(CT-234). Que disciplina!
</p>

<p>
No final de outubro viajei brevemente com a Taiene e Briana até Belém
pra elas voltarem com sua família pra casa, enquanto voltei pra São
José dos Campos. Apesar da loucuras, vôo atrasados, tretas com
bagagem&#x2026; E viajar pela primeira vez com uma criança num avião por
quase 4 horas, deu tudo certo. Quando voltei pra SJC, cheguei quase 3
da manhã em casa depois de muito rolo&#x2026; Tive que dirigir de madrugada
e foi muito cansativo.
</p>

<p>
O mês de novembro foi muito estranho. Eu fiquei sozinho nesse período
todo. Acho que comecei a perder a noção do tempo, foco e qualquer
outra coisa que sobrou. E eu sempre estava em algum momento desejando
mais tempo e silêncio, consegui isso mas minha mente já tava tão
saturada com tudo que não consegui saber usar bem todo esse recurso
valioso que tanto queria.
</p>

<p>
A segunda prova dessa disciplina eu não me dei bem e fiquei pendurado
dependendo de tirar uma nota melhor na última prova pra não reprovar.
</p>

<p>
Acho que&#x2026; Desde o vestibular entre 2012-2013 nunca mais tinha
sentido tanta ansiedade. E a pressão toda tinha um motivo: se eu
reprovasse eu iria perder o mestrado. Ou seja, todos os sacrifícios
dos últimos dois anos teria sido em vão, junto com todo o dinheiro
gasto no processo de ter residência de temporada em SJC (caríssimo).
</p>

<p>
Estudei como um maluco nos próximos dias&#x2026; Orava todo dia. E, então,
consegui tirar um 9.6 na última prova, que foi o suficiente pra
conseguir passar ainda com uma média boa no final da disciplina. Foi
um alívio imenso. Realmente fazia muito tempo que não ficava tão feliz
com algum resultado de algo que me esforcei pra conseguir!
</p>

<p>
Diogo, meu sobrinho, veio do interior do Pará de avião e então
voltamos de carro, dirigindo por 3000km durante 5 dias até chegar em
casa, como fizemos em 2024 também.
</p>

<p>
Aliás, dias antes de começar a viagem estávamos lá na pista de kart e
dessa vez o Diogo conseguiu lavar a alma dele, já que na partida de
2024 ele levou uma lapada de uma cacheada que fez ele rodar na pista e
chegar em penúltimo. Dessa vez ele chegou em 5°!
</p>

<p>
<img src="/assets/posts/pai-init/kart.jpg" alt="nil"/>
</p>
</div>
</div>
<div id="outline-container-org493be83" class="outline-2">
<h2 id="org493be83">O retorno e o final de 2025</h2>
<div class="outline-text-2" id="text-org493be83">
<p>
Agora estamos apenas esperando o ano acabar&#x2026; E também na espera de
eventualmente o parto acontecer de forma saudável. Ainda há
preocupações por aí&#x2026; Seja como vai ser o parto com a remoção do
pessário nesse fim de mundo, ou as dívidas que ficaram no caminho com
essa loucura de ano, ou como vamos conseguir comprar uma boa casa pra
essas crianças ano que vem.
</p>

<p>
Mas eu quero pensar&#x2026; De forma bem direta, que até esse momento, Deus
esteve comigo e vai continuar comigo em 2026. Sei que minhas preces
foram ouvidas durante aquela véspera de prova! E que Deus cuide da
Taiene, a "gestosa" que carrega o Sebastian.
</p>

<p>
Feliz ano novo a todos. Que 2026 seja divertido e também nos permita
descansar de tudo isso.
</p>

<p>
<img src="/assets/posts/pai-init/family.jpg" alt="nil"/>
</p>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="personal" /><category term="personal" /><summary type="html"><![CDATA[Primeiro ano completo como pai]]></summary></entry><entry><title type="html">OCaml Journey</title><link href="https://lerax.me/programming/ocaml-journey/" rel="alternate" type="text/html" title="OCaml Journey" /><published>2025-11-09T16:18:00+00:00</published><updated>2025-11-09T16:18:00+00:00</updated><id>https://lerax.me/programming/ocaml-journey</id><content type="html" xml:base="https://lerax.me/programming/ocaml-journey/"><![CDATA[<link rel="stylesheet"
      href="/assets/css/style.css"
      type="text/css"/>
<div id="outline-container-orge1c2165" class="outline-2">
<h2 id="orge1c2165">Introdução</h2>
<div class="outline-text-2" id="text-orge1c2165">
<p>
Em novembro de 2025 comecei a estudar OCaml, uma das últimas
linguagens de programação funcional que ainda não havia tocado a
mão. Em anos anteriores, já havia programado em Haskell, Common Lisp,
Scheme, Racket, um pouco de Clojure, F#, Scala entre outras. Mas OCaml
nunca tinha me chamado tanto atenção, por um lado por achar que
Haskell deveria ser superior por ser uma linguagem de programação
pura, mas talvez nunca dei moral por conta que nunca gostei do nome da
linguagem&#x2026; é, talvez tenha sido uma coisa estúpida como essa&#x2026;
</p>

<p>
Depois de muita conversa com colegas sobre como OCaml era usado em
<a href="https://www.janestreet.com/join-jane-street/open-roles/?type=experienced-candidates&amp;location=new-york">Jane Street</a>, uma empresa famosa no mundo de trade de alta frequência
em NYC, comecei a olhar com certa cautela sobre a linguagem&#x2026; Eles
mantém um compilador particular de OCaml com extensões próprias, não é
interessante? Há muitas histórias também de compiladores inicialmente
escritos em OCaml, o próprio <a href="https://github.com/rust-lang/rust/tree/ef75860a0a72f79f97216f8aaa5b388d98da6480/src/boot">compilador de Rust</a> em suas primeiras
versões era escrito em OCaml. Não que eu me importe tanto com Rust,
mas é um achievement interessante a linguagem ter esse tipo de
sucesso. Curtia muito também um leitor de PDF ultra rápido chamado
<a href="https://github.com/criticic/llpp">llpp</a>, que era escrito em OCaml também.
</p>

<p>
Pra isso, resolvi me embarcar numa nova jornada de aprendizado com
OCaml através da plataforma de exercícios de programação <a href="https://exercism.org/tracks/ocaml">exercism.org</a>.
</p>
</div>
</div>
<div id="outline-container-org168a644" class="outline-2">
<h2 id="org168a644">Inevitável comparar com Haskell</h2>
<div class="outline-text-2" id="text-org168a644">
<p>
Eu tive muitas infelicidades pra tentar fazer coisas mais práticas com
Haskell ao depender de cabal e stack. Quem mexeu com Haskell e não
passou por <a href="https://well-typed.com/blog/2014/09/how-we-might-abolish-cabal-hell-part-1/">cabal hell</a> não mexeu com Haskell tempo o suficiente. Era um
verdadeiro inferno&#x2026; Tive duas rodadas de programação com Haskell no
geral, em 2014 e outra em 2017. Aprendi vários conceitos
interessantes, mas sempre me bati muito sobre como gerenciar uma
aplicação prática que possui dependências e irá entregar uma aplicação
útil no final. Percebi também que o gerenciamento monâdico obrigatório
pra IO e todos os efeitos colaterais era pra mim um verdadeiro pé no
saco, onde linguagens como Scala, F# e Common Lisp me davam muito mais
liberdade pra escolher bem onde era melhor fazer algo procedural ou
funcional. Eu sempre gostei de liberdade e poder escolher as melhores
ferramentas pra'quele problema invés de ser algo disciplinar, como
acontece com Haskell e também Rust (por outros motivos que não é
programação funcional pura).
</p>
</div>
</div>
<div id="outline-container-org4f79e33" class="outline-2">
<h2 id="org4f79e33">Tooling</h2>
<div class="outline-text-2" id="text-org4f79e33">
<p>
Acredito que antes de entrar em todos os detalhes sobre as
particularidades da linguagem, algo me chamou atenção em relação a
outras linguagens de programação funcional, principalmente em
comparação a Haskell. OCaml tem um tooling muito melhor e mais coeso
em amplo sentido.
</p>

<p>
Por outro lado, OCaml se resolve com dois pilares de ferramentas:
</p>

<ul class="org-ul">
<li><a href="https://opam.ocaml.org/blog/about-utop/">opam</a>: package manager</li>
<li><a href="https://github.com/ocaml/dune">dune</a>: build system (que usa s-exp para configs, achei ótimo)</li>
</ul>

<p>
Isso já me trouxe um certo frescor inicial em ter que pensar que não
iria passar novamente pelo terror que foi com Haskell.
</p>

<p>
Meu editor principal é o emacs, e aparentemente há muitos
programadores de OCaml que também o usa, então fiquei contente por
pensar que teria uma vida facilitada com isso&#x2026; Haskell já tinha um
suporte bom no emacs também. Aparentemente bons programadores
escolherem emacs não é uma grande surpresa também.
</p>

<p>
Ao utilizar como base a configuração do prelude, o módulo
<a href="https://github.com/bbatsov/prelude/blob/master/modules/prelude-ocaml.el">prelude-ocaml</a>, o modo tuareg-mode está configurado com um conjunto de
ferramentas que mesmo sem o uso de LSP possui praticamente tudo que
preciso: goto-definition, auto-complete e type signature lookup.
</p>

<p>
Há algumas ferramentas em particular que encontrei que ajudam bastante
adescoberta de funções e depuração. Em seguida vou citar três em
particular que achei bastante interessante.
</p>

<p>
<a href="https://opam.ocaml.org/blog/about-utop/">utop</a>: um repl cheio de firulas que melhora a interação com OCaml
interativamente (não saquei muito o motivo do nome).
</p>

<p>
<img src="/assets/posts/ocaml-journey/utop.gif" alt="nil"/>
</p>

<p>
<a href="https://www.typerex.org/ocp-index.html">ocp-index</a>: motor de busca local de funções, docs e autocomplete, tem
um browser legal com fuzzy search também muito bom (ocp-browser).
</p>

<p>
<img src="/assets/posts/ocaml-journey/ocp-browser.gif" alt="nil"/>
</p>

<p>
<a href="https://doc.sherlocode.com">sherlocode</a>: um sistema web indexador de funções e documentações de
  vários pacotes, com fuzzy search e type signature search, similar ao
  <a href="https://hoogle.haskell.org/">Hoogle</a> &#x2013; que de longe era uma das melhores coisas do tooling de Haskell.
</p>

<p>
<img src="/assets/posts/ocaml-journey/sherlocode.png" alt="nil"/>
</p>
</div>
</div>
<div id="outline-container-orgf0588de" class="outline-2">
<h2 id="orgf0588de">Exemplos em OCaml</h2>
<div class="outline-text-2" id="text-orgf0588de">
</div>
<div id="outline-container-orgb05b58d" class="outline-3">
<h3 id="orgb05b58d">Darts</h3>
<div class="outline-text-3" id="text-orgb05b58d">
<p>
Essa é a solução do problema <a href="https://exercism.org/tracks/ocaml/exercises/darts">Darts</a>, bem no início da track de OCaml exercism, que podemos
explorar de forma bem pragmática de um uso de <a href="https://ocaml.org/docs/basic-data-types">pattern matching</a>:
</p>

<div class="org-src-container">
<pre class="src src-ocaml"><span style="color: #1e90ff;">let</span> <span style="color: #dddddd;">radius</span> (<span style="color: #dddddd;">x</span>:<span style="color: #acacac;"> float</span>) (<span style="color: #dddddd;">y</span>:<span style="color: #acacac;"> float</span>):<span style="color: #acacac;"> float </span>= sqrt (x *. x +. y *. y)

<span style="color: #1e90ff;">let</span> <span style="color: #dddddd;">score</span> (<span style="color: #dddddd;">x</span>:<span style="color: #acacac;"> float</span>) (<span style="color: #dddddd;">y</span>:<span style="color: #acacac;"> float</span>):<span style="color: #acacac;"> int </span>=
  <span style="color: #1e90ff;">match</span> radius x y <span style="color: #1e90ff;">with</span>
  | r <span style="color: #1e90ff;">when</span> r &lt;= 1.0 -&gt; 10
  | r <span style="color: #1e90ff;">when</span> r &lt;= 5.0 -&gt; 5
  | r <span style="color: #1e90ff;">when</span> r &lt;= 10.0 -&gt; 1
  | _ -&gt; 0
</pre>
</div>
</div>
</div>
<div id="outline-container-orgdbc57d2" class="outline-3">
<h3 id="orgdbc57d2">perfect numbers</h3>
<div class="outline-text-3" id="text-orgdbc57d2">
<p>
Esse é outro exemplo, <a href="https://exercism.org/tracks/ocaml/exercises/perfect-numbers">detecção de números perfeitos</a>. É exemplo um
pouco mais rebuscado que o anterior, para realizar a classificação de
Nicomachus que categoriza um número em relação a soma dos seus
divisores. Um número qualquer pode ser classificados em três
categorias baseado na soma de seus divisores (excluindo ele mesmo):
</p>

<ul class="org-ul">
<li>perfect: soma dos divisores igual ao próprio número</li>
<li>abundant: soma dos divisores maior que o próprio número</li>
<li>diefficient: soma dos divisores menor que o próprio número</li>
</ul>

<div class="org-src-container">
<pre class="src src-ocaml"><span style="color: #1e90ff;">let</span> <span style="color: #1e90ff;">rec</span> <span style="color: #dddddd;">range</span> <span style="color: #dddddd;">a</span> <span style="color: #dddddd;">b</span> =
  <span style="color: #1e90ff;">if</span> a &gt; b <span style="color: #1e90ff;">then</span> <span style="color: #acacac;">[]</span>
  <span style="color: #1e90ff;">else</span> a <span style="color: #acacac;">::</span> range (a + 1) b

<span style="color: #1e90ff;">let</span> <span style="color: #dddddd;">divisors</span> <span style="color: #dddddd;">n</span> =
  range 1 (truncate (sqrt (float n)))
  <span style="color: #1e90ff;">|&gt;</span> <span style="color: #acacac;">List.</span>filter (<span style="color: #1e90ff;">fun</span> <span style="color: #dddddd;">d</span> -&gt; n <span style="color: #1e90ff;">mod</span> d = 0)
  <span style="color: #1e90ff;">|&gt;</span> <span style="color: #acacac;">List.</span>map (<span style="color: #1e90ff;">fun</span> <span style="color: #dddddd;">x</span> -&gt; [x; n / x])
  <span style="color: #1e90ff;">|&gt;</span> <span style="color: #acacac;">List.</span>flatten
  <span style="color: #1e90ff;">|&gt;</span> <span style="color: #acacac;">List.</span>filter (<span style="color: #1e90ff;">fun</span> <span style="color: #dddddd;">x</span> -&gt; x <span style="color: #1e90ff;">!=</span> n)
  <span style="color: #1e90ff;">|&gt;</span> <span style="color: #acacac;">List.</span>sort_uniq compare

<span style="color: #1e90ff;">let</span> <span style="color: #dddddd;">sum</span> <span style="color: #dddddd;">l</span> = <span style="color: #acacac;">List.</span>fold_left (<span style="color: #dddddd;">+</span>) 0 l
<span style="color: #1e90ff;">let</span> <span style="color: #dddddd;">number_class</span> <span style="color: #dddddd;">n</span> = <span style="color: #1e90ff;">match</span> sum (divisors n) <span style="color: #1e90ff;">with</span>
  | k <span style="color: #1e90ff;">when</span> k &lt; n -&gt; <span style="color: #acacac;">"deficient"</span>
  | k <span style="color: #1e90ff;">when</span> k &gt; n -&gt; <span style="color: #acacac;">"abundant"</span>
  | _ -&gt; <span style="color: #acacac;">"perfect"</span>

<span style="color: #1e90ff;">let</span> <span style="color: #dddddd;">classify</span> <span style="color: #dddddd;">n</span> =
  <span style="color: #1e90ff;">if</span> n &gt; 0 <span style="color: #1e90ff;">then</span>
    (<span style="color: #acacac;">Ok</span> (number_class n))
  <span style="color: #1e90ff;">else</span>
    (<span style="color: #acacac;">Error</span> <span style="color: #acacac;">"Classification is only possible for positive integers."</span>)
</pre>
</div>

<p>
Nesse exemplo já é possível observar aplicações de outros conceitos e
funcionalidades, como o uso do operador <code>|&gt;</code> pipeline e também operações
com listas. Para minha surpresa, não encontrei em OCaml uma função
genérica para gerar um range de inteiros <code>[a, b)</code>. Nesse exemplo
particular, implemento um gerador de range de inteiros fechado nas
duas pontas <code>[a ,b]</code> de forma relativamente simples. Sum também não
tinha definido, mas é um caso trivial como pode ser visto acima.
</p>
</div>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="programming" /><category term="programming" /><summary type="html"><![CDATA[Programação funcional pragmática]]></summary></entry><entry><title type="html">Common Lisp Brasil</title><link href="https://lerax.me/programming/common-lisp-brasil/" rel="alternate" type="text/html" title="Common Lisp Brasil" /><published>2025-07-20T01:11:00+00:00</published><updated>2025-07-20T01:11:00+00:00</updated><id>https://lerax.me/programming/common-lisp-brasil</id><content type="html" xml:base="https://lerax.me/programming/common-lisp-brasil/"><![CDATA[<div id="outline-container-org23929a5" class="outline-2">
<h2 id="org23929a5">O início de tudo</h2>
<div class="outline-text-2" id="text-org23929a5">
<p>
Este post deve contar parte da história sobre o <a href="https://lisp.com.br">https://lisp.com.br</a>,
conhecido também como a comunidade de Common Lisp do Brasil, por assim
dizer. Eu já deveria ter escrito sobre isso há algunos anos, mas
sempre ficava adiando. Vamos lá! Talvez a primeira versão desse post
fique incompleta.
</p>

<p>
Esse projeto começou em 2018 após uma conversa informal no grupo do
Telegram <a href="https://t.me/rustlangbr/46741">Rust Brasil</a> <sup><a id="fnr.1" class="footref" href="#fn.1" role="doc-backlink">1</a></sup>, em que trocando ideias sobre o quão o
macro <a href="https://lispcookbook.github.io/cl-cookbook/iteration.html#the-loop-macro-built-in">LOOP</a> de CL era <a href="https://gist.github.com/ryukinix/6823eb9219a7f240588cadf41457b521">maluco</a>, eu cheguei a mencionar que entendia a
maioria das coisas do macro loop entre outras coisas, e citei o livro
<a href="http://landoflisp.com/">Land of Lisp</a> onde aprendi boa parte das coisas há um ano
(2017). Eventualmente conversamos sobre como a Naughty Dog inseriu um
compilador de Lisp chamado <a href="https://all-things-andy-gavin.com/2011/02/02/making-crash-bandicoot-part-1/">GOAL</a> (que eles mesmo inventaram) em jogos
como Crash Bandicoot.
</p>

<p>
Essa pessoa com quem conversava era <a href="https://luksamuk.codes/">Lucas Vieira</a> e aquela breve conversa
fez nos aproximar e conversar sobre o quão difícil era encontrar
pessoas que também estavam interessadas em Lisp, ou Common Lisp em
especial.
</p>

<p>
A partir daí&#x2026; existem alguns detalhes, mas resumidamente, decidimos
criar um grupo no Telegram pra concentrar essa interação nova que
estavamos propondo: um lugar especial pra falar sobre Lisp! Dessa
maneira, eu e o Lucas somos os criadores da comunidade de CL no
Brasil, e obviamente muitas pessoas ao longo do tempo fizeram
contribuições e ajudaram nesse processo, que levaria um tempo para
citar todos aqui.
</p>
</div>
</div>

<div id="outline-container-org675675f" class="outline-2">
<h2 id="org675675f">lisp.com.br</h2>
<div class="outline-text-2" id="text-org675675f">
<p>
Eventualmente, escrevemos o site usando org-mode para termos uma
página principal da comunidade, que é literalmente toda escrita em org
e usa o emacs pra compilar pra HTML.
</p>

<p>
Em determinado momento, um membro do grupo novo que era fã de Lisp há
décadas chamado Hélio Cordeiro se ofereceu para conceder o domínio
<a href="https://lisp.com.br">https://lisp.com.br</a> para nós. Ele havia comprado há muitos anos esse
dominio e o mantinha esperando algo grande acontecer.
</p>

<p>
Desde então, mantemos esse domínio memorável como nosso principal
ponto de contato.
</p>

<p>
Fomos ao ar pela primeira vez num sábado, 02 de fevereiro de 2018.
</p>
</div>
</div>


<div id="outline-container-org33691ee" class="outline-2">
<h2 id="org33691ee">Projetos</h2>
<div class="outline-text-2" id="text-org33691ee">
<p>
Somos uma comunidade com picos de atividade muito sazonais, mas também
sofremos hiatos de tempos em tempos também. Entre os projetos que
temos, eis uma lista não-exaustiva:
</p>

<ul class="org-ul">
<li><a href="https://github.com/commonlispbr/quicksys">quicksys</a> <sup><a id="fnr.2" class="footref" href="#fn.2" role="doc-backlink">2</a></sup>- um projeto para facilitar o gerenciamento de pacotes com
múltiplas distribuições quicklisp (como ultralisp, borodust,
shirakumo etc);</li>
<li><a href="https://github.com/commonlispbr/docker-roswell">docker-roswell</a> - imagem docker com roswell instalado;</li>
<li><a href="https://github.com/commonlispbr/docker-reblocks">docker-reblocks</a> - imagem com o framework reblocks + roswell para
desenvolvimento de aplicações web, como <a href="https://logic.manoel.dev">https://logic.manoel.dev</a>;</li>
<li><a href="https://github.com/commonlispbr/stickers">stickers</a> - um repositório com stickers personalizados sobre Lisp que usamos no
telegram;</li>
<li><a href="https://github.com/commonlispbr/troll-shield">troll-shield</a> - um mecanismo de defesa criado em 2020 para impedir
que os trolls destruíssem nossa comunidade (um bot expulsador de
gente escrito em Go);</li>
<li><a href="https://github.com/commonlispbr/starwar">starwar</a> - um port/fork de um joginho de dominação de planetas escrito em
Common Lisp que particularmente sempre gostei muito;</li>
<li><a href="https://lisp.com.br/cl-cookbook">lisp.com.br/cl-cookbook</a> - a tradução do cl-cookbook pra português,
mas está boa parte incompleto.</li>
</ul>
</div>
</div>

<div id="outline-container-org089d0bd" class="outline-2">
<h2 id="org089d0bd">Pandemia: a guerra contra os trolls do Império de C++</h2>
<div class="outline-text-2" id="text-org089d0bd">
<p>
Aqui&#x2026; essa parte vou omitir por enquanto, que está parcialmente
descrita em <a href="https://lisp.com.br/rules.html">https://lisp.com.br/rules.html</a>. Em outro momento entro
em detalhes.
</p>
</div>
</div>
<div id="footnotes">
<h2 class="footnotes">Footnotes: </h2>
<div id="text-footnotes">

<div class="footdef"><sup><a id="fn.1" class="footnum" href="#fnr.1" role="doc-backlink">1</a></sup> <div class="footpara" role="doc-footnote"><p class="footpara">
a propósito, Rust não é uma das minhas linguagens favoritas
não, estudei Rust em 2017 criando o toy project <a href="https://github.com/ryukinix/conway-rs">conway-rs</a>, mas perdi o
interesse com o tempo por motivos que esse espaço de nota de rodapé é
muito pequeno pra conter.
</p></div></div>

<div class="footdef"><sup><a id="fn.2" class="footnum" href="#fnr.2" role="doc-backlink">2</a></sup> <div class="footpara" role="doc-footnote"><p class="footpara">
Então, até tentamos inserir o quicksys no quicklisp, mas acabou
virando um grande problema pois não era possível criar pacotes no
quicklisp que dependiam do quicklisp. Na verdade, o projeto se chamava
inicialmente de quicklisp-meta e foi solicitado o renomeamento pelo
criador do quicklisp para não haver confusão de que fosse algo que
eles mantesse&#x2026; Situação um tanto lamentável, fizemos o renomeamento
atoa, já que nem se quer foi aceito no quicklisp (é possível de ser
instalado via ultralisp ou diretamente via roswell). Detalhes em
<a href="https://github.com/quicklisp/quicklisp-projects/issues/1654">quicklisp-projects#1654</a>
</p></div></div>


</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="programming" /><category term="programming" /><category term="lisp" /><summary type="html"><![CDATA[Gerenciando a comunidade de Common Lisp desde 2018]]></summary></entry><entry xml:lang="en"><title type="html">Lisp Inference</title><link href="https://lerax.me/programming/lisp-inference/" rel="alternate" type="text/html" title="Lisp Inference" /><published>2025-07-09T22:26:00+00:00</published><updated>2025-07-09T22:26:00+00:00</updated><id>https://lerax.me/programming/lisp-inference</id><content type="html" xml:base="https://lerax.me/programming/lisp-inference/"><![CDATA[<div id="outline-container-org8cb2cea" class="outline-2">
<h2 id="org8cb2cea">Lisp Inference</h2>
<div class="outline-text-2" id="text-org8cb2cea">
<p>
I've been working on this since 2017. The current web application version is
possible to access through <a href="https://logic.manoel.dev">logic.manoel.dev</a>. The main page looks like
this:
</p>

<p>
<img src="/assets/posts/lisp-inference/lisp-inference.png" alt="nil"/>
</p>

<p>
It's a application written in Common Lisp that is capable to generate
a truth table for logical expressions. The source can be found in my
github profile <a href="https://github.com/ryukinix/lisp-inference/">ryukinix/lisp-inference</a>. It contains as well a <b>share</b>
button so the users can share expressions with its truth table, some
known tautologies are provided as hyperlinks as well.
</p>
</div>
</div>

<div id="outline-container-orgefee905" class="outline-2">
<h2 id="orgefee905">Prologue</h2>
<div class="outline-text-2" id="text-orgefee905">
<p>
The initial system was designed to be a propositional calculus
checker, in the sense of:
</p>

<pre class="example" id="org48711a4">
Given a set of K premises, show how we can deduce this conclusion C.
</pre>

<p>
This was requested as an engineering task in my computer engineering
graduation in 2014, during the first period. Funny, what did the
professor think when requesting something like this for the students
in the first year? The outcome was not good, as anyone could probably
imagine. The project was designed to be split in such a way that part
of the classroom was doing X, Y, Z&#x2026; and in the end, the small parts
would be glued together to form a "Propositional Calculator."
</p>

<p>
Well, this professor talked about Lisp to us, but what everyone had
started to learn basically two months ago was programming in C. I'm
not sure, but he really tried to convince us that a header called
<code>&lt;lisp.h&gt;</code> was real and we could use it to process lists using C, using
functions like car and cdr.
</p>

<p>
I'm not sure if the professor was going crazy or if it was just a lie,
but this didn't exist. And most of the students were struggling to
just implement linked lists. The result was a complete disaster; most
of the groups, which were split from A to F, failed completely.
</p>

<p>
To this day, I think this impossible task was aimed at giving students
a real feeling about how hard engineering is, because some weeks
before this, the same professor was teaching us digital electronics,
and after other hard courses (like calculus and physics), someone
said, "Hey, this is easy." I think he took this personally, I'm not
sure. Besides this, he was a great professor teaching digital
electronics.
</p>

<p>
Anyway, since this failure, I had already read about Common Lisp
because of Serial Experiments Lain a year ago (2013). Then, my
interest in this increased even more because Lisp seemed like such an
ALIEN technology, which was fascinating to me.
</p>
</div>
</div>

<div id="outline-container-org0c913b1" class="outline-2">
<h2 id="org0c913b1">Common Lisp? Why?</h2>
<div class="outline-text-2" id="text-org0c913b1">
<p>
Well, most part of the literature I've found abouth proof checkers,
propositional logic and in the classic sense was written in
Lisp. Curiously, most part of the books the professor shared was
doctor thesis or really old books (from 197X).
</p>

<p>
To accomplish the initial task, that actually to see this happening, I
decided to learn Common Lisp properly. Between 2015-2016 I was only
looking superfially how Lisp works, how Emacs works&#x2026; But not having
much time to get into it. In 2017, however, I got a deep dive on it.
</p>

<p>
I started to read <i>Structured and Interpretation of Computer
Programmings</i> (SICP), watched all the youtube course of <a href="https://www.youtube.com/watch?v=2Op3QLzMgSY&amp;list=PLE18841CABEA24090">MIT 6.001 of
1986</a> and read from start to end the book <a href="http://landoflisp.com/">Land of Lisp</a> (very fun to
read, btw). All my notes about this journey of learning is scattered
in some small code and notes in this repository called <a href="https://github.com/ryukinix/lisp-insights">lisp-insights</a>.
</p>

<p>
After thoroughly reading a lot about this and learning Common Lisp
more profoundly, I decided to apply my recently acquired
knowledge. The first project was actually <a href="https://lerax.me/programming/lisp-chat/">Lisp Chat</a>, a fun experience
of managing a chat using raw TCP sockets and being capable of using
even netcat as a client.
</p>

<p>
It's still 2017, three years since 2014, when my previous professor
showed the nightmare of dealing with propositional calculus. In that
year, I started lisp-inference and got some stuff working on
generating truth tables, although this was not exactly the initial
request.
</p>

<p>
To create a real logical proposition checker, I had to implement the
<a href="https://coursys.sfu.ca/2018sp-cmpt-384-d1/pages/Wang">Wang's Algorithm</a>, which was, at that moment, beyond my comprehension
of how I'd deal with it. I even tried to start, dealing with
expression transformation, like simplification, double negation,
equivalences, etc. An automation of human deduction of logical proofs.
</p>

<p>
Since then, I have worked on this project, improving it little by
little each year. It's almost my personal laboratory for Common Lisp.
</p>
</div>
</div>

<div id="outline-container-orgf663244" class="outline-2">
<h2 id="orgf663244">Refactor of Lisp Inference in 2025</h2>
<div class="outline-text-2" id="text-orgf663244">
<p>
I worked on revitilization of this application due being a important
project for me, even without any practical usage. Some things was
really important to deal with, including:
</p>

<ul class="org-ul">
<li><a href="https://github.com/ryukinix/lisp-inference/pull/31">implementing a pratt parser;</a></li>
<li><a href="https://github.com/ryukinix/lisp-inference/pull/35">implement a share button to share truth tables</a>;</li>
<li><a href="https://github.com/ryukinix/lisp-inference/pull/33">change deprecated web framework weblocks to reblocks;</a></li>
<li><a href="https://github.com/ryukinix/lisp-inference/pull/30/files">restylize web application;</a></li>
<li>changed testing framework prove to rove;</li>
<li>add input validator:
<ul class="org-ul">
<li>error handling of invalid expressions;</li>
<li><a href="https://github.com/ryukinix/lisp-inference/pull/42">reject expressions with more than 10 premisses</a>;</li>
</ul></li>
<li><a href="https://github.com/ryukinix/lisp-inference/pull/42">improve dockerfile build time from 8min to 1min</a></li>
<li><a href="https://github.com/ryukinix/lisp-inference/pull/34">ci/cd with new scheme of tests / deploy</a></li>
</ul>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="programming" /><category term="programming" /><category term="mathematics" /><category term="lisp" /><summary type="html"><![CDATA[A Truth Table Generator written in Common Lisp]]></summary></entry><entry><title type="html">Finalmente engenheiro e a nova vida no ITA</title><link href="https://lerax.me/personal/finalmente-engenheiro/" rel="alternate" type="text/html" title="Finalmente engenheiro e a nova vida no ITA" /><published>2024-03-02T20:42:00+00:00</published><updated>2024-03-02T20:42:00+00:00</updated><id>https://lerax.me/personal/finalmente-engenheiro</id><content type="html" xml:base="https://lerax.me/personal/finalmente-engenheiro/"><![CDATA[<div id="outline-container-orgd1d9a36" class="outline-2">
<h2 id="orgd1d9a36">Vida de pré-vestibular (2012-2013)</h2>
<div class="outline-text-2" id="text-orgd1d9a36">
<p>
<img src="/assets/posts/finalmente-engenheiro/me-2012.jpg" alt="nil"/>
</p>

<p>
Tudo começou logo após o término do ensino médio. Naquela época (2012), eu já
trabalhava como técnico em informática e, no mesmo ano, consegui ser
aprovado em um concurso público municipal para atuar na mesma
função. Isso, mesmo possuindo apenas um diploma de um curso
profissionalizante à distância que fiz no Instituto Padre Reus, que
naquela época era realizado por correspondência.
</p>

<p>
Eu era jovem, tinha apenas 18 anos, repleto de sonhos e uma arrogância
natural, fruto da inocência de não compreender o quão vasto é o
mundo. Naquele ano, enquanto frequentava um cursinho pré-vestibular e
me preparava para cursar engenharia da computação em alguma
universidade, conheci o ITA. Fiquei muito interessado na ideia de
passar por uma experiência de confinamento, para me distanciar de tudo
que estava vivendo no Pará, entre problemas familiares e questões que
só viria a entender uma década depois.
</p>

<p>
Naquele ano, nada saiu como planejado. Fui mal no vestibular da UFPA,
no ENEM e tive um desempenho vergonhoso no ITA. Após a prova do ITA,
que naquela época durava quatro dias consecutivos, peguei uma chuva em
Belém que parecia lavar minha alma. Foi um choque de realidade,
perceber a diferença entre o que eu sabia e o que estava sendo
cobrado. Isso foi crucial, pois após essa experiência, passei a levar
meus estudos mais a sério e desenvolvi uma relação muito mais intensa
com a matemática.
</p>

<p>
<img src="/assets/posts/finalmente-engenheiro/me-2013.jpg" alt="nil"/>
</p>

<p>
O ano de 2013 foi bem diferente. Consegui uma bolsa integral no
instituto onde cursava o pré-vestibular, o que facilitou a continuação
dos meus estudos após a sensação de grande fracasso. Naquele ano,
estudei intensivamente, lia vários livros, resolvia questões do ITA
durante o jantar&#x2026; era um ritmo frenético que não sei se conseguiria
manter hoje em dia (ah, a juventude).
</p>

<p>
Apesar da confiança ainda abalada, tive um bom desempenho nos
vestibulares naquele ano, o suficiente para ser aprovado em várias
universidades, incluindo a UFPA, UNIFESSPA, UFC e também consegui uma
bolsa integral pelo ProUni. Infelizmente, não tive coragem para tentar
o ITA novamente, mesmo tendo pago a taxa de inscrição de 120 reais. O
desânimo veio do meu desempenho no ENEM, sem ter ideia de que meses
depois eu seria aprovado.
</p>

<p>
Devido à falta de recursos, decidi cursar Engenharia da Computação na
UFPA, campus de Tucuruí, onde ingressei em 2014.
</p>
</div>
</div>

<div id="outline-container-org4687bcf" class="outline-2">
<h2 id="org4687bcf">10 anos no curso de engenharia da computação (2014-2023)</h2>
<div class="outline-text-2" id="text-org4687bcf">
<p>
<img src="/assets/posts/finalmente-engenheiro/me-2014.jpg" alt="nil"/>
</p>

<p>
Se eu fosse relatar tudo o que aconteceu durante esses dez anos,
poderia escrever um livro. Nos primeiros dois anos, de 2014 a 2016,
cursei engenharia na UFPA. Por motivos pessoais, comecei a sentir que
não me identificava mais com a instituição e que estava no lugar
errado. Assim, em 2016, iniciei o processo de transferência de
instituição e fui aprovado para continuar meu curso de Engenharia da
Computação na UFC, em Sobral.
</p>

<p>
Em Sobral, senti uma conexão mais forte com a instituição e percebi
que estava em um lugar que fazia mais sentido para mim. Lá, consegui
expandir significativamente meu conhecimento e estabelecer boas
relações com professores e outros alunos, apesar de geralmente fazer
poucas amizades.
</p>

<p>
<img src="/assets/posts/finalmente-engenheiro/me-2016.jpg" alt="nil"/>
</p>

<p>
Os primeiros anos em Sobral, de 2016 até o final de 2017, foram
marcados por muitos problemas financeiros, pois havia parado de
trabalhar. Trabalhei em uma empresa de procedência duvidosa de 2015
a 2016. Em 2018, ao ser contratado pela Neoway, empresa na qual
trabalho até hoje (2024), consegui me manter financeiramente em
Sobral.
</p>

<p>
A partir de 2020, com o início da pandemia, minha graduação entrou em
um ciclo terrível de depressão e adversidades. Embora já enfrentasse
problemas antes, o confinamento e meu casamento recente (2019)
pareceram intensificar a crise.
</p>

<p>
<img src="/assets/posts/finalmente-engenheiro/me-2020.jpg" alt="nil"/>
</p>

<p>
Por mais de dois anos, a partir de 2021, fiquei paralisado com meu
projeto de TCC. Uma mistura de ansiedade, que me levou à emergência
pensando que estava tendo um infarto, depressão e outros problemas,
tornaram o tema que escolhi praticamente impossível de desenvolver,
apesar de ter parecido uma boa ideia quando o escolhi em 2021.
</p>

<p>
Após várias reviravoltas, incluindo a obtenção de uma bolsa de
iniciação científica voluntária no ITA em 2020 e quase perder minha
relação com meu orientador na UFC devido à minha incapacidade de
responder seus e-mails, 2023 trouxe uma grande mudança.
</p>

<p>
Em junho de 2023, mesmo ainda estando na gradução, fui aprovado no
programa de mestrado do ITA em Engenharia Eletrônica e Computação com
o mesmo tema do meu TCC &#x2013; <a href="https://github.com/ryukinix/tcc">Segmentação Semi-Supervisionada de Imagens
através de Dinâmicas Coletivas em Redes Complexas</a>. Isso me deu um
novo impulso para finalmente concluir meu TCC. Felizmente, o resultado
foi muito melhor do que eu esperava e a banca examinadora elogiou
bastante o trabalho que passei mais de dois anos pesquisando. No dia
25 de janeiro de 2024, finalmente me formei, totalizando 10 anos na
engenharia desde que fui aprovado na UFPA em 2014.
</p>

<p>
<img src="/assets/posts/finalmente-engenheiro/formatura-2024.jpg" alt="nil"/>
</p>
</div>
</div>


<div id="outline-container-org3ad142a" class="outline-2">
<h2 id="org3ad142a">Mestrado no ITA (2024-)</h2>
<div class="outline-text-2" id="text-org3ad142a">
<p>
Cheguei aqui em São José dos Campos, SP, em fevereiro de 2024. As
minhas primeiras aulas presenciais no ITA começarão no início de
março. Fazer parte do ITA me proporcionou uma imensa alegria, pois era
um sonho que eu tinha há mais de 10 anos e que acreditava estar
perdido. Apesar da pós-graduação ser diferente da graduação, sinto-me
satisfeito por estar avançando na minha carreira acadêmica. Quem sabe,
este passo pode me levar a lugares que, no momento, não consigo nem
imaginar.
</p>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="personal" /><category term="personal" /><summary type="html"><![CDATA[Após 10 anos cursando engenharia e realizando um sonho de estar no ITA]]></summary></entry><entry><title type="html">O Transtorno Bipolar</title><link href="https://lerax.me/personal/transtorno-bipolar/" rel="alternate" type="text/html" title="O Transtorno Bipolar" /><published>2023-06-11T11:03:00+00:00</published><updated>2023-06-11T11:03:00+00:00</updated><id>https://lerax.me/personal/transtorno-bipolar</id><content type="html" xml:base="https://lerax.me/personal/transtorno-bipolar/"><![CDATA[<div id="outline-container-org55378fb" class="outline-2">
<h2 id="org55378fb">Prelúdio</h2>
<div class="outline-text-2" id="text-org55378fb">
<p>
<i><i>TL;DR: Em 2022 fui diagnosticado com Transtorno Bipolar Tipo II, desde então minha vida ganhou uma perspectiva diferente.</i></i>
</p>



<p>
Não sei ao certo como começar esse texto, não é um assunto fácil pra
mim. De certa maneira, durante muitos anos, principalmente após a
separação dos meus pais em 2009, aos meus 15 anos, eu tinha dúvidas de
que eu poderia ser uma pessoa diferente em vários sentidos&#x2026; Mas
especialmente no aspecto de lidar com emoções intensas.
</p>

<p>
Olá! Meu nome é <b><b>Manoel Vilela</b></b>, tenho 29 anos na data de publicação
deste artigo. Fui diagnosticado com <a href="https://pt.wikipedia.org/wiki/Transtorno_bipolar_II">Transtorno Bipolar Tipo II</a>
(T.B. Tipo II) após mais de 12 anos sofrendo com episódios de
depressão profunda de maneira cíclica.
</p>
</div>
</div>

<div id="outline-container-orgb07abf5" class="outline-2">
<h2 id="orgb07abf5">O início e a família</h2>
<div class="outline-text-2" id="text-orgb07abf5">
<p>
Minha primeira depressão ocorreu quando tinha 16 anos, em 2010. Fiquei
recluso por todo esse ano em casa, no último ano do ensino médio com
um turbilhão de sentimentos, onde se misturava a separação dos meus
pais, meu primeiro namoro e uma traição que sofri de um amigo
próximo. Mesmo sendo um aluno aplicado — um ano adiantado na formação
de ensino por ter pulado a segunda série para terceira aos 8 anos
sendo que mal frequentei a terceira a série por conta de problemas
familiares — a depressão não encontrou barreiras pra destruir esse
histórico.
</p>

<p>
Penso até o momento que o Transtorno Bipolar é uma condição psiquiatra
extremamente mal compreendida, começando pelos próprios pacientes em
certas ocasiões. Um transtorno como esse que pode possuir tantas variações
não pode ser caracterizado como um transtorno psiquiátrico fácil de
entender — ao mesmo tempo que possa ser confundido com uma pessoa completamente
normal, é possível também confundir com esquizofrenia (T.B. Tipo I).
</p>

<p>
Cresci toda minha vida rodeado de dramas em relação ao Transtorno
Bipolar por conta do meu pai, que possui T.B. Tipo I. Esse tipo
de transtorno possui várias semelhanças ao tipo II, mas com uma
diferença substancial: a mania. O portador de transtorno bipolar
maníaco-depressivo tipo I possui uma resposta oposta a depressão
chamada mania, onde acontece uma extrema euforia, podendo levar a
agressividade, estresse e até mesmo alucinações.
</p>

<p>
Eu não tenho mania, apenas hipomania, que é uma versão mais branda
desse episódio que acontece exclusivamente com o T.B. tipo I. Na
imagem a seguir é possível observar as transições de humor entre
diferentes transtornos psiquiátricos em relação a uma pessoa comum, a
mania e hipomania é a diferença entre os bipolares tipo I e tipo II.
</p>

<p>
<img src="/assets/posts/transtorno-bipolar/bipolar_mood_shifts.png" alt="nil"/>
</p>


<p>
Durante uma crise de mania, já vi meu pai destruir uma casa inteira
enquanto criança (aos 6 anos de idade) e isso foi devastador pra mim,
por muito tempo tive medo do meu pai e também não compreendia isso
muito bem. Muitos falavam de possessão demoníaca, e honestamente, até
que parecia mesmo&#x2026; Seu tom de voz mudava, sua personalidade, sua
percepção, até mesmo suas memórias&#x2026; E muitas vezes ele se tornava extremamente agressivo,
principalmente com seus familiares.
</p>

<p>
Isso persistiu por muitos anos na minha família, as crises de mania e
depressão que meu pai sofria. E eu, que tinha meus problemas, não
recebia atenção que talvez eu precisasse sobre os traumas que estavam
sendo criados continuamente, e eu escolhi ali a reclusão como meu
protetor, pois eu senti naquele momento que não poderia contar com
ninguém.
</p>
</div>
</div>

<div id="outline-container-org20eed46" class="outline-2">
<h2 id="org20eed46">Entre a adolescência e a vida adulta</h2>
<div class="outline-text-2" id="text-org20eed46">
<p>
O ano de 2010&#x2026; É um ano chave. Como comentei, é o início de muitas coisas na
minha vida, a incluir o alcoolismo juvenil, a primeira traição, a
primeira vez de tantas coisas. Isso foi devastador pra mim de muitas
maneiras. Foi uma experiência muito intensa, que me obrigou a me
afastar de praticamente todas as pessoas que eu conhecia&#x2026; e me
aproximar da música, neste ano foi quando comecei a aprender tocar
violão enquanto faltava as aulas do ensino médio.
</p>

<p>
Na perspectiva de quem possui essa condição, a diferença substancial
de uma pessoa com transtorno bipolar é a resposta as emoções, seja as
boas ou ruins&#x2026; No geral, tudo é muito intenso. Alguns tem a
percepção que bipolares são muito sensíveis, mas não é somente sobre
isso, as emoções perduram por muito mais tempo e isso trás
consequências que nem sempre são tão agradáveis.
</p>

<p>
Meu primeiro episódio de depressão durou cerca de 9 meses.  Isso
ocorreu novamente em anos posteriores, em ciclos de aproximadamente 2
anos&#x2026; 2012, 2014, 2016, 2019, 2021&#x2026;
</p>

<p>
Os ciclos de depressões no geral sempre foram bastante longas (9 meses
em média), e entre esses ciclos, há intervalos de <b>hipomania</b> que podem
parecer uma ressuscitação emocional de tão agressiva que pode ser,
afinal nesse momento tudo parecia ser novo, e eu com toda essa energia
de renovação fiz muitas coisas&#x2026; Seja na faculdade, no aprendizado
individual com a música e outras coisas&#x2026; Isso é tão forte, que
pessoas próximas, principalmente em relacionamentos, já pensaram que
eu tivesse dupla personalidade, e brincavam com meus nomes tentando
separar as identidades (Manoel, Neto&#x2026;). A hipomania é tão
revitalizante após a depressão, que te mexe com sua percepção de
auto-resistência, tornando uma espécie de super homem na sua auto
imagem. Essa criação de uma distorção da percepção de si mesmo nesse período é comum,
podendo também gerar até mesmo crises de <a href="https://pt.wikipedia.org/wiki/Megalomania">megalomania</a> (como um gatinho que olha pro
espelho e vê um leão).
</p>

<p>
Esse combustível da hipomania te deixa imparável, tira os limites do
cansaço e da distração, é possível aguentar longas exposições de
esforço físico e mental, entre várias horas e dias, como também a
baixa necessidade de sono (mesmo dormindo entre 3 a 4h diárias, ainda
é possível se manter sem sinais de cansaço por VÁRIOS DIAS).
</p>

<p>
Mas existe um problema, a hipomania além de ser breve, ela costuma ter
lados negativos também, em algumas situações muito negativas. Pressa na fala,
irritabilidade, agressividade, dificuldade de sentir empatia. Isso
pode ser devastador num relacionamento ou no trabalho
profissional. Além do mais, por estar operando acima da sua capacidade
cognitiva normal, a chance disso provocar uma exaustão emocional e
mental se não for gerida é imensa, sendo um gatilho eventual para depressão (e
assim perpetuando a dinâmica oscilatória malévola: a transição
maníaca-depressiva).
</p>
</div>
</div>

<div id="outline-container-org49916ad" class="outline-2">
<h2 id="org49916ad">Suicídio</h2>
<div class="outline-text-2" id="text-org49916ad">
<p>
Há uma preocupação grave com o transtorno bipolar não tratado, pois é
a doença de transtorno de personalidade maior causadora de suicídios,
sendo que 30% a 50% dos portadores tentam o suicídio <sup><a id="fnr.1" class="footref" href="#fn.1" role="doc-backlink">1</a></sup>, 20% conseguem e
o T.B. II é ainda pior nesse sentido, pois os ciclos de depressão
costumam ser maiores, e também mais reincidentes. Pesquisador alerta
sobre transtorno bipolar e comportamento suicida na
adolescência (<a href="https://portal.fiocruz.br/noticia/pesquisador-alerta-sobre-transtorno-bipolar-e-comportamento-suicida-na-adolescencia">Fiocruz</a>, 2022).
</p>

<p>
<img src="/assets/posts/transtorno-bipolar/suicidio_bipolaridade.jpg" alt="nil"/>
</p>

<p>
É um tema recorrente que passa pela mente do bipolar, mais agravante
em períodos depressivos, coisas que já sofri muitas vezes, e o apoio
da família e amigos nessa etapa é fundamental. Em outro momento talvez
possa contar sobre um episódio crítico pessoal sobre esse tema.
</p>
</div>
</div>

<div id="outline-container-orgd97de6d" class="outline-2">
<h2 id="orgd97de6d">Relacionamentos e o Bipolar</h2>
<div class="outline-text-2" id="text-orgd97de6d">
<p>
<a href="https://psiquiatriapaulista.com.br/meu-companheiro-e-bipolar"><i>Ele é bipolar&#x2026; e agora?</i></a>
</p>

<p>
Eu tive poucos relacionamentos na minha vida, e sempre o Transtorno
Bipolar, esteve presente como um ator de conflito mesmo que eu não
soubesse da sua existência.
</p>

<p>
Há muitos anos estou no mesmo relacionamento (minha atual querida
esposa), mas nem por isso, esse relacionamento é imune aos males do
transtorno. Pelo contrário, é uma batalha constante para ambos aqueles
que participam da relação onde há o bipolar.
</p>

<p>
Dou mérito a minha <b><b>esposa</b></b>, por mais que na minha completa descrença, e
com minha grande relutância, insistiu que eu buscasse ajuda profissional.
</p>

<p>
Não dá pra saber o que vai acontecer no futuro a partir daqui, mas o
processo de diagnóstico foi essencial para salvar minha vida e também meu
casamento que caminhava ao abismo.
</p>

<p>
Em 2022, além de ter passado por um problema de saúde familiar grave
com minha mãe, tive um <i><i>burnout</i></i> severo no trabalho por conta de
incompetência alheia, que prefiro nesse artigo não dar detalhes pra
perder o foco.
</p>

<p>
Além de estar num episódio de depressão, <i><i>burnout</i></i> no trabalho, infeliz
na vida pessoal, infeliz no casamento, os investimentos em colapso e
todas minhas economias derretendo, perdi uma das essências que mais me
motivava continuar: meus estudos.
</p>

<p>
Em 2021 entrei em exaustão profunda e não consegui dar continuidade
nem na bolsa de pesquisa que ganhei no <a href="https://pt.wikipedia.org/wiki/Instituto_Tecnol%C3%B3gico_de_Aeron%C3%A1utica">ITA</a>, nem finalizar minha
graduação que apenas faltava o trabalho de conclusão de concurso. Isso
foi um veneno extremamente poderoso pra minha alma.
</p>

<p>
Até hoje sinto ainda estar em recuperação disso tudo, pois não é
apenas uma questão de medicação pra restabelecer o equilíbrio
físico-químico do meu cérebro que é deficiente por natureza, mas
também&#x2026; Aceitar a condição psiquiatra que possuo e aprender a
conviver com os traumas que fui adquirindo com cada fase da minha vida.
</p>

<p>
Não sou uma pessoa aberta, sou bastante recluso, anti social e tenho
poucos amigos. E mesmo entre esses poucos amigos, em episódios de crise é
praticamente impossível eu me comunicar de maneira efetiva. No pico da
depressão, eu perco a comunicação
total. E quem mais sofre, além de mim, é quem está perto de mim.
</p>

<p>
Por esses motivos, a única sensação que sobra é a de isolamento. E de
certa maneira, isso não mudou muito, mesmo com a medicação.
</p>

<p>
A vontade de isolamento persiste. E isso torna um relacionamento
saudável, seja amoroso, profissional, ou de amizade, extremamente
difícil.
</p>

<p>
<a href="https://www.youtube.com/watch?v=PtUkKMCvLHc">Van Gogh e o Transtorno Bipolar - É mais fácil amar ao longe.</a>
</p>
</div>
</div>

<div id="outline-container-org8795ce9" class="outline-2">
<h2 id="org8795ce9">Referências</h2>
<div class="outline-text-2" id="text-org8795ce9">
<p>
Estudar sobre o transtorno bipolar me fez aumentar meu nível de
aceitação e também entendimento sobre os gatilhos que podem fazer eu sair da
zona de estabilidade.
</p>

<p>
Uma monografia em particular de Maria F. F. Mota como estudo de caso
do transtorno bipolar para conclusão de curso de Psicologia (2005,
UniCEUB) é bastante elucidativo:
</p>

<p>
<a href="https://repositorio.uniceub.br/jspui/bitstream/123456789/3053/2/20059837.pdf">MEU DEUS, POR QUE EU FIZ ISTO?</a>.
</p>

<p>
Para quem quiser explorar as características clínicas para diagnóstico
do transtorno bipolar tipo 2, é possível consultar no <i><i>Manual
Diagnóstico e Estatístico de Transtornos Mentais</i></i>. Para facilitar o
processo de busca vou deixar um link da quinta edição numa página
hospedada gentilmente pelo Psiquiatra Gustavo Amadera (CRM-SP
117.682):
</p>

<p>
<a href="https://kiai.med.br/transtorno-bipolar-tipo-2-criterios-diagnosticos-dsm-5/">Transtorno Bipolar Tipo 2 Critérios Diagnósticos DSM-5</a>
</p>
</div>
</div>

<div id="outline-container-orgd6eb3f5" class="outline-2">
<h2 id="orgd6eb3f5">Esperança?</h2>
<div class="outline-text-2" id="text-orgd6eb3f5">
<p>
Em tratamento. Apenas deixo um recado pra quem se identificar: confie
no seu psiquiatra e no tratamento. As medicações não são seus inimigos
nem mudam quem você é realmente.
</p>

<p>
<i><i>To be continued</i></i>.
</p>
</div>
</div>
<div id="footnotes">
<h2 class="footnotes">Footnotes: </h2>
<div id="text-footnotes">

<div class="footdef"><sup><a id="fn.1" class="footnum" href="#fnr.1" role="doc-backlink">1</a></sup> <div class="footpara" role="doc-footnote"><p class="footpara">
<a href="https://drauziovarella.uol.com.br/psiquiatria/transtorno-bipolar-e-a-doenca-que-mais-causa-suicidios/">Transtorno bipolar é a doença que mais causa suicídios</a>
</p></div></div>


</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="personal" /><category term="personal" /><summary type="html"><![CDATA[Uma vida confusa, emocionalmente intensa e com muitos traumas]]></summary></entry><entry><title type="html">J. Karamazov</title><link href="https://lerax.me/personal/karamazov/" rel="alternate" type="text/html" title="J. Karamazov" /><published>2021-02-19T02:21:00+00:00</published><updated>2021-02-19T02:21:00+00:00</updated><id>https://lerax.me/personal/karamazov</id><content type="html" xml:base="https://lerax.me/personal/karamazov/"><![CDATA[<p>
<i>Atenção: este é um conto de ficção, qualquer similaridade com a
realidade é mera coincidência.</i>
</p>

<div id="outline-container-orgd9cc167" class="outline-2">
<h2 id="orgd9cc167">Prefácio</h2>
<div class="outline-text-2" id="text-orgd9cc167">
<p>
<span class="timestamp-wrapper"><span class="timestamp">&lt;2021-02-19 Fri&gt;</span></span>
</p>

<p>
Estamos em 202X. Já perdemos a conta sobre o número de <i>lockdowns</i>
sequenciais. No mundo existe guerra política, ouve-se mentiras e
histórias mal contadas nos meios de comunicação o tempo todo que são
eventualmente desmascaradas ao longo de poucos dias. Todo ano que se
passa, pontualmente, há uma variação do coronavírus que aparece no
final do ano e explode no início do próximo ano.
</p>

<p>
Suponha o seguinte: a pandemia COVID-19 é um plano mundial pra coleta
de informações das mais variadas áreas da humanidade. Todos estes
acontecimentos foram planejados para que ocorresse uma revolução
digital de vez com os programados <i>lockdowns</i>, principalmente nas
universidades e no mercado industrial. Desse jeito, uma amostra do
conhecimento do mundo muito maior que a anterior é feita.
</p>

<p>
Eles fizeram o problema, então ofereceram a solução. A coleta de dados é
feita através de ferramentas digitais, como <i>Google Meet</i> e
Zoom. Ferramentas usadas para dar aulas em universidades e reuniões
empresariais, do qual foram recomendadas via parcerias gratuitas com
mérito de caridade em momento de epidemia global, mas há uma cláusula:
uma porcentagem mínima de usuários da instituição adotada deve gravar o
conteúdo das conferências.
</p>

<p>
Por exemplo, a gravação no <i>Google Meet</i> é armazenada no <i>Google
Drive</i>. Através de um tratado oculto, planejado desde 201Y, a China e
outros governadores mundiais tem acesso direto aos dados provisionados
de armazenamento em <i>cloud</i>&#x2026; Portanto, possuem acesso a toda base de
conhecimento do mundo. Como existe já I.A. suficientemente
especialista com reconhecimento de voz e imagens, é possível fazer uma
busca tremenda num mar novo de informações.
</p>

<p>
Dessa maneira, o Google, e os outros sistemas mundiais de busca, tem a
maior biblioteca antecipada do estado da arte da ciência, engenharia,
produtos e negócios. Pois eles tem acesso a toda informação catalogada
automaticamente por inteligência computacional, com busca avançada e
tudo mais que tem direito do novo milênio. E o pior: com acesso ao
conhecimento de todo global, no ponto de produção, em tempo real!
Imagine&#x2026; o conceito de privacidade é abolido, algo do passado a ser
sonhado por muitos. Quem acredita na possibilidade de privacidade
nessa época são revolucionários desse sistema de vigilância opressor.
</p>

<p>
Essa seria chamada&#x2026; a espionagem suprema, uma versão de 1984 global,
a pandemia da espionagem. Ao considerar isto, devo apresentar o
professor e um dos protagonistas dessa história, Doutor J. Karamazov,
uma grande referência da ciência da computação, que sabiamente decide
não gravar suas aulas pois conhece a verdade. Por outro lado, ele não
conta isto a ninguém, muito menos a seus alunos. J. Karamazov é um
herói indireto dessa história, destinado a revelar a todos a corrupção
desse sistema&#x2026; mesmo sem dizer nenhuma palavra direta a respeito.
</p>
</div>
</div>

<div id="outline-container-orgdd3cbe9" class="outline-2">
<h2 id="orgdd3cbe9">Capítulo I: Doutor J. Karamazov e seus alunos</h2>
<div class="outline-text-2" id="text-orgdd3cbe9">
<p>
Professor J. Karamazov sempre foi um professor muito atencioso,
devidamente cauteloso no que fala e bastante didático. Nas variadas
disciplinas que ministrava, sempre foi muito exigente com o nível de
aprendizado dos seus alunos e também com uma empatia anormal sobre o
entendimento real dos alunos. Por outro lado, por esperar tanto dos
seus alunos, facilmente se decepcionava.
</p>

<p>
De maneira recorrente, o professor questionava se o que falava aos
seus alunos fazia sentido, e apenas era necessário um silêncio
estranho da turma para ouvir coisas do tipo: "Esse silêncio não é
bom. Ou vocês estão entendendo tudo e estão entendiados, ou eu não
estou me fazendo entender [&#x2026;] melhor eu clarificar, pois é normal
não entender imediatamente, o aprendizado nasce do confronto". Com
sua grande empatia ao aprendizado dos alunos, até aqueles mais tímidos
que havia desistido de interagir pela opressão de outros professores
arrogantes, tomava então coragem para fazer perguntas e pedir mais
explicações de Karamazov. A aula era bastante fluída e
definitivamente uma das aulas mais legais do semestre, pois sempre
havia espaço pra questionamento e aquilo dava uma verdadeira sensação
de liberdade de pensamento &#x2013; como uma universidade deve ser.
</p>

<p>
Entre os vários professores do corpo docente de computação,
J. Karamazov era de longe um dos mais respeitados por outros colegas e
principalmente seus alunos. Além do domínio exemplar sobre computação
e inteligência artificial, era uma pessoa muito humilde e sincera,
entretanto com aparente muitos segredos sobre sua vida pessoal, que a
deixava totalmente reservada da sua atuação profissional. Ah, mas sei
de algo pessoal, J. Karamazov era fã dos cientistas e escritores
russos, especialmente o escritor Fiódor Dostoiévski. Ele até me
apresentou um dia a última e maior obra desse autor numa feirinha de
livro da universidade! E, óbvio, não pude resistir a sugestão e mesmo
sem tempo pra ler eu comprei a única cópia que tinha &#x2013; algum tempo
depois me bateu uma leve culpa, pois este livro era prometido para um
professor de filosofia de outra universidade e eu mesmo depois de anos
ainda não terminei de ler toda a obra.
</p>

<p>
Para J. Karamazov o distanciamento social na universidade por conta da
pandemiaera terrível, pois como ele era um professor muito atencioso
que percebia o desentendimento apenas olhando para os rostos dos seus
alunos, esse professor teve uma enorme dificuldade pra manter as aulas
via conferências digitais. Afinal&#x2026; quase nenhum aluno tinha a
ousadia de ligar a câmera e provar que estavam focados, prestando
atenção na aula, pois muitos estavam na verdade fazendo outra coisa
enquanto fingiam estar assistindo aula.
</p>

<p>
Depois dos primeiros anos, apesar de ir quase a loucura, Dr. Karamazov
finalmente conformou-se com a condição de talvez nunca mais dar aula
ao vivo para todos seus alunos em sala de aula. A universidade estava
propondo como regimento oficial o ensino híbrido: parte presencial,
parte remota. Muitos alunos preferiram continuar com as aulas remotas
por muitas questões pessoais e financeiras, portanto, o professor
precisava continuar usando as ferramentas digitais para aula de todo
jeito. Uma delas era o Google Meet.
</p>

<p>
Mas algo o incomodava&#x2026; este professor não permitia em hipótese
alguma a gravação de suas aulas, uma vez questionado sobre o motivo
disse apenas que evitava a gravação para valorizar a sua aula e a
atenção: "Se vocês não prestarem atenção agora, não haverá segunda
chance, você ouvirá tudo isso apenas uma vez e é agora. Prestem
atenção.".
</p>

<p>
Em contrapartida, havia um motivo medonho por trás dessa decisão&#x2026; um aluno em
especial, M. Laurent, desconfiava e defendia uma hipótese estranha com
unhas e dentes, mas era considerado por muitos outros alunos como um lunático,
embora fosse um aluno respeitado por J. Karamazov. M. Laurent&#x2026; era
literalmente pirado. Frequentava suas aulas de forma assídua e
fazia grandes questionamentos pertinentes aos seus ensinamentos,
conseguia gabaritar provas nas disciplinas mais difíceis com
J. Karamazov, mas eventualmente tomava umas bombas tão grandes e
ridículas que um dia teve que ouvir coisas de seu professor como: "Eu
esperava mais de você, M. Laurent.". Isso era de cortar o coração de
M. Laurent, mas ele sabia que estava errado e que deveria ao menos ter
lido o conteúdo da prova invés de ter ficado livros sobre matemática
pura que não tinha nada a ver com a disciplina.
</p>

<p>
E esta era a maneira de J. Karamazov educar seus alunos: "Vocês, meus
alunos, podem e devem ser muito mais.". Penso que o professor poderia
imaginar algo assim ao repreender seus alunos com a mão da decepção
invés de o punho da arrogância.
</p>
</div>
</div>

<div id="outline-container-org446a210" class="outline-2">
<h2 id="org446a210">Capítulo 2: A Grande Conspiração de Laurent durante a Pandemia</h2>
<div class="outline-text-2" id="text-org446a210">
<p>
To be continued&#x2026;
</p>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="personal" /><category term="personal," /><category term="history" /><summary type="html"><![CDATA[A Pandemia da Espionagem]]></summary></entry><entry><title type="html">Experiência acima da opinião - atenção, silêncio e transformação</title><link href="https://lerax.me/personal/experiencia-acima-da-opiniao/" rel="alternate" type="text/html" title="Experiência acima da opinião - atenção, silêncio e transformação" /><published>2021-01-21T00:00:00+00:00</published><updated>2021-01-21T00:00:00+00:00</updated><id>https://lerax.me/personal/experiencia-acima-da-opiniao</id><content type="html" xml:base="https://lerax.me/personal/experiencia-acima-da-opiniao/"><![CDATA[<div id="outline-container-org7e9db4b" class="outline-2">
<h2 id="org7e9db4b">Opinião, perspectiva e verdade</h2>
<div class="outline-text-2" id="text-org7e9db4b">

<div class="figure">
<p><img src="/assets/posts/experiencia-acima-da-opiniao/provocacao-1.png" alt="provocacao-1.png" />
</p>
<p><span class="figure-number">Figure 1: </span>Fonte Desconhecida</p>
</div>


<p>
<b>Opinião</b>. O que é opinião? Pela etimologia, é possível reconhecer que
essa palavra deriva-se do termo Latim `opinari`, sinônimo de pensar e
acreditar. Popularmente, opinião é a visão de mundo de uma pessoa
sobre um determinado assunto, mas na filosofia de Parmênides o caminho
da opinião (<i>doxa</i>) estaria baseado na aparência, como uma ideia
imprecisa acerca da realidade a ponto de levar ao engano e
incertezas. A opinião se opõe à verdade. Dessa maneira, opinião não se
trata sobre fatos &#x2013; afirmações verdadeiras &#x2013; mas perspectivas orientadas
a um determinado assunto.
</p>

<p>
Quando ocorre o desferimento de uma frase como <i>"Essa é minha opinião,
FIM."</i>, algo recorrente na atualidade política e social, isso
demonstra um fechamento sobre a busca da verdade quanto àquele
assunto. Mas ora, o que é a verdade? Refiro-me nesse momento a verdade
da razão, como Leibniz a define. A verdade é um estado de supremo
conhecimento e irrevogável quanto a um acontecimento. Algo só pode ser
verdade quando não há qualquer dúvida sobre tal assunto, como os
teoremas na matemática, um sistema idealizado e bem comportado.
</p>

<p>
Pergunto, portanto, será que na nossa realidade existem verdades? É
questionável, pois, se não é permitido algo verdadeiro conter qualquer
dúvida sequer, eu poderia dizer que há poucas verdades no mundo, ou
talvez nenhuma. Ao tomar como exemplo o céu azul, o que inocentemente
parece ser uma verdade, pode não ser. Nós como humanos enxergamos o
céu com essa coloração dita <i>azul</i> pois a declaramos dessa maneira
pela nossa visão. Mas não significa que para os outros animais, ou até
mesmo outros humanos, o céu seja de fato azul. Enxergar o céu azul é
uma perspectiva. Desta maneira, percebe-se que a verdade é um ideal a
ser buscado, e a opinião é uma ilusão.
</p>
</div>
</div>


<div id="outline-container-orgc883b89" class="outline-2">
<h2 id="orgc883b89">Consumismo e Escapismo contra a Experiência</h2>
<div class="outline-text-2" id="text-orgc883b89">

<div class="figure">
<p><img src="/assets/posts/experiencia-acima-da-opiniao/provocacao-2.png" alt="provocacao-2.png" />
</p>
<p><span class="figure-number">Figure 2: </span>Tirinha <i>os Malvados</i> por André Dahmer</p>
</div>

<p>
Durante nossas vidas cotidianas consumimos muitas coisas. Passamos a
vida consumindo, todos dias notícias, drogas, músicas, emoções, livros
e até mesmo o ar que respiramos. O que reflete meu ser senão aquilo
que eu consumo todos dias? Desde meu alimento, o que leio, o que
estudo, o que me distrai. O consumo me consome como ser, consome meu
tempo e meu estar, a distração atrapalha meu foco e minha atenção ao
que está ao redor. Porque sentimos necessidade de tanto consumir e
nos distrair? O sofrimento não é fácil de gerenciar, muito menos
confrontar, muitas vezes é mais simples buscar o conforto na fuga. Mas
será esse o caminho para aproveitarmos a <b>experiência</b> em vida?
</p>

<p>
O consumo na indústria do entretenimento é uma fuga das emoções
externas e internas que abalam a nossa alma; seja uma música que
incita o alcoolismo e o apelo sexual, um livro de autoajuda cheio de
métodos vãos para a busca da verdade, um jogo de videogame cheio de
violência pra extravasar sua raiva. Dito isto, pergunto: O que estamos
fazendo nessa vida breve e finita?
</p>

<p>
A fuga nos afasta da experiência, do confronto, das emoções reais que
sentimos. O consumismo consome nosso tempo e nossa mente, como um
artifício em ilusão de repor o que perdemos, para acalmar nossa dor,
um remédio pra postergar o confronto. Se o que há de mais valioso
nessa vida é a experiência, porque deveríamos perder tanto tempo com
tantas coisas vazias e sem valor?
</p>

<p>
O reconhecimento do que significa experiência é necessário. O autor
J. L. Bondia no artigo intitulado `Notas sobre a experiência e o saber da
experiência' defende: "A experiência é o que nos passa, o que nos
acontece, o que nos toca. Não o que se passa, não o que acontece, ou o
que toca. A cada dia se passam muitas coisas, porém, ao mesmo tempo,
quase nada nos acontece. Dir-se-ia que tudo o que se passa está
organizado para que nada nos aconteça. [&#x2026;]".
</p>

<p>
O excesso não é bom em praticamente nada nesta vida, não seria
diferente quanto a <b>informação</b>. O autor anteriormente citado,
parafrasesando-o, diz que a experiência tem sido cada vez mais rara,
em primeiro lugar pelo excesso de informação, e informação não é
experiência. Em segundo lugar, a experiência é cada vez mais rara por
<b>excesso de opinião</b>. Pelo excesso de informação, opinamos
demasiadamente. O autor continua e diz: "Em nossa arrogância, passamos
a vida opinando sobre qualquer coisa sobre que nos sentimentos
informados [&#x2026;]. A obsessão pela opinião também anula nossas
possibilidades de experiência, também faz com que nada nos aconteça".
</p>

<p>
Ainda nessa perpectiva, é posto em cheque a raridade da experiência
pela <b>falta de tempo</b>. O autor afirma que tudo se passa demasiadamente
depressa, cada vez mais depressa na modernidade, de tal maneira que o
acontecimento nos é dado na forma de choque e a velocidade com que
ocorre é tão tremenda que impede a conexão significativa entre esses
acontecimentos.
</p>

<p>
Por último, de acordo com o autor, a falta de experiência acontece
pelo <b>excesso de trabalho</b>. Portanto, conectando estes pontos e a
tirinha do <i>André Dahmer</i>, temos tido pouco tempo para apreciar a
vida, o que nos ocorre a todo instante, inundados de informações
inúteis e trabalhos medíocres que não nos fazem felizes, pra piorar, no
estado de infelicidade fugimos da realidade com qualquer coisa que
ajude a nos esquecer do que vivemos. No fim, chega o pior caso: a vida se
torna um grande vazio completo sem experiência alguma. Tudo passou por
nós e nada em nós terá ficado, pois estávamos sem tempo, trabalhando dia e
noite, ocupados demais opinando sobre qualquer assunto irrelevante de uma
notícia do governo, uma vacina que está pra chegar ou outra besteira
de alguma rede social.
</p>

<p>
Sem experiência não teremos vida. Seremos uma mula até a morte. A
experiência requer atenção, silêncio para que ocorra a transformação
em nossa vida. O grande show da vida.
</p>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="personal" /><category term="philosophy," /><category term="personal" /><summary type="html"><![CDATA[Porque a experiência está em escassez para muitos?]]></summary></entry><entry><title type="html">Reinstall NVIDIA drivers at shutdown</title><link href="https://lerax.me/programming/reinstall-nvidia-drivers/" rel="alternate" type="text/html" title="Reinstall NVIDIA drivers at shutdown" /><published>2020-07-14T00:00:00+00:00</published><updated>2020-07-14T00:00:00+00:00</updated><id>https://lerax.me/programming/reinstall-nvidia-drivers</id><content type="html" xml:base="https://lerax.me/programming/reinstall-nvidia-drivers/"><![CDATA[<link rel="stylesheet"
      href="/assets/css/style.css"
      type="text/css"/>

<p>
<i>Disclosure</i>: essa solução é a coisa mais porca e funcional que já fiz na
minha vida em manutenção de sistemas.
</p>

<div id="outline-container-orge739ffd" class="outline-2">
<h2 id="orge739ffd">Background</h2>
<div class="outline-text-2" id="text-orge739ffd">
<p>
Eu tava tendo vários problemas com meu sistema operacional do
computador de mesa, que além de ter um hardware já datado (10+ anos),
possuí uma placa de vídeo nvidia (GT 240) que constantemente tem me
dado dor de cabeça durante quase toda minha jornada com o Linux. Acho
que a única distribuição Linux que não tive muitos problemas foi o
Manjaro e o Artix.
</p>

<p>
Mas então, por questão de simplicidade multiusuário &#x2013; outras pessoas
tem usado esse computador agora &#x2013; instalei o Linux Mint desde que
perdi todos meus sistemas principais &#x2013; resumo de uma longa história:
(2019) artix random upgrade bug caused kernel panic at boot + (2020)
ransomware no windows por causa de uma criança estúpida querendo
baixar fortnite.
</p>
</div>
</div>

<div id="outline-container-orge14c139" class="outline-2">
<h2 id="orge14c139">Real problem</h2>
<div class="outline-text-2" id="text-orge14c139">
<p>
De toda maneira, cortando o lenga-lenga &#x2013; ou uma parte dele &#x2013; tenho
usado Linux Mint desde então (2020) depois de fugir por alguns anos de
sistemas baseado em debian/ubuntu e systemd. Por alguma razão estranha, após
alguns upgrades (distro version upgrade, pensa numa parada pra dar
merda! rolling release rules) eu finalmente cheguei numa
versão&#x2026; mais <b><b>bugada ainda</b></b> pra minha felicidade.
</p>

<p>
Toda vez que eu reiniciava meu computador simplesmente não funcionava
mais o driver de vídeo. O X11 entrava em loop e eu se quer conseguia
acionar o console via Ctrl+Alt+FN, ficava tudo travado; minha única
opção era reiniciar naquele ponto ou destruir essa desgraça &#x2013;
brincadeira, esse computador foi o início de tudo. No fim das contas,
o fluxo padrão de uso desse computador funcionava da seguinte maneira:
toda vez que eu desligava, ao ligar novamente percebia que tava tudo
fudido, então eu reiniciava de NOVO para então entrar no modo de
recuperação, dava um jeito de acionar os serviços de rede (que depois
de um tempo fazendo manualmente percebi que tinha uma OPÇÃO pra ativar
pra você) e reinstalar os drivers de vídeo da nvidia com o seguinte
comando:
</p>

<div class="org-src-container">
<pre class="src src-shell">apt install --reinstall nvidia-340
</pre>
</div>

<p>
Toda vez, toda <b><b>santa vez</b></b>, que reiniciava ou desligava eu tinha que
fazer essa merda. Claro, depois de corrigir eu reiniciava de novo. Só
nisso já foi três restarts (o que deu ruim, a correção e o sistema
funcionando de novo).
</p>

<p>
Sabe o que pensei? Quer saber, bora vê aqui se nesse SystemDeus tem um
jeito de usar um hook pra executar um comando antes de
desligar/reiniciar. Afinal, se essa porra toda sempre acontece depois
de desligar, eu corrigindo antes de desligar deve funcionar, não?
</p>
</div>
</div>

<div id="outline-container-org9b721e0" class="outline-2">
<h2 id="org9b721e0">Master solution</h2>
<div class="outline-text-2" id="text-org9b721e0">
<p>
Pois então, aí vamos lá. Eu fiz o seguinte, após uma breve pesquisa e
verifiquei que quase ninguém sabe direito como faz pra isso funcionar,
ou quando sabe fazer funcionar não sabe porque funciona, coletando os
fragmentos de conhecimentos espalhados pelas threads encontradas,
escrevi o seguinte serviço em
<code>/etc/systemd/system/reinstall-drivers.service</code>:
</p>

<div class="org-src-container">
<pre class="src src-text">[Unit]
Description=Reinstall Nvidia Drivers
DefaultDependencies=no
Before=shutdown.target reboot.target halt.target
After=network.target network-online.target
Wants=network.target network-online.target


[Service]
ExecStart=/usr/local/bin/apt install --reinstall nvidia-340 -y
Type=oneshot


[Install]
WantedBy=shutdown.target reboot.target halt.target
</pre>
</div>

<p>
Logo então, acionei os seguintes comandos:
</p>

<div class="org-src-container">
<pre class="src src-shell">sudo systemctl daemon-reload
sudo systemctl enable reinstall-drivers
</pre>
</div>

<p>
Fiz reboot e testei. Funcionou! Fiz reboot de novo e funcionou
novamente. Espero que continue funcionando. A parte chata é só a
demora de cerca de 3min agora pra desligar/reiniciar, afinal toda vez
vai ser reinstalado o driver de vídeo, mas é muito
melhor que fazer toda essa desgraça manualmente.
</p>

<p>
Invés de ser escravo de computador, prefiro que o computador seja
escravo de si mesmo.
</p>
</div>
</div>
<div id="outline-container-org250c25b" class="outline-2">
<h2 id="org250c25b">Edit: SystemDestroyed</h2>
<div class="outline-text-2" id="text-org250c25b">
<p>
<i>Post</i> atualizado em: <code>&lt;2020-09-04 Fri&gt;</code>
</p>

<p>
Na real, essa porra de ficar reinstalando não é muito
confiável. Depois de um mês e meio usando essa solução, às vezes isso
funciona, às vezes não. O <i>systemd</i> nunca foi muito confiável, mas
eu supus que pelo menos pra fazer ativação correta dos serviços poderia
se confiar. Nem isso.
</p>

<p>
Às vezes os <i>drivers</i> eram reinstalados quando o computador desligava,
mas nem sempre &#x2013; também não sei o porquê isso acontecia. Além disso,
se o computador fosse desligado abruptamente já era, aí não
funcionaria mesmo a reinstalação no desligamento. Tentei também deixar
o serviço rodando na inicialização do sistema, embora demorasse muito
o computador pra desligar, iria assegurar que iria pelo menos
ligar. Mas também não funcionou muito bem. <b><b>ÀS VEZES</b></b> funcionava.
</p>

<p>
Por esse motivo, eu resolvi usar uma propriedade do sistema dos
arquivos e simplesmente marcar o atributo de imutabilidade como ativo
para os arquivos de driver da nvidia. Uma solução brutal, mas que
funcionou bem. Nesse caso, precisei rodar os seguinte comandos com
permissão de administrador:
</p>

<div class="org-src-container">
  <pre class="src src-shell-script">
    sudo chattr +i /lib/modules/$(uname -r)/kernel/drivers/video/nvidia_uvm.ko
    sudo chattr +i /lib/modules/$(uname -r)/kernel/drivers/video/fbdev/nvidia/nvidiafb.ko</span>
</pre>
</div>

<p>
Para checar se a mudança teve efeito observa-se a inclusão do atributo de
imutabilidade <code>i</code> via <code>lsattr</code>:
</p>

<div class="org-src-container">
  <pre class="src src-shell-script">lsattr /lib/modules/$(uname -r)/kernel/drivers/video/nvidia_uvm.ko
    lsattr /lib/modules/$(uname -r)/kernel/drivers/video/fbdev/nvidia/nvidiafb.ko
  </pre>
</div>

<p>
Você deve receber uma resposta similar a:
</p>

<pre class="example">
----i--------------- /lib/modules/5.4.0-42-generic/kernel/drivers/video/nvidia_uvm.ko
----i--------------- /lib/modules/5.4.0-42-generic/kernel/drivers/video/fbdev/nvidia/nvidiafb.ko
</pre>

<p>
O lado negativo dessa solução é que precisarei fazer esses comandos
toda vez que o <i>kernel</i> for atualizado. Talvez uma solução definitiva
seria assegurar que um <i>script</i> ativa os atributos de imutabilidade dos
<i>drivers</i> assim que são reinstalados. Mas isso é papo pra outra história.
</p>
</div>
</div>
<div id="outline-container-org60c9950" class="outline-2">
<h2 id="org60c9950">Edit2: Definitive Solution</h2>
<div class="outline-text-2" id="text-org60c9950">
<p>
Post atualizado em: <span class="timestamp-wrapper"><span class="timestamp">&lt;2020-10-17 Sat&gt;</span></span>
</p>

<p>
Instalei outra distribuição Linux mais decente neste computador:
<a href="https://artixlinux.org">Artix</a>. Já venho usando essa distribuição desde 2017 e tem sido muito
bom. Não vem com SystemD e é considerado um mini-fork do <a href="https://https//www.archlinux.org/">Arch Linux</a>,
uma distribuição rolling-release com uma ótima documentação online e
também um repositório de pacotes de usuários com muitas coisas úteis:
<a href="https://aur.archlinux.org/">AUR</a>.
</p>

<p>
Apesar de não existir suporte oficial para placas de vídeo NVIDIA mais
legadas como a minha &#x2013; GT 240 (2010) &#x2013; pois os últimos drivers que a
suportam é a versão <code>340.xx</code> eu consegui ter uma versão funcional do meu
sistema com a instalação dos seguintes pacotes via AUR:
</p>

<div class="org-src-container">
<pre class="src src-shell-script">yay -S lib32-nvidia-340xx-utils nvidia-340xx-dkms nvidia-340xx-utils
</pre>
</div>

<p>
O lib32 é necessário pra rodar alguns softwares mais legados, como o
da steam.
</p>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="programming" /><summary type="html"><![CDATA[The master solution for slavery problems]]></summary></entry><entry><title type="html">Empatia vs Altruísmo</title><link href="https://lerax.me/personal/empatia-vs-altruismo/" rel="alternate" type="text/html" title="Empatia vs Altruísmo" /><published>2019-03-30T07:43:00+00:00</published><updated>2019-03-30T07:43:00+00:00</updated><id>https://lerax.me/personal/empatia-vs-altruismo</id><content type="html" xml:base="https://lerax.me/personal/empatia-vs-altruismo/"><![CDATA[<div id="outline-container-org5829a9d" class="outline-2">
<h2 id="org5829a9d">Motivação de escrever</h2>
<div class="outline-text-2" id="text-org5829a9d">
<p>
Bom&#x2026; eu estava aqui num dia de sábado, às 07h45 e me veio
espontaneamente na cabeça: o que é preciso pra ter empatia?
</p>

<p>
Um pouco óbvio, as pessoas que pensei como exemplo de empáticas,
muitas vezes elas eram também altruístas. Lembrando que altruísmo é o
ato dicotômico em relação ao egoísmo: ou seja, invés de se colocar em
primeiro lugar frente aos outros, se coloca os outros acima de você.
</p>


<p>
Mas então, isso é apenas uma coincidência ou é realmente é necessário?
Em outras palavras: <b>é possível ter empatia mesmo não sendo
altruísta?</b>
</p>
</div>
</div>

<div id="outline-container-org18413c1" class="outline-2">
<h2 id="org18413c1">Egoísmo</h2>
<div class="outline-text-2" id="text-org18413c1">
<p>
Egoísmo é comum. Talvez mais do que deveria ser; há uma certa confusão
de egoísmo com individualidade. Ora, são coisas distintas! Egoísmo
está relacionada com nossa identidade pessoal, está ligada diretamente
com a ideia de que tudo gira ao seu redor (centro das atenções). Não é
que você seja somente importante pra sua vida, afinal óbvio que na sua
vida você é importante, mas você acredita fielmente que as outras
pessoas também deveriam dar importância a você de repente até mais do
que elas dão a si mesmo!
</p>

<p>
O egoísmo além de dar supremacia ao ego poderia tornar um indíviduo
até mesmo um megalomaníaco: um complexo de superioridade que as
outras vidas tem menos importância que a sua, uma ilusão, um delírio.
</p>

<p>
A individualidade por outro lado apenas preza que eu sou um indíviduo, eu
tenho minhas vontades e elas devem ser respeitadas. Eu gosto da ideia
de individualidade, mas tenho realmente dificuldade de lidar com
pessoas egocêntricas por serem tão acidas e centradas em si.
</p>

<p>
Acredito que individualidade é necessário para a iluminação e o
autoconhecimento, pelo menos em algum nível. É muito difícil não
deixar sua identidade esparsa e nebulosa no meio de tanta explosão de
informação pela internet.
</p>

<p>
Então entramos no oposto, senão é egoísta, então é altruísta? Não
necessariamente. A seguir eu comento que o altruísmo pode ser às vezes
até mais nocivo pra própria vida que o egoísmo.
</p>
</div>
</div>


<div id="outline-container-org3593c3d" class="outline-2">
<h2 id="org3593c3d">Conclusão</h2>
<div class="outline-text-2" id="text-org3593c3d">
<p>
Ou seja, não é necessário adotar extremos entre egoísmo e altruísmo
para definir sua personalidade, é possível muito bem balancear o uso
de empatia e individualidade para que você alcance seus desejos
pessoais respeitando também a vontade, desejo, complexidade e
sofrimento alheio.
</p>

<p>
Não devemos viver a vida dos outros! Mas também não devemos impedir
que elas possam viver bem! Sejamos meros coadjuvantes na vida dos
outros e na nossa, definitivamente, precisamos ser o protagonista!
</p>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="personal" /><summary type="html"><![CDATA[É necessário ser altruísta para ter empatia?]]></summary></entry><entry><title type="html">Fundamentos de Estatística</title><link href="https://lerax.me/mathematics/stats/" rel="alternate" type="text/html" title="Fundamentos de Estatística" /><published>2019-03-07T22:24:00+00:00</published><updated>2019-03-07T22:24:00+00:00</updated><id>https://lerax.me/mathematics/stats</id><content type="html" xml:base="https://lerax.me/mathematics/stats/"><![CDATA[<div id="outline-container-orge0b9114" class="outline-2">
<h2 id="orge0b9114">Capítulo I: Modelagem Probabilística</h2>
<div class="outline-text-2" id="text-orge0b9114">
<p>
Este capítulo refere-se como uma contextualização do uso prático de
probabilidade na engenharia.
</p>
</div>
<div id="outline-container-org692f043" class="outline-3">
<h3 id="org692f043">Modelos Determinísticos</h3>
<div class="outline-text-3" id="text-org692f043">
<p>
Modelos determinísticos tem a propriedade que não há fatores de
aleatoriedade no processo de modelagem da solução. Sua resposta sempre
se aproxima de maneira ótima para o problema e é previsível em
qualquer caso. Conhecidos modelos determinísticos são as análises da
física newtoniana, como dinâmica e cinemática. Conhecendo os valores
iniciais, é possível descrever a evolução de um sistema em condições
ideais.
</p>

<p>
Outro modelo conhecido por ser determinístico é o modelo matemático
envolvido nos circuitos elétricos. Como a lei de Ohm \(v = RI\).  Em
condições ideais, a resposta exata do sistema avaliado é descrito
pelas equações que regem o modelo.
</p>

<p>
É importante lembrar que um modelo matemático é comumente referenciado
como um sistema para descrever algo mensurável, que se assemelha a
algo real — como é o caso da física newtoniana e a teoria de circuitos
elétricos.
</p>
</div>
</div>

<div id="outline-container-orge372e4a" class="outline-3">
<h3 id="orge372e4a">Modelos Probabilísticos</h3>
<div class="outline-text-3" id="text-orge372e4a">
<p>
Muitos sistemas de interesse envolvem comportamentos imprevisíveis e
aleatórios. Esses sistemas não podem ser descritos com modelos
determinísticos, pois dependem de fatores
não-determinísticos. Experimentos aleatórios, como o fato de lançar
uma moeda, transmissão de pacotes, tempo de espera em uma fila&#x2026; são
problemas com natureza aleatória. Não é possível modelar esse tipo de
problema com modelos determinísticos.
</p>

<p>
Nesse momento então surge um novo tipo de matemática que lidaremos
como Probabilidade e Estatística. No decorrer do livro, entraremos em
conceitos mais abstratos como o de <i>Random Processes</i> (Processos
Estocásticos).
</p>

<p>
Os meios de comunicação da internet, assim como seus protocolos, são
bons exemplos de sistemas modelados com modelos probabilísticos. Não é
possível, por exemplo, saber de exato se um pacote ao ser enviado será
chegado ao destinatário. Temos uma probabilidade que isso ocorra e uma
determinada probabilidade relacionada a quantidade de vezes
necessárias que um pacote seja enviado até que ele tenha sucesso.
</p>
</div>
</div>
</div>

<div id="outline-container-orge49ceea" class="outline-2">
<h2 id="orge49ceea">Capítulo II: Fundamentação de Probabilidade</h2>
<div class="outline-text-2" id="text-orge49ceea">
<p>
Conceitos básicos de probabilidade, axiomas, teoremas e implicações.
</p>
</div>


<div id="outline-container-orgfb833fd" class="outline-3">
<h3 id="orgfb833fd">Axiomas</h3>
<div class="outline-text-3" id="text-orgfb833fd">
<p>
Seja \(P\) o operador de probabilidade, \(A\) e \(B\) eventos do
espaço amostral \(S\), é dado os seguintes axiomas no contexto de
probabilidade:
</p>

<ol class="org-ol">
<li>\(0 \leq P[A] \leq 1\)</li>
<li>\(P[S] = 1\)</li>
<li>Se A e B são eventos que não acontecem simultaneamente, então
\(P[A \cup B] = P[A] + P[B]\)</li>
</ol>

<p>
Uma extensão do axioma 3 é para o caso que tenhamos um conjunto
enumerável de eventos que são mutuamente exclusivos, então a
probabilidade de todos eles é a soma das suas probabilidades
individuais.
</p>

<p>
Um colorário interessante é o da probabilidade complemento:
</p>

<div class="LATEX">
\begin{equation}
P[A^c] =1 - P[A]
\end{equation}

</div>

<p>
Usualmente a operação de complemento pode ser vista como a negação da
proposição que se avalia a probabilidade. Por exemplo: qual a
probabilidade de se jogar um dado e não aparecer o número 6? Ao
aplicar esse teorema o problema fica simples \(1 - \dfrac{1}{6}
\Rightarrow \dfrac{5}{6}\) dado que a probabilidade de aparecer
qualquer número em um dado é \(\dfrac{1}{6}\)
</p>
</div>
</div>

<div id="outline-container-orgbfc5f63" class="outline-3">
<h3 id="orgbfc5f63">Eventos Independentes</h3>
<div class="outline-text-3" id="text-orgbfc5f63">
<p>
Se dois eventos são independentes, como o ato de lançar duas moedas, a
intersecção de suas probabilidades devem ser igual ao produto das
probabilidades dos eventos.
</p>

<div class="LATEX">
\begin{equation}
P(A \cap B) = P(A) \cdot P(B)
\end{equation}

</div>

<p>
Um exemplo de eventos independentes é quando o estado anterior de um
evento ocorrido não interfere na probabilidade do próximo evento
ocorrer.  Por exemplo, duas moedas sendo lançadas ao mesmo tempo são
eventos independentes.  O que ocorrer em uma não depende de outra.
</p>

<p>
No entanto, por outro lado, a probabilidade de tirar uma carta \(X\)
num deque de 52 cartas sem reposição e tirar outra \(Y\) não são
eventos independentes.
</p>
</div>
</div>

<div id="outline-container-orgb6708ed" class="outline-3">
<h3 id="orgb6708ed">Eventos Mutualmente Exclusivos</h3>
<div class="outline-text-3" id="text-orgb6708ed">
<p>
Se dois eventos \(A\) e \(B\) não podem ocorrer simultaneamente, então
temos duas propriedades:
</p>

<div class="LATEX">
\begin{align}
P[A \cap B] &= 0 \\ P[A \cup B] &= P[A] + P[B]
\end{align}

</div>

<p>
Isso se deve pelo tipo de experimento que ocorre. Em alguns casos, um
evento não pode ocorrer simultaneamente. Como o caso de um moeda ser
cara e coroa ao mesmo tempo, um carro ser verde e amarelo ao mesmo
tempo.  São eventos impossíveis, por isso a probabilidade é zero
(intuitivamente).  Muitas provas existem sobre esses colorários dos
axiomas da probabilidade, mas estão fora do escopo dessas notas — a
não ser quando for interessante demonstrar.
</p>

<div class="LATEX">
\begin{align}
P[A \cup B] &= P[A] + P[B] - P[A \cap B]
\end{align}

</div>
</div>
</div>


<div id="outline-container-org38a7db9" class="outline-3">
<h3 id="org38a7db9">Probabilidade Condicional</h3>
<div class="outline-text-3" id="text-org38a7db9">
<p>
A probabilidade condicional pode ser enxergada como uma nova base do
<b>espaço amostral</b> em cima de uma nova condição. É anunciado que \(P(A
\mid B)\) como: 'Probabilidade de A, dado que B já ocorreu'. Ou
simplesmente 'P de A dado B'.  A fórmula para seu cálculo é dado por:
</p>

<div class="LATEX">
\begin{equation}
P[A \mid B] = \dfrac{P[A \cap B]}{P[B]}
\end{equation}

</div>

<p>
Probabilidade condicional é usado quando estamos se referindo a
eventos dependentes. Um bom exemplo, como comentado anteriormente, é a
probabilidade de duas cartas escolhidas sequencialmente serem
advinhadas num deque de cartas.
</p>
</div>
</div>

<div id="outline-container-orgdd0e6b3" class="outline-3">
<h3 id="orgdd0e6b3">Experimentos Sequenciais</h3>
<div class="outline-text-3" id="text-orgdd0e6b3">
<p>
Experimentos sequenciais nada mais são que eventos aplicados um depois
do outro.  Sua probabilidade depende se os eventos são dependentes ou
não. Para eventos independentes podemos aplicar simplesmente a regra
do produto, a probabilidade dos eventos ocorrerem é o produtório das
probabilidades desses eventos.
</p>

<p>
No entanto, se os eventos são dependentes, devemos ter mais cautela.
</p>
</div>
</div>

<div id="outline-container-orgaed748a" class="outline-3">
<h3 id="orgaed748a">Probabilidade Binomial</h3>
<div class="outline-text-3" id="text-orgaed748a">
<p>
A lei da probabilidade binomial descreve como a probabilidade de um
experimento evolui de acordo com o número de eventos sequenciais.
</p>

<div class="LATEX">
\begin{equation}
p_n(k) = \binom{n}{k}p^k(n -p)^{n-k}
\end{equation}

</div>
</div>
</div>

<div id="outline-container-org2799e58" class="outline-3">
<h3 id="org2799e58">Teorema de Bayes</h3>
<div class="outline-text-3" id="text-org2799e58">
<p>
O teorema de Bayes, ou regra de Bayes, estabelece que o evento
condicional estão intrinsecamente ligados com a probabilidade do
evento em si ocorrer.  Isto é, a probabilidade condicional de A dado B
e B dado A, é proporcional as probabilidades de B e A.
</p>

<div class="LATEX">
\begin{equation}
P(A \mid B) = \dfrac{P(B \mid A) P(A)}{P(B)}
\end{equation}

</div>

<p>
Muito similar ao teorema da probabilidade condicional, o teorema de
Bayes geralmente tem sua formula descrita de forma mais sucinta
traduzindo a definição da probabilidade de \(P(A \cap \B)\) em termos
da probabilidade condicional.
</p>

<p>
Isto fica evidente quando lembramos que:
</p>

<div class="LATEX">
\begin{equation}
P(A \cap B) = P(B \mid A)P(A) = P(A \mid B) P(B)
\end{equation}

</div>
</div>
</div>


<div id="outline-container-org769edcb" class="outline-3">
<h3 id="org769edcb">Teorema da Probabilidade Total</h3>
<div class="outline-text-3" id="text-org769edcb">
<p>
O teorema da probabilidade total referencia o teorema de Bayes com uma
especifica modelagem. Ele é enxergado com fatias do espaço amostral em
relação ao um evento de interesse. Logo, a probabilidade de um evento
\(A\) pode ser visto como a intersecção de todas essas parcelas de
eventos com nosso evento de interesse \(A\).
</p>


<p>
A partir disso tem-se que uma probabilidade qualquer \(A)\) pode ser
expressa em cima de:
</p>

<div class="LATEX">
\begin{equation}
P[A] = \sum_{i=1}^n P[E_i \cap A] = \sum_{i=i}^n P[A \mid E_i] P[E_i]
\end{equation}

</div>
</div>
</div>

<div id="outline-container-orgdd5bc13" class="outline-3">
<h3 id="orgdd5bc13">Diagrama de Árvore</h3>
<div class="outline-text-3" id="text-orgdd5bc13">
<p>
O diagrama de árvore é usado geralmente para descrever todos os
possíveis caminhos de um determinado experimento.  Como um modelo
probabilístico pode se comportar diante das variações de eventos.
</p>

<p>
Muito útil durante a análise, principalmente de eventos sequenciais,
para um caso avaliando dois lançamentos de moedas sequencias, tem-se a
seguinte possível arquitetura:
</p>

<pre class="example">
       _ / \
   T H / \ / \
T H T H
</pre>

<p>
Onde <code>T</code> significa <i>tail</i> (coroa) e <code>H</code> <i>head</i> (cara). Embora nesse
exemplo não pareça um tanto útil pois as probabilidades são iguais,
quando lidamos com sistemas com muitas peculiaridades, como
probabilidades condicionais pode ser bastante útil para
visualização. No entanto, é uma ferramenta visual para esclarecimento,
que pode ser muitas vezes ignorada.
</p>
</div>
</div>
</div>


<div id="outline-container-org9b45ce0" class="outline-2">
<h2 id="org9b45ce0">Capitulo III: Variáveis aleatórias discretas</h2>
<div class="outline-text-2" id="text-org9b45ce0">
<p>
Bom, variáveis aleatórias discretas são definidas no contexto de
probabilidade e estatística. Uma variável aleatória nada mais é que
uma função que relaciona um evento (experimento aleatório) a um dado
número.
</p>

<p>
Para um variável aleatória ser definida, essa relação deve ser
conhecida.
</p>

<p>
Há muitos tipos de variáveis aleatórias, como variável de poison,
geométrica, bernoulli e a variável binomial. Cada uma delas são usadas
para casos distintos de problemas com natureza probabilística.
</p>

<p>
Nas próximas seções serão definidas, de uma maneira mais descritiva e
formal, as propriedades que uma variável aleatória discreta possuí.
</p>

<p>
Existe a noção de classe de eventos, que são uma coleção de
experimentos aleatório que possuí o mesmo tipo de experimento.
(como os resultados de lançar uma moeda ou um dado).
</p>
</div>

<div id="outline-container-orgcf82a8d" class="outline-3">
<h3 id="orgcf82a8d">Probability Mass Function (PMF)</h3>
<div class="outline-text-3" id="text-orgcf82a8d">
<p>
A PMF, em português FMP, que significa função massa de probabilidade
se refere uma função de probabilidade que X assume dado valor. Sua
definição é bem tirada como pode ser visto a seguir:
</p>

<div class="LATEX">
\begin{equation}
p_x(x) = P[X = x] = P[\{\zeta:X(\zeta) = x\}]
                    \qquad \text{for x a real number.}
\end{equation}

</div>

<p>
Três axiomas são definidas para a PMF, dentre quais:
</p>

<div class="LATEX">
\begin{align}
p_x(x) &\geq 0 &\text{for all x} \\
\sum_{k \in S_x} p_x(k) &= 1 \\
P[X \in B] &= \sum_{x \in B} p_x(x) &\text{where} \ B \subset S_X
\end{align}

</div>
</div>
</div>

<div id="outline-container-orge7e5f87" class="outline-3">
<h3 id="orge7e5f87">Distribuições</h3>
<div class="outline-text-3" id="text-orge7e5f87">
<p>
Há varias tipos de distribuições para modelos de probabilidade. Cada
um desses modelos é aplicado para um determinado tipo de problema, a
seguir é comentado algum deles. Dessa maneira, uma determinada
distribuição está relacionado com uma definição de variável aleatória.
</p>
</div>

<ul class="org-ul">
<li><a id="org4ac6887"></a>Bernoulli<br />
<div class="outline-text-4" id="text-org4ac6887">
<p>
Provavelmente uma das distribuições mais simples de todas, quando se
possui um problema de natureza binária, isto é, a variável aleatória
só pode assumir dois valores, então seu nome recebe como variável
aleatória de Bernoulli. Em casos, como um sistema que avalia
sucesso/falha de uma operação, é interessante usar Bernoulli. Por
exemplo \(X(E_{sucesso}) = 1\) e \(X(E_{falha}) = 0\).
</p>
</div>
</li>

<li><a id="orgf446e03"></a>Geométrica<br />
<div class="outline-text-4" id="text-orgf446e03">
<p>
Quando uma sequência de eventos é relacionada de forma independente
aos seus estados anteriores, essa variável é conhecida como Variável
Aleatória Geométrica. Sua forma é acontecer n eventos iguais sequencialmente,
até que o posto aconteça. É a única variável aleatória sem memória.
Um exemplo de uso dessa distribuição é a quantidade de pacotes necessários
que precisam ser enviados até que um deles chegue com sucesso.
</p>

<div class="LATEX">
\begin{equation}
p_x(k) = P[X = k] = (1 - p)^{k-1}p = q^{k-1}p
\end{equation}

</div>
</div>
</li>

<li><a id="orgf8feee9"></a>Binomial<br />
<div class="outline-text-4" id="text-orgf8feee9">
<p>
Semelhante ao caso da Geométrica, na binomial estamos interessados
nas possíveis combinações geradas entre os eventos. Por exemplo,
como é distribuída a probabilidade para eu obter n coroas no lançamento
de uma moeda k vezes?
</p>

<p>
A fórmula da binomial segue que:
</p>

<div class="LATEX">
\begin{equation}
p_x(k) = P[X = k] = \binom{n}{k}p_k(1-p)^{n-k}
\end{equation}

</div>

<p>
Outro exemplo interessante é contar a quantidade de erros numa
transmissão. Uma canal de comunicação binária introduz um bit de erro
em uma transmissão com probabilidade \(p\). Seja \(X\) o número de erros
em \(n\) independentes transmissões. Encontre a pmf de X. Encontre a
probabilidade de um ou mais erros.
</p>

<p>
A distribuição binomial é usada aqui pois pode ocorrer um erro em qualquer
uma das transmissões, embora a ordem que eles ocorreram não importam,
apenas que é possível ocorrer em qualquer das \(n\) transmissões.
</p>

<p>
Por exemplo, para \(P[X \leq 1]\) iremos somar a probabilidade de que
\(k = \{0, 1\}\).
</p>
</div>
</li>


<li><a id="org1e302dd"></a>Poisson<br />
<div class="outline-text-4" id="text-org1e302dd">
<p>
A variável de Poisson, uma variável discreta, é modelada
para descrever uma contagem num dado intervalo contínuo.
Ela é modelada através de uma função exponencial.
</p>

<p>
Um exemplo de uso para essa variável seria analisar quantas
pessoas chegam na estação de trem no intervalo de uma hora.
</p>

<p>
Define-se então a variável de Poisson como a seguir:
</p>

<div class="LATEX">
\begin{equation}
P[N = k] = p_N(k) = \dfrac{\lambda^k e^{-\lambda}}{k!}
\end{equation}

</div>
</div>
</li>
</ul>
</div>


<div id="outline-container-org0697236" class="outline-3">
<h3 id="org0697236">Valor esperado (Expected Value)</h3>
<div class="outline-text-3" id="text-org0697236">
<p>
O valor esperado ou média se refere a um valor de tendência numa distribuição
probabilística. Isto é, os valores mais prováveis de serem encontrados estão
em torno da média ou do valor esperado.
</p>

<div class="LATEX">
\begin{equation}
E[X] = \sum_{x \in S_x} xp_x(x) = \sum_k x_k p_k(x_k)
\end{equation}

</div>

<p>
Isto é, dado um subconjunto \(S_x\) do espaço amostral \(S\), sendo
esse subconjunto aqueles com os nossos eventos de interesse, a definição
de esperança define como a soma do produto dos individuais valores do conjunto
por sua probabilidade de ocorrer.
</p>

<p>
Para o valor esperado existir, é necessário que a soma convirja absolutamente.
</p>
</div>
</div>

<div id="outline-container-org10632e0" class="outline-3">
<h3 id="org10632e0">Variância e Desvio Padrão</h3>
<div class="outline-text-3" id="text-org10632e0">
<p>
A definição de variância em probabilidade estatística está relacionado
a amplitude que os valores oscilam em torno da média. Pode-se definir
de duas maneiras:
</p>

<div class="LATEX">
\begin{equation}
\sigma_X^2 = VAR[X] = E[(X - m_x)^2] = E[X^2] - E[X]^2
\end{equation}

</div>

<p>
Vale lembrar que a Esperança (E[X]) é um operador linear
que possuí as propriedades de superposição e homogeneidade.
</p>

<p>
O desvio padrão é denotado como a raiz quadrada da variança.
Sendo apenas \(\sigma_x\).
</p>
</div>
</div>

<div id="outline-container-orga9a12c7" class="outline-3">
<h3 id="orga9a12c7">Momento de uma variável</h3>
<div class="outline-text-3" id="text-orga9a12c7">
<p>
O momento é definido como uma propriedade referente ao valor
esperado de uma variável X. É definido como <b>n-ésimo momento de X</b>:
\(E[X^n]\).
</p>
</div>
</div>


<div id="outline-container-org8072b15" class="outline-3">
<h3 id="org8072b15">PMF e Esperança Condicional</h3>
<div class="outline-text-3" id="text-org8072b15">
<p>
A PMF e Esperança condicional apenas estende os conceitos
previamente descritos com a Regra de Bayes e o Teorema da
Probabilidade Total.
</p>
</div>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="mathematics" /><summary type="html"><![CDATA[Revisão de Fundamentos de Estatística]]></summary></entry><entry xml:lang="en"><title type="html">The Eternal Phoenix</title><link href="https://lerax.me/personal/the-eternal-phoenix/" rel="alternate" type="text/html" title="The Eternal Phoenix" /><published>2017-11-06T03:38:00+00:00</published><updated>2017-11-06T03:38:00+00:00</updated><id>https://lerax.me/personal/the-eternal-phoenix</id><content type="html" xml:base="https://lerax.me/personal/the-eternal-phoenix/"><![CDATA[<p align="center">
<iframe style="border: 0; width: 350px; height: 786px;"
        src="https://bandcamp.com/EmbeddedPlayer/album=512666029/size=large/bgcol=333333/linkcol=0f91ff/transparent=true/" seamless>
  <a href="http://chaoticlambdas.bandcamp.com/album/the-eternal-phoenix">The Eternal Phoenix by Manoel Vilela @ Lerax</a>
</iframe>
</p>

<div id="outline-container-org26cdd2c" class="outline-2">
<h2 id="org26cdd2c">Description</h2>
<div class="outline-text-2" id="text-org26cdd2c">
<p>
This is a lot of introspection about my entire life: the nested deaths
and resurrections. Mainly about the depressing eras and fighting with
it. How does the sound of a mind like that sound? The album covers a random
composing music on these days. How can I say... it's just about me.
</p>

<p>
For me, was always (and always will be) like a eternal phoenix cycle: dead inside, reborn. <b>Repeat</b>.
</p>

<p>
Thanks to <i>Boa</i> and <i>Vivaldi</i> creating so much awesome musics, the
<i>Mindblowing</i> and <i>Lost</i> tracks was covers of the respective music
authors: Vivaldi Tribute by Patrick Rondat and Duvet by <i>Boa</i>.
</p>

<p>
As extra track, I added later of publish date a old cover that I
recorded of <i>Cello Suit I Prelude in G</i> by <i>John Sebastian Bach</i>, but
the execution is just a sample (not completed).
</p>

<p>
All credits © and rights reserved ® to Manoel Vilela (λ.me?), released in June 11, 2016.
</p>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="personal" /><summary type="html"><![CDATA[A conceptual album about my mind]]></summary></entry><entry xml:lang="pt"><title type="html">Lisp Bookmarks - Lista de bookmarks da minha vida de Lisp</title><link href="https://lerax.me/programming/lisp-bookmarks/" rel="alternate" type="text/html" title="Lisp Bookmarks - Lista de bookmarks da minha vida de Lisp" /><published>2017-08-26T00:00:00+00:00</published><updated>2017-08-26T00:00:00+00:00</updated><id>https://lerax.me/programming/lisp-bookmarks</id><content type="html" xml:base="https://lerax.me/programming/lisp-bookmarks/"><![CDATA[<style>
  pre.src {
    background-color: #303030;
    color: #e5e5e5;
    padding: 1em;
    padding-top: 1em;
    padding-right: 1em;
    padding-bottom: 1em;
    padding-left: 1em;
  }
</style>

<!DOCTYPE NETSCAPE-Bookmark-file-1>
<!-- This is an automatically generated file.
     It will be read and overwritten.
     DO NOT EDIT! -->
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
<TITLE>Bookmarks</TITLE>
<H1>Bookmarks</H1>
<DT><H3 ADD_DATE="1509052029" LAST_MODIFIED="1509052029">Lisp</H3>
  <DL><p>
      <DT><A HREF="http://fauux.neocities.org/" ADD_DATE="1509052029">「 Ｗｉｒｅｄ　Ｓｏｕｎｄ 」 | Serial Experiments Lain</A>
      <DT><A HREF="http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node10.html" ADD_DATE="1509052029">1.2.3. Evaluation, Expansion, and Equivalence</A>
      <DT><A HREF="http://www.dainf.ct.utfpr.edu.br/~kaestner/Logica/HowtoLisp.txt" ADD_DATE="1509052029">Algoritmos de Wang, Tableau Semantico e Resolução</A>
      <DT><A HREF="http://www.diale.org/rootslisp.html" ADD_DATE="1509052029">As raízes de Lisp</A>
      <DT><A HREF="http://www.clisp.org/" ADD_DATE="1509052029">CLISP - an ANSI Common Lisp Implementation</A>
      <DT><A HREF="http://www.dca.fee.unicamp.br/courses/EA072/lisp9596/node6.html" ADD_DATE="1509052029">Combinações em CL</A>
      <DT><A HREF="http://pt.wikipedia.org/wiki/Common_Lisp#Entrada_e_Sa.C3.ADda" ADD_DATE="1509052029">Common Lisp – Wikipédia, a enciclopédia livre</A>
      <DT><A HREF="https://epxx.co/artigos/lithp.php" ADD_DATE="1509052029">Fumando listas: Lisp</A>
      <DT><A HREF="https://medium.com/@technicat/i-miss-lisp-847bf040be84" ADD_DATE="1509052029">I Miss Lisp — Medium</A>
      <DT><A HREF="http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/index.html" ADD_DATE="1509052029">Index of Common Lisp (functions and other entities)</A>
      <DT><A HREF="https://xuanji.appspot.com/isicp/index.html" ADD_DATE="1509052029">Interactive SICP | Fundamentals LISP</A>
      <DT><A HREF="http://www.ic.unicamp.br/~meidanis/courses/mc336/2006s2/funcional/L-99_Ninety-Nine_Lisp_Problems.html" ADD_DATE="1509052029">L-99: Ninety-Nine Lisp Problems</A>
      <DT><A HREF="http://landoflisp.com/" ADD_DATE="1509052029">Land of Lisp! Book</A>
      <DT><A HREF="http://pt.wikipedia.org/wiki/Lisp" ADD_DATE="1509052029">Lisp – Wikipédia, a enciclopédia livre</A>
      <DT><A HREF="http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node12.html" ADD_DATE="1509052029">Descriptions of Functions and Other Entities (CL)</A>
      <DT><A HREF="http://eudoxia.me/article/common-lisp-sotu-2015/" ADD_DATE="1509052029">State of the Common Lisp Ecosystem, 2015</A>
      <DT><A HREF="http://www.dca.ufrn.br/~adelardo/lisp/" ADD_DATE="1509052029">Tutorial LISP</A>
      <DT><A HREF="http://learnxinyminutes.com/docs/common-lisp/" ADD_DATE="1509052029">Learn Common Lisp in Y Minutes</A>
      <DT><A HREF="http://c2.com/cgi/wiki?WhyWeHateLisp" ADD_DATE="1509052029">Why We Hate Lisp</A>
      <DT><A HREF="http://www.cse.buffalo.edu/~shapiro/Reasoning/wang.html" ADD_DATE="1509052029">www.cse.buffalo.edu/~shapiro/Reasoning/wang.html</A>
      <DT><A HREF="http://www.cs.sfu.ca/CourseCentral/310/pwfong/Lisp/1/tutorial1.html" ADD_DATE="1509052029">LISP Tutorial 1: Basic LISP Programming</A>
      <DT><A HREF="http://www.unixuser.org/~euske/doc/cl/loop.html" ADD_DATE="1509052029">Common Lisp&#39;s Loop Macro Examples for Beginners</A>
      <DT><A HREF="https://lainchan.org/~lisp/" ADD_DATE="1509052029">Index of /~lisp/</A>
      <DT><A HREF="http://www.infoq.com/presentations/Simple-Made-Easy" ADD_DATE="1509052029">Simple Made Easy</A>
      <DT><A HREF="https://marktrapp.com/blog/2014/01/20/lisp-with-os-x-sublime-text/" ADD_DATE="1509052029">Setting up a Common Lisp environment on OS X with Sublime Text 3 | Mark Trapp</A>
      <DT><A HREF="http://norvig.com/python-lisp.html" ADD_DATE="1509052029">Python for Lisp Programmers</A>
      <DT><A HREF="https://mitpress.mit.edu/sicp/full-text/book/book.html" ADD_DATE="1509052029">Structure and Interpretation of Computer Programs</A>
      <DT><A HREF="https://mitpress.mit.edu/sicp/full-text/sicp/book/node39.html" ADD_DATE="1509052029">Example: Symbolic Differentiation</A>
      <DT><A HREF="http://kep.io/is-lisp-still-a-secret-weapon/" ADD_DATE="1509052029">Lisp is still a secret weapon</A>
      <DT><A HREF="https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-11.html#%_sec_1.2" ADD_DATE="1509052029">Structure and Interpretation of Computer Programs</A>
      <DT><A HREF="http://r-th.hatenablog.com/entry/2013/06/09/172821" ADD_DATE="1509052029">Sublime Text 2にCommon LispのSyntaxを追加する - ひぎろぐ</A>
      <DT><A HREF="http://hyperpolyglot.org/lisp" ADD_DATE="1509052029">Lisp: Common Lisp, Racket, Clojure, Emacs Lisp - Hyperpolyglot</A>
      <DT><A HREF="http://www.gigamonkeys.com/book/" ADD_DATE="1509052029">Practical Common Lisp</A>
      <DT><A HREF="http://www.crategus.com/books/cl-gtk/gtk-tutorial_toc.html#SEC_Contents" ADD_DATE="1509052029">GTK+ 3 Tutorial for Lisp: Table of Contents</A>
      <DT><A HREF="http://www.gigamonkeys.com/book/files-and-file-io.html" ADD_DATE="1509052029">Common Lisp: Files and File I/O</A>
      <DT><A HREF="http://www.andromeda.com/people/ddyer/lisp/" ADD_DATE="1509052029">A Brief History of Lisp Machines</A>
  </DL><p>
</DL>]]></content><author><name>Manoel Vilela</name></author><category term="programming" /><category term="lisp" /><category term="programming" /><summary type="html"><![CDATA[Nas profundezas arcaicas, um mundo de Lisp será encontrado]]></summary></entry><entry xml:lang="pt"><title type="html">Processamento Digital de Sinais</title><link href="https://lerax.me/mathematics/pds/" rel="alternate" type="text/html" title="Processamento Digital de Sinais" /><published>2017-08-24T14:01:00+00:00</published><updated>2017-08-24T14:01:00+00:00</updated><id>https://lerax.me/mathematics/pds</id><content type="html" xml:base="https://lerax.me/mathematics/pds/"><![CDATA[<div class="ABSTRACT">
<p>
Essas notas se concentram toda a revisão, resumo e exercícios para o
Cápitulo II do livro Discrete-Time Digital Processing do <i>Oppenheim</i>:
Sinais e Sistemas Lineares Invariantes no Tempo.  Esse material
refere-se a disciplina de Processamento Digital de Sinais.
</p>

</div>

<div id="outline-container-org4868679" class="outline-2">
<h2 id="org4868679">Descrição</h2>
<div class="outline-text-2" id="text-org4868679">
<p>
As últimas aulas de PDS foram dadas a respeito sobre as definições
básicas de sinal e sistema. Outras propriedades foram faladas também
como:
</p>

<ul class="org-ul">
<li>Memoria</li>
<li>Linearidade</li>
<li>Sistemas Lineares Invariantes no Tempo</li>
<li>Causalidade</li>
<li>Estabilidade</li>
</ul>


<p>
Também foi comentado sobre entidades como <code>media móvel</code>, delta de
Dirac (contínuo) e delta de Kronecker (discreto).
</p>


<p>
Existem três tipos de sistemas: contínuo, discretos no tempo e
digitais.
</p>


<p>
Sistemas computacionais são digitais, no entanto na teoria de PDS será
estudado sistemas discretos no tempo. A diferença entre eles é que os
valores que um sinal pode assumir é contínuo, embora os valores do
tempo (abscissas) são discretos.
</p>
</div>
</div>


<div id="outline-container-orgcf3a10b" class="outline-2">
<h2 id="orgcf3a10b">Conceitos</h2>
<div class="outline-text-2" id="text-orgcf3a10b">
<p>
Os conceitos principais para a disciplina de Processamento Digitais de
Sinais (PDS), envolve os conceitos já definidos na disciplina de
Sistemas Lineares (que não fiz completamente). Os conceitos
elementares envolvem Sinais e Sistemas de Sinais, dos quais derivam-se
os domínios: contínuo, discreto no tempo e digital.
</p>

<p>
Sinais contínuos tem seu domínio e contra-domínio contínuo,
referenciado muitas vezes como sinais analógicos. Sinais discretos no
tempo possui o tempo discreto, mas a amplitude contínua. Sinais
digitais são ambos discretos em tempo e amplitude.
</p>

<p>
As transformações sucessivas entre esses tipos de sinais são chamados
de amostragem e quantização. A transformação de um sinal em outro é
chamado de sistema.
</p>
</div>

<div id="outline-container-orga45d4af" class="outline-3">
<h3 id="orga45d4af">Sinais</h3>
<div class="outline-text-3" id="text-orga45d4af">
<p>
Sinal é nada mais que uma função com uma interpretação física: uma
entidade mensurável.  No domínio discreto no tempo recebe uma notação
especial \(f[n]\) enquanto no contínuo geralmente é \(f(t)\). Sinais
discretos podem ser interpretados também com uma sequência numérica,
com seus valores associados em \(n \in \mathbb{N}\).
</p>

<p>
Um sinal muito importante é o impulso unitário, definido como o delta
de kronecker para o caso discreto. \(\delta[n = 0] = 1\) e \(\delta[n
\neq 0]=0 \).
</p>

<p>
Como será visto na discussão de sistemas lineares, uma dos mais
importantes aspectos de uma sequência de impulsos é que um sequência
arbitrária pode ser descrita como uma soma ponderada de impulsos
atrasados.
</p>

<p>
Além disso, um sinal discreto pode ser representando como um sinal
contínuo com uma amostragem matemática definida como:
</p>

<div class="LATEX" id="sinais:amostragem">
\begin{equation}
x[n] = x_a(nT)
\end{equation}

</div>

<p>
Representa a \(n\)-ésima componente do sinal contínuo \(x_c(t)\)
obtida de um processo de amostragem periódica.
</p>

<p>
Sendo \(T\) o período de amostragem, tal que \(T \in \mathbb{R} \) e
\(n \in \mathbb{N} \).
</p>
</div>
</div>

<div id="outline-container-org29a32c0" class="outline-3">
<h3 id="org29a32c0">Sistemas</h3>
<div class="outline-text-3" id="text-org29a32c0">
<p>
Sistema tem como entrada um sinal e resposta um novo sinal. De forma
um tanto detalhada, é dita que: `Fenômeno físico que exerce transformações sobre os sinais, modificando
o conteúdo de informação nele contida.'
</p>
</div>
</div>

<div id="outline-container-org378dfca" class="outline-3">
<h3 id="org378dfca">Sinal unitário</h3>
<div class="outline-text-3" id="text-org378dfca">
<p>
Sinal unitário é definido como delta de kronecker para o domínio
discreto.
</p>
</div>
</div>

<div id="outline-container-orgc468609" class="outline-3">
<h3 id="orgc468609">Delta de Kronecker</h3>
<div class="outline-text-3" id="text-orgc468609">
<p>
O delta de kronecker é definido como \(\delta[0]=1\) e para todos
outros igual a 0.
</p>
</div>
</div>

<div id="outline-container-org5d3fa13" class="outline-3">
<h3 id="org5d3fa13">Sinal degrau</h3>
<div class="outline-text-3" id="text-org5d3fa13">
<p>
O sinal degrau é \(u[n \geq 0] = 1\) e zero para todo o resto. Há
algumas implicações do sinal degrau com o sinal unitário, como de fato
no exemplo no sistema acumulador, recebendo o sinal unitário de
entrada, vamos criar o sinal degrau.
</p>
</div>
</div>
</div>

<div id="outline-container-orgee808d6" class="outline-2">
<h2 id="orgee808d6">Propriedades de sistemas</h2>
<div class="outline-text-2" id="text-orgee808d6">
</div>

<div id="outline-container-org48373bf" class="outline-3">
<h3 id="org48373bf">Memória</h3>
<div class="outline-text-3" id="text-org48373bf">
<p>
Um sistema pode ser definido com memória ou sem memória. Sistemas
ideais sem memória não dependem de entradas passadas. Por exemplo o
sistema média móvel é um sistema com memória pois deve armazenar \(n\)
entradas para calcular a cada ponto. Um amplificador pode ser
implementado sem memória, no entanto amplificadores reais geralmente
são implementados com memória por alguma razão obscura que ainda não
sei <sup><a id="fnr.1" class="footref" href="#fn.1">1</a></sup>.
</p>
</div>
</div>

<div id="outline-container-org40b3dfb" class="outline-3">
<h3 id="org40b3dfb">Linearidade</h3>
<div class="outline-text-3" id="text-org40b3dfb">
<p>
Se provado as condições de superposição, é dito que o sistema é
linear. Vale lembrar que as condições de superposição são os axiomas
da aditividade (Eq. <a href="#orgc5d5f84">1</a>) e homogeneidade
(Eq. <a href="#orgdefa3c0">1</a>) .
</p>

<div class="LATEX" id="linearidade:aditividade">
\begin{equation} \label{linearidade:aditividade}
T\{x_1[n] + x_2[n]\} = T\{x_1[n]\} + T\{x_2[n]\} = y_1[n] + y_2[n]
\end{equation}

</div>

<div class="LATEX" id="linearidade:homogeneidade">
\begin{equation} \label{linearidade:homogeneidade}
T\{ax[n]\} = aT\{x[n]\} = ay[n]
\end{equation}

</div>
</div>
</div>

<div id="outline-container-orgbb2a9b8" class="outline-3">
<h3 id="orgbb2a9b8">Invariância no Tempo</h3>
<div class="outline-text-3" id="text-orgbb2a9b8">
<p>
Sistemas invariantes no tempo são aqueles quando o sinal atrasado na
entrada ou atrasado na saida, gera o mesmo sistema. Para provar se é
SLIV, é necessário provar para todos os possíveis atrasos.  Para
refutar, é necessário apenas um contra-exemplo.
</p>

<p>
Matematicamente descrito como:
</p>

<div class="LATEX" id="sliv:teorema">
\begin{equation} \label{sliv:teorema}
x_1[n -n_0] \Rightarrow y_1[n - n_o], \forall n_0
\end{equation}

</div>

<p>
Por exemplo, o sistema acumulador é invariante no tempo.
</p>

<div class="LATEX" id="examplo:acumulador">
\begin{equation} \label{exemplo:acumulador}
y[n] = \sum_{i=-\infty}^n x[k]
\end{equation}

</div>
</div>
</div>

<div id="outline-container-orgaa7ddee" class="outline-3">
<h3 id="orgaa7ddee">Causalidade</h3>
<div class="outline-text-3" id="text-orgaa7ddee">
<p>
A causalidade define que um sistema causal é aquele que não depende de
entradas futuras.  Isto é, um sistema é causal se, para todo \(n_0\),
o valor da saída em \(n=n_0\), depende somente dos valores da entrada
en \(n \leq n_0\).
</p>

<div class="LATEX" id="causalidade:teorema">
\begin{equation} \label{causalidade:teorema}
x_1[n] = x_2[n], n \leq n_0 \Rightarrow y_1[n] = y_2[n], n \leq n_0
\end{equation}

</div>

<p>
O acumulador, por exemplo, é causal pois depende apenas das entradas
anteriores para calcular os próximos sinais.
</p>
</div>
</div>

<div id="outline-container-org05af708" class="outline-3">
<h3 id="org05af708">Estabilidade</h3>
<div class="outline-text-3" id="text-org05af708">
<p>
Para um sistema ser estável ele precisa ter uma saída e entrada
limitada <sup><a id="fnr.2" class="footref" href="#fn.2">2</a></sup>.
</p>

<div class="LATEX" id="estabilidade:teorema">
\begin{equation} \label{estabilidade:teorema}
| x[n] | \leq B_x < \infty \quad \forall n \Rightarrow | y[n] | \leq B_y |
< \infty \quad \forall n
\end{equation}

</div>

<p>
Na qual \(B_x, B_y > 0\) são números positivos finitos.
</p>

<ul class="org-ul">
<li>O conceito de estabilidade de um sistema não dependente do tipo de entrada.</li>
<li>Um dado sistema pode produzir uma saída limitada apenas para um número restrito
de entradas limiitadas. Nesse caso, o sistema <b>não é estável</b>.</li>
<li>Sistemas estáveis produzem saídas limitadas para <b>todo</b> tipo de entrada
limitada.</li>
</ul>
</div>
</div>
</div>

<div id="outline-container-org832cbbc" class="outline-2">
<h2 id="org832cbbc">Convolução de Sinais Discreto no Tempo</h2>
<div class="outline-text-2" id="text-org832cbbc">
<p>
Sistemas convolucionais. Uma convolução é realizada entre dois sinais
e gera um novo sinal. Uma das interpretações intuitivas é que ao
transladar uma das funções em relação a outra, é calculado a média
móvel em relação a área de intersecção desses dois sinais.  Para
calcular a convolução de sinais é necessário realizar algumas
operações primárias, sendo que de fato a convolução é uma soma
infinita de impulsos ponderados deslocados no tempo.
</p>

<p>
Primeiramente devemos entender que sistemas lineares invariantes no
tempo podem ser caracterizados completamente por sua resposta ao
impulso. Através de alguns artifícios matemáticos, obtem-se:
</p>

<div class="LATEX" id="convolucao:eq1">
\begin{equation} \label{convolucao:eq1}
\begin{aligned}
y[n] = T\{x[n]\} = T\{\sum_{k=-\infty}^\infty x[k]\delta[n - k]\} \\
y[n] = \sum_{k=-\infty}^\infty x[k]T\{\delta[n - k]\} \\ y[n] =
\sum_{k=-\infty}^\infty x[k]h[n - k] = x[n] * h[n]
&& \text{(soma de convolução)} \\
\end{aligned}
\end{equation}

</div>

<p>
Dado que pela invariância no tempo: \(T\{\delta[n]\}=h[n] \Rightarrow
T\{\delta[n-k]\}=h[n-k]\).
</p>

<p>
Os passos para calcular a operação de convolução são:
</p>

<ol class="org-ol">
<li>Refletir \(h[k]\) em torno da origem para obter \(h[-k]\)</li>
<li>Obter \(h[n-k]\) deslocando a sequência refletida até \(k=n\)</li>
<li>Multiplicar \(h[n-k]\) por \(x[k]\)</li>
</ol>

<p>
As propriedades definidas para a convolução são:
</p>

<ul class="org-ul">
<li>Comutatividade: \((f * g)[n] = (g * f)[n]\)</li>
<li>Distributividade sobre a adição)</li>
<li>Associação em série (a própria convolução)</li>
<li>Associação em paralelo (som a de sinais)</li>
</ul>


<div id="orgf7127b7" class="figure">
<p><img src="/assets/posts/pds/convolucao.png" alt="convolucao.png" />
</p>
<p><span class="figure-number">Figure 1: </span>Exemplo de convolução contínua no tempo entre uma função exponencial descrescente e a função degrau.</p>
</div>

<p>
No final geralmente temos um PG para se calcular. Onde pode ser uma PG
infinita convergente, ou uma PG simples finita. Para as duas as
fórmulas são conhecidas.
</p>
</div>


<div id="outline-container-org5939cfd" class="outline-3">
<h3 id="org5939cfd">Exercício sobre convolução</h3>
<div class="outline-text-3" id="text-org5939cfd">
<p>
Exercício 2.3: Encontre a resposta ao degrau dado a resposta ao
impulso a seguir:
</p>

<div class="LATEX">
<p>
\[h[n] = a^{-n}u[-n] \quad 0 < a < 1 \]
</p>

</div>

<p>
Resposta: De acordo com a definição de soma de convolução na
(Eq. <a href="#orgefcf601">1</a>), é importante lembrar também que a operação de
convolução é um operador que suporta comutatividade. O que será
importante nessa análise.
</p>

<p>
Podemos inicialmente analisar essa soma da seguinte maneira:
</p>

<div class="LATEX">
\begin{equation*}
\begin{aligned}
x[n] &= u[n] \\ h[-k] &= a^{k}u[k] \\ h[n -k] &= a^{k -n}u[k -n] \\
y[n] &= x[n] * h[n] = \sum_{k=-\infty}^\infty u[k]a^{k -n}u[k -n] \\
\end{aligned}
\end{equation*}

</div>

<p>
Se \(n < 0\) então, \(u[n -k] = 1\) para \(k \geq 0\).  Não interessa
para \(k < 0\) pois \(u[k] = 0\). Logo, reescrevendo a expressão temos
que para \(n < 0\):
</p>

<div class="LATEX">
\begin{equation*}
\begin{aligned}
y[n] &= \sum_{k=-\infty}^{-1} u[k]a^{k -n}u[k -n] + \sum_{k=0}^\infty
u[k]a^{k -n}u[k -n] \\
     &= 0 + \sum_{k=0}^\infty a^{k -n} \\ &= \sum_{k=0}^\infty
     a^{-n}a^k \\ &= a^{-n}\sum_{k=0}^\infty a^k \\ &=
     a^{-n}\sum_{k=0}^\infty a^k
\end{aligned}
\end{equation*}

</div>

<p>
Onde \(\sum_{k=0}^\infty a^k\) é a progressão geométrica infinita, tal
como \(0 < a < 1\), equivalente a \(\dfrac{1}{(1 - a)}\). Portanto,
através do desenvolvimento anterior temos que para \(n < 0\):
</p>

<div class="LATEX" id="convolucao:exemplo23-solucao1">
\begin{equation} \label{convolucao:exemplo23-solucao1}
y[n] = \dfrac{a^{-n}}{1 - a}
\end{equation}

</div>

<p>
Não podemos usar a mesma convolução acima definida entre \((x *
h)[n]\) para \(n \geq 0\) devido ao fato que o resultante disso seria
uma progressão geométrica condicionada da existência de seus termos
somente para \(k \geq n\), do contrário o termo é nulo por conta da
função degrau \(u[k -n]\).  Nesse caso, é um grande problema pois
\(\forall n \in \mathbb{Z}\) a sequência está definida e não incluindo
todos os elementos na soma isto não será propriamente uma soma de
progressão geométrica.
</p>

<p>
No entanto ao aplicar a propriedade da comutatividade da convolução
podemos contornar este problema.  Ao aplicar a propriedade de
comutatividade, temos que para \(n \geq 0\):
</p>

<div class="LATEX" id="convolucao:exemplo23-solucao2">
\begin{equation} \label{convolucao:exemplo23-solucao2}
\begin{aligned}
y[n] &= x[n] * h[n] = h[n] * x[n] \\
     &= \sum_{k=-\infty}^\infty h[k]x[n - k] \\ &=
     \sum_{k=-\infty}^\infty a^{-k}u[-k]u[n -k] \qquad \text (k > 0
     \Rightarrow u[-k] = 0) \\ &= \sum_{k=-\infty}^0 a^{-k}u[n -k]
     \qquad \text (k \leq 0 \land n \geq 0 \Rightarrow u[n -k] = 1)
     \\ &= \sum_{k=-\infty}^0 a^{-k} \\ &= \dfrac{1}{1-a} \\
\end{aligned}
\end{equation}

</div>

<p>
Como \(k \leq 0 \Rightarrow -k \geq 0\), portanto a mesma relação de
PG vale no último passo.  Dessa maneira, finalmente temos que através
de (Eq. <a href="#org74ba9a6">1</a>) e
(Eq. <a href="#org38e256f">1</a>) a convolução desses dois sinais é
dado como:
</p>

<div class="LATEX" id="convolucao:exemplo23-solucao-final">
\begin{equation}
y[n] =
\begin{cases}
\dfrac{1}{1 -a} \quad \text{se} \ n \geq 0 \\ \dfrac{a^{-n}}{1-a}
\quad \text{se} \ n < 0 \\
\end{cases}
\end{equation}

</div>
</div>
</div>

<div id="outline-container-orgd356594" class="outline-3">
<h3 id="orgd356594">Relação: Transformada de Laplace e Convolução</h3>
<div class="outline-text-3" id="text-orgd356594">
<p>
A convolução e a transformada de Laplace possuí algumas propriedades
interessantes, entre elas, durante a transformada de Laplace, a
convolução se torna apenas uma multiplicação das transformadas de
Laplace das funções individuais. No nosso contexto de PDS, sinais.
</p>

<p>
A Transformada de Laplace transforma um sinal dependente do tempo para
o domínio da frequência. Como é um assunto muito extenso, com muitas
propriedades e implicações, irei deixar isso de lado por enquanto.
Talvez no livro eu ache mais algum contexto relevante para aplicação
em PDS.
</p>

<p>
Dado que a Transformada de Laplace no tempo contínuo é dada como:
</p>

<div class="LATEX">
\begin{equation}
F(s) = \mathcal{L}\{f\}(s) =\int_0^\infty e^{-st} f(t)\,dt.
\end{equation}

</div>
</div>
</div>
</div>


<div id="outline-container-orgcd78fea" class="outline-2">
<h2 id="orgcd78fea">Equações de Diferenças</h2>
<div class="outline-text-2" id="text-orgcd78fea">
<p>
Equações de diferenças podem ser usadas para implementar sistemas que
podem ter duração infinita ao impulso infinita ou simplesmente para o
fazê-los de maneira mais eficiente.
</p>

<p>
Tendo o citado acima m mente, é importante comentar que existem dois
tipos de sistemas LTI:
</p>

<ul class="org-ul">
<li>FIR (<i>finite-duration impulse response</i>) \(\Rightarrow\) RI de duração finita;</li>
<li>IIR (<i>infinte-duration impulse response</i>) \(\Rightarrow\) RI de duração infinita.</li>
</ul>

<p>
Sistemas FIR são sempre estáveis (RI tem sempre soma das magnitudes
finita).
</p>

<p>
Nem todo sistema IIR é estável, \(|h[n]|\) deve ser absolutamente
somável.
</p>

<p>
Um bom exemplo de IIR estável é a resposta impulso do último exemplo
sobre convolução feito em <a href="#org5939cfd">Exercício sobre convolução</a>.
</p>
</div>

<div id="outline-container-org02f76ce" class="outline-3">
<h3 id="org02f76ce">A equação de recorrência</h3>
<div class="outline-text-3" id="text-org02f76ce">
<p>
Uma implementação de sistema por equações de diferenças, tem sua
representação numa equação de recorrência (recursiva). Um bom exemplo
é uma implementação mais eficiente do acumulador, dado como: \(y[n] =
x[n] + y[n-1]\).
</p>

<p>
Analogamente, é possível definir também a média móvel através de uma
equação de recorrência:
</p>

<div class="LATEX">
<p>
\[h[n] = \dfrac{1}{M_2 + 1} (u[n] - u[n - M_2 -1])\]
</p>

</div>

<p>
Um problema tanto relevante é que como uma recorrência é definida em
termo de valores já calculados, logo é necessário sabermos todos os
valores para \(n' < n\) e então ser possível calcular a
sequência. Logo uma equação de recorrência é sempre um sistema com
memória (posso afirmar isso?).
</p>
</div>
</div>

<div id="outline-container-org7eef6e1" class="outline-3">
<h3 id="org7eef6e1">Relação com equações diferenciais (caso contínuo)</h3>
<div class="outline-text-3" id="text-org7eef6e1">
<p>
As equações de diferenças são definidas no tempo discreto. O que
conhecemos de equações diferenciais isto está definido no contexto do
domínio contínuo. Mas as ideias entre ambas operações são muito
semelhantes.
</p>
</div>
</div>

<div id="outline-container-org287ba1e" class="outline-3">
<h3 id="org287ba1e">Solução homogênea(natural) e particular (forçada)</h3>
<div class="outline-text-3" id="text-org287ba1e">
<p>
A solução homogênea, embora não necessária nesse curso, refere-se ao
contexto de que um sistema possui uma condição inicial. A solução
homogênea não depende da entrada, pois a entrada é zero. Isso é um
ponto negativo em LTI, pois isso o torna um sistema variante no tempo
e também não é linear. O que de fato não queremos.
</p>

<p>
Num contexto de circuítos elétricos, uma solução homogênea lembra
problemas como exemplo o comportamento de um circuito RC (Resistor -
Capacitor) em que sua energia inicial é não-nula.
</p>

<p>
A resposta forçada e particular é justamente a que temos interesse, na
qual é 'forçado' um sinal em relação a resposta. Nesse caso a resposta
particular é linear e invariante no tempo.
</p>

<p>
A solução geral da saída do sistema é descrita como:
</p>
<div class="LATEX" id="equacoes-diferencas:solucao-geral">
<p>
\[ y[n] = y_h[n] + y_p[n] \]
</p>

</div>
<p>
Sendo que a equação para solução homogênea é a solução de:
</p>

<div class="LATEX">
<p>
\[ \sum_{k=0}^N a_k y[n-k] = 0 \]
</p>

</div>
</div>
</div>
</div>


<div id="outline-container-org4d1af4e" class="outline-2">
<h2 id="org4d1af4e">Representação no domínio da frequência</h2>
<div class="outline-text-2" id="text-org4d1af4e">
<p>
Um sistema pode ser caracterizado por sua frequência, um exemplo é
aplicar a entrada de \(x[n] = e^{jwn}\) para \(n \in (-\infty,
\infty)\).
</p>

<p>
A resposta ao impulso para a entrada dada é:
</p>

<div class="LATEX">
\begin{equation}
\begin{aligned}
y[n] &= \sum_{k=-\infty}^{\infty} h[k] \cdot e^{jw(n -k)} \\
     &= e^{-jwn}(\sum_{k=-\infty}^{\infty} h[k] \cdot e^{-jwk})
\end{aligned}
\end{equation}

</div>

<p>
É observável que o somatório entre parenteses nada mais é que uma
constante.  Pois não depende da entrada \(n\), ou seja não depende do
tempo! No entanto, ela varia em torno da frequência, essa entidade é
conhecida como <b>resposta em frequência</b>.
</p>

<p>
Essa propriedade ocorre pois a exponencial complexa é uma autofunção,
sendo a autofunção a exponencial complexa que está fora do
somatório e o próprio somatório no final o autovalor.
</p>

<p>
Uma propriedade importante é que durante a aplicação de um sistema em
domínio da frequência, a frequência não muda, apenas a fase e a
amplitude desse sinal. O que é uma propriedade muito desejada em
projeto de filtros.
</p>
</div>

<div id="outline-container-org59c25c7" class="outline-3">
<h3 id="org59c25c7">Resposta em frequência</h3>
<div class="outline-text-3" id="text-org59c25c7">
<p>
Definição de resposta em frequência, como descrito na seção anterior,
tem-se que:
</p>

<div class="LATEX">
\begin{equation}
H(e^{j\omega}) = \sum_{k=-\infty}^{\infty} h[k] \cdot e^{-jwk}
\end{equation}

</div>

<p>
Logo o sinal se torna:
</p>

<div class="LATEX">
\begin{equation}
y[n] = e^{j\omega n} \cdot H(e^{j\omega})
\end{equation}

</div>

<p>
Onde \(H(e^{j\omega})\) é o autovalor. Esta operação é periódica com
período \(2\pi\).
</p>
</div>
</div>

<div id="outline-container-orgf5428ed" class="outline-3">
<h3 id="orgf5428ed">Transformada de Fourier (TF)</h3>
<div class="outline-text-3" id="text-orgf5428ed">
<p>
A transforma de Fourier no contexto de processamento digital de sinais
é usada para representar um sistema de domínio do tempo para domínio
da frequência. Uma propriedade interessante é que a exponencial
complexa é uma autofunção. Isso quer dizer que se um sinal de entrada
é uma exponencial complexa, a saída do sistema será também uma
exponencial complexa multiplicada por uma constante.
</p>

<p>
Isso simplifica todo o trabalho muito complicado de lidar com
diferentes tipos de convolução de sinais discreto no tempo. Pois, ao
transformar um sinal para o domínio da frequência usando a
Transformada de Fourier, nosso sinal fica em função da frequência em
relação a exponenciais complexas. Sendo assim, para aplicar um sistema
temos apenas que lidar com operações simples de multiplicações de
exponenciais complexas.
</p>

<p>
A transformada de Fourier de um sinal qualquer é dada para um sinal
\(x[n]\):
</p>

<div class="LATEX">
\begin{equation}
X(e^{j\omega}) = \sum_{n=-\infty}^{\infty} x[n]e^{-j\omega n}
\end{equation}

</div>

<p>
Também conhecida como uma operação de análise.
</p>
</div>
</div>
<div id="outline-container-org47d6943" class="outline-3">
<h3 id="org47d6943">Transformada de Fourier Inversa (TFI)</h3>
<div class="outline-text-3" id="text-org47d6943">
<p>
A operação de reconstrução do sinal, voltando ao domínio real e
discreto é feito através de uma integral complexa. A
transformada de Fourier é definida como \(\mathcal{F}:
\mathbb{R} \rightarrow \mathbb{C}\) e \(\mathcal{F}^{-1}: \mathbb{C}
\rightarrow \mathbb{R}\).
</p>

<p>
Sendo que a fórmula para síntese, reconstrução do sinal da a
transformada de Fourier, é equivalente a:
</p>

<div class="LATEX">
\begin{equation}
x[n] = \dfrac{1}{2\pi} \int_{-\pi}^{\pi} X(e^{j \omega})e^{j \omega
n}d \omega
\end{equation}

</div>

<p>
Sendo que para nosso caso a entrada da transformação \(\mathcal{F}\) é
<b>discreta</b> mas após a transformação é <b>contínua</b> e <b>complexa</b>!
</p>
</div>
</div>
</div>


<div id="outline-container-orgf3d2772" class="outline-2">
<h2 id="orgf3d2772">Referências</h2>
<div class="outline-text-2" id="text-orgf3d2772">
<ul class="org-ul">
<li>OPPENHEIM; ALAN, 1999, Discrete-Time Signal Processing 2nd Edition</li>
<li>DINIZ; PAULO, 2010, Digital Signal Processing System Analysis and Design 2nd Edition</li>
</ul>
</div>
</div>
<div id="footnotes">
<h2 class="footnotes">Footnotes: </h2>
<div id="text-footnotes">

<div class="footdef"><sup><a id="fn.1" class="footnum" href="#fnr.1">1</a></sup> <div class="footpara"><p class="footpara">
Sim, não pesquisei ainda sobre isso. O professor apenas comentou em aula sobre isso
após eu ter perguntado. Se você souber me diz.
</p></div></div>

<div class="footdef"><sup><a id="fn.2" class="footnum" href="#fnr.2">2</a></sup> <div class="footpara"><p class="footpara">
não pode crescer indefinitivamente.
</p></div></div>


</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="mathematics" /><summary type="html"><![CDATA[Sistemas e Sinais Discretos no Tempo]]></summary></entry><entry><title type="html">Aprendendo F#</title><link href="https://lerax.me/programming/fsharp/" rel="alternate" type="text/html" title="Aprendendo F#" /><published>2017-08-20T00:00:00+00:00</published><updated>2017-08-20T00:00:00+00:00</updated><id>https://lerax.me/programming/fsharp</id><content type="html" xml:base="https://lerax.me/programming/fsharp/"><![CDATA[<link rel="stylesheet"
      href="/assets/css/style.css"
      type="text/css"/>


<div id="outline-container-orgd316ce9" class="outline-2">
<h2 id="orgd316ce9">Descrição</h2>
<div class="outline-text-2" id="text-orgd316ce9">
<p>
Este arquivo contém notas pessoais sobre aprendizado do ecossistema de F#.
</p>
</div>
</div>

<div id="outline-container-org7392442" class="outline-2">
<h2 id="org7392442">Setup</h2>
<div class="outline-text-2" id="text-org7392442">
</div>
<div id="outline-container-orgfdf9d06" class="outline-3">
<h3 id="orgfdf9d06">Pacotes instalados no Manjaro</h3>
<div class="outline-text-3" id="text-orgfdf9d06">
<p>
Atualmente tenho instalados o mono junto com trocentas coisas. Aliás, embora
isso não tenha nada a ver, é somente com o monodevelop que estou conseguindo
definitivamente usar F# [1]. Não dei jeito ainda no meu emacs. Vou verificar depois
se consigo usar.
</p>

<p>
Mas para instalar o .NET Core precisei dos seguintes pacotes que estão no AUR:
</p>

<ul class="org-ul">
<li>dotnet-sdk-2.0</li>
<li>dotnet-host</li>
<li>dotnet-runtime-1.1</li>
<li>dotnet-sdk-1.1</li>
</ul>

<p>
Já instalei tanta coisa que nem sei mais o que é realmente necessário. Mas, bem,
na verdade o setup mais estável que consegui foi instalando os seguintes pacotes
do AUR:
</p>

<ul class="org-ul">
<li>dotnet-host (cli dotnet, cross-sdk manager)</li>
<li>dotnet-runtime-1.1</li>
<li>dotnet-sdk-1.1 (actually 1.0.4)</li>
</ul>


<p>
De resto estou conseguindo me virar.
</p>

<p>
[1]: Na verdade estou conseguindo usar o Emacs e VS code também. Só tenho
problemas com o MonoDevelop na hora de usar .NET Core quando faz referências
a pacotes do paket. O Emacs estou tendo problemas apenas com os templates usados
pelo .NET Core SDK 1.0.4. VS Code está supostamente funcionando tudo, tirando a parte
que ele me dá kernel panic.
</p>
</div>
</div>
<div id="outline-container-org2e18907" class="outline-3">
<h3 id="org2e18907">Mudar entre múltiplas versões do SDK de .NET Core</h3>
<div class="outline-text-3" id="text-org2e18907">
<p>
É possível definir a versão por projeto do .NET Core, criando um arquivo
<code>global.json</code> na raíz do projeto:
</p>

<div class="org-src-container">
<pre class="src src-json">{
  <span style="color: #51afef;">"projects"</span>: [ <span style="color: #7bc275;">"src"</span>, <span style="color: #7bc275;">"test"</span> ],
  <span style="color: #51afef;">"sdk"</span>: {
    <span style="color: #51afef;">"version"</span>: <span style="color: #7bc275;">"1.0.4"</span>
  }
}
</pre>
</div>

<p>
Inclusive é a que estou usando atualmente pra mexer com Fable. Pois simplesmente
a versão 2.0 preview está com muitos problemas e não é recomendada pelo pessoal
do fable. Na verdade, eles até falam que é possível fazer desenvolvimento do projeto,
embora recomendem usar o SDK 1.0.4, no entanto simplesmente os templates não funcionam.
Queria apenas um template que funcionasse&#x2026;
</p>

<p>
EDIT <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-08-16 Wed 06:55&gt;</span></span>:
Isso na verdade gera um outro problema, que é do cache ficar sendo repopulado toda
vez que é chamado. Não sei se corrigiu recentemente, mas estava tendo sérios problemas com isso!
Se eu precisar novamente fazer isso e vê que não funciona setar o <code>global.json</code>, venho comentar isso aqui.
</p>
</div>
</div>

<div id="outline-container-org13ccde3" class="outline-3">
<h3 id="org13ccde3">Issues com .NET Core</h3>
<div class="outline-text-3" id="text-org13ccde3">
</div>
<div id="outline-container-orgddf51b1" class="outline-4">
<h4 id="orgddf51b1">Bugs com múltiplos SDKs instalados</h4>
<div class="outline-text-4" id="text-orgddf51b1">
<p>
Usar ao mesmo tempo sdk 2.0 e 1.0.4 dá merda. Embora haja a opção pra
a definir a versão por projeto, simplesmente toda vez que chamo o
comando <code>dotnet new</code> é populado o diretório cache de pacotes do nuget
e outras coisas SEMPRE. E isso é beeeem demorado. Leva quase 2 minutos.
Executar um comando recorrente que leva 2 minutos é simplesmente
inviável.
</p>
</div>
</div>

<div id="outline-container-orgd0e8028" class="outline-4">
<h4 id="orgd0e8028">Inviabilidade de usar SDK 1.0.4 em alguns casos</h4>
<div class="outline-text-4" id="text-orgd0e8028">
<p>
Outro ponto infeliz é que simplesmente os templates para F# PRATICAMENTE
de todos que testei estão cagados na versão SDK 1.0.4. Simplesmente os arquivos
.fsproj são legacy, não funcionam na hora de dar build nem com os comandos
do .NET core. O xbuild também não funciona pela linha de comando nem pelo
emacs. Por outro lado, como última alternativa, o comando `msbuild` funciona.
Mas não o do .NET Core (dotnet msbuild), somente o do mono [1].
</p>

<p>
EDIT <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-08-06 Sun 06:10&gt;</span></span>: parece que esse problema específico já foi
reportado, e para minha alegria está com a tag wont-fix, QUE MARAVILHA.
Isto foi corrigido no SDK 2.0, mas o fable não deixa eu usar o sdk 2.0&#x2026;
De qualquer maneira, aqui está: <a href="https://github.com/dotnet/netcorecli-fsc/issues/91">dotnet/netcorecli-fsc/issues/91</a>.
</p>

<p>
Além do mais eu também criei minha própria issue no dotnet/cli.
Aqui está: <a href="https://github.com/dotnet/cli/issues/7378">dotnet/cli/issues/7378</a>
</p>

<p>
Eles falaram que Fsharp.Net.SDK foi deprecated e é também a causa desse problema.
</p>

<p>
[1]: NOTA às <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-08-16 Wed 06:52&gt;</span></span>:
esse comando não vem por padrão no mono! só pude usar na minha máquina
porque tenho o MonoDevelop instalado e por dependência ele instala o pacote do AUR
<code>msbuild-15-bin</code>
</p>
</div>
</div>

<div id="outline-container-org2218a87" class="outline-4">
<h4 id="org2218a87">Fable Template só funciona com a versão 1.0.4: conflito com sdk 2.0</h4>
<div class="outline-text-4" id="text-org2218a87">
<p>
Pra minha felicidade o fable template só tá funcionando com justamente a versão
do SDK 1.0.4, que embora seja a estável, simplesmente tá com os templates bem cagados
de F#.
</p>

<p>
Aparentemente eles mudaram recentemente a estrutura do projeto e talvez isso
tenha tido algum efeito colateral. Esta <a href="https://github.com/fable-compiler/Fable/issues/1042">issue</a> descreve o que estou comentando.
</p>

<p>
EDIT <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-08-06 Sun 07:09&gt;</span></span>: fazendo uma pergunta diretamente pra issue anterior,
recebi uma resposta que removendo a referencencia de Fsharp.Net.SDK dos arquivos
de .fsproj e references resolve esse problema. Estou ainda re-instalando os arquivos
para saber se isso irá mesmo corrigir. Isso está relacionado com
Inviabilidade de usar 1.0.4 em alguns casos.
</p>

<p>
EDIT2 <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-08-06 Sun 09:17&gt;</span></span>: infelizmente a dica do carinha não funcionou e
ainda não consigo rodar o projeto com o SDK 2.0 preview 2. :(
Sinceramente estou pensando em dropar plenamente o SDK 2.0 e fazer uns
alias pros comandos que não funcionarem apontando para o certo. Como
`alias dotnet build` =&gt; msbuild do mono kkk
Mas isso não vai dar muito certo&#x2026;
</p>

<p>
EDIT3 <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-08-16 Wed 06:44&gt;</span></span>: finalmente foi lançado na <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-08-14 Mon&gt;</span></span>
.NET Core 2.0 e ainda tive problemas relatado com esse <i>heading</i>. Na verdade
o problema é mais profundo e está relacionado a shared frameworks. Quando tenho
shared framework de SDK 1.0.4 e 2.0.0, com runtimes 1.1.2 e 2.0.0, Fable
aponta para a versão 1.0.4 DO RUNTIME que não existe. Embora instalando o runtime
1.0.4 também não funcione e a razão está descrita <a href="https://github.com/dotnet/cli/issues/6390">dotnet/cli/issues/6390</a>.
No entanto, um workaround possível é fazer um link simbólico do runtime 1.1.2 para
o 1.0.4 (e claro removendo esse runtime). Em geral apenas fazendo isso corrige:
</p>

<div class="org-src-container">
<pre class="src src-shell-script"><span style="color: #C57BDB;">cd</span> /opt/dotnet/shared/Microsoft.NETCore.App
sudo ln -s 1.1.2 1.0.4
</pre>
</div>
</div>
</div>

<div id="outline-container-orge68a915" class="outline-4">
<h4 id="orge68a915">MonoDevelop e Fable</h4>
<div class="outline-text-4" id="text-orge68a915">
<p>
Uma alternativa pra criar projetos de console seria usar o MonoDevelop + Mono.
Mas, o MonoDevelop também NÃO ESTÁ FUNCIONANDO com o Fable porque simplesmente
não consegue reconhecer as dependências setadas pelo paket.
</p>

<p>
Configurei o paket pra rodar no MonoDevelop como um addin, mas também não está
funcionando. Simplesmente ele congela ao tentar fazer <code>fetch</code> das dependências.
Além disso, a entrada `clitool dotnet-fable` não é reconhecida pelo parser.
Sendo que isto está definido em paket.dependencies e é crucial para fazer
build do projeto.
</p>

<p>
Se faço <code>dotnet restore</code> pela linha de comando, mesmo funcionando pela linha de
comando o build do projeto com <code>dotnet fable yarn-start</code>, SIMPLESMENTE o
MonoDevelop não reconhece todas as referências, explicitamente as que estão
setadas pelo paket.references. Desse modo além de não dar pra fazer build no
MonoDevelop, não tenho também autocomplete.
</p>
</div>
</div>

<div id="outline-container-org364269f" class="outline-4">
<h4 id="org364269f">Emacs e F#</h4>
<div class="outline-text-4" id="text-org364269f">
<p>
O autocomplete no emacs simplesmente só funciona quando quer. Não entendo
mais nada. Mas com o Fable nunca funcionou. Quando funciona é somente com
os projetos gerados pelo MonoDevelop (não pelos templates do .NET Core e
dotnet new). EDIT <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-08-06 Sun 05:29&gt;</span></span>: por alguma razão ele começou a funcionar! D:
</p>
</div>
</div>
</div>
</div>
<div id="outline-container-org9cd7ff4" class="outline-2">
<h2 id="org9cd7ff4">Syntax</h2>
<div class="outline-text-2" id="text-org9cd7ff4">
</div>
<div id="outline-container-orge8b7f13" class="outline-3">
<h3 id="orge8b7f13">Funções, tuplas e pattern matching</h3>
<div class="outline-text-3" id="text-orge8b7f13">
<p>
A maioria dos métodos de F# que fazem wrapping na API da .NET
não são funções com múltiplos argumentos, mas sim tuplas. Isso
pode ser confuso no começo, mas é assim que funciona no ecossistema
de F#. O tipo <code>int * int</code> denota uma tupla de inteiros (int, int).
Enquanto na notação de tipos <code>int -&gt; int</code> é uma função curry que recebe
uma parâmetro int e retorna int.
</p>


<div class="org-src-container">
<pre class="src src-fsharp"><span style="color: #51afef;">open</span> <span style="color: #FCCE7B;">System.Net</span>

<span style="color: #62686E;">// </span><span style="color: #62686E;">usando tuplas como argumento (url, file) e definindo uma fun&#231;&#227;o curry</span>
<span style="color: #62686E;">// </span><span style="color: #62686E;">do tipo: string -&gt; string -&gt; unit</span>
<span style="color: #51afef;">let</span> <span style="color: #5cEfFF;">download</span> (<span style="color: #DFDFDF;">url</span>:<span style="color: #FCCE7B;">string</span>) (<span style="color: #DFDFDF;">file</span>:<span style="color: #FCCE7B;">string</span>) = <span style="color: #51afef;">new</span> WebClient().DownloadFile(url, file<span style="color: #ff665c; background-color: #1c1f24; font-weight: bold;">)</span>

download <span style="color: #7bc275;">"www.google.com"</span> <span style="color: #7bc275;">"google.html"</span> <span style="color: #62686E;">// </span><span style="color: #62686E;">faz download de um arquivo</span>

</pre>
</div>

<p>
Curried functions são muito úteis por causa da possibilidade de fazer
partial application. Onde você passa apenas alguns dos primeiros parâmetros
e então uma nova função é definida. Um exemplo simples é dado a seguir:
</p>

<div class="org-src-container">
<pre class="src src-fsharp"><span style="color: #51afef;">open</span> <span style="color: #FCCE7B;">System</span>

<span style="color: #C57BDB; font-weight: bold;">[&lt;EntryPoint&gt;]</span>
<span style="color: #51afef;">let</span> <span style="color: #5cEfFF;">main</span> <span style="color: #DFDFDF;">argv</span> =
  <span style="color: #51afef;">let</span> <span style="color: #DFDFDF;">print</span> = printfn <span style="color: #7bc275;">"%d"</span> <span style="color: #62686E;">// </span><span style="color: #62686E;">canonical print</span>
  [1..10] <span style="color: #87cefa;">|&gt;</span> List.map print <span style="color: #87cefa;">|&gt;</span> ignore

</pre>
</div>
</div>
</div>

<div id="outline-container-org87a02be" class="outline-3">
<h3 id="org87a02be">Funções recursivas</h3>
<div class="outline-text-3" id="text-org87a02be">
<p>
Uma função recursiva recebe a keyword <code>rec</code> antes da definição.
</p>

<div class="org-src-container">
<pre class="src src-fsharp"><span style="color: #51afef;">let</span> <span style="color: #51afef;">rec</span> <span style="color: #5cEfFF;">fat</span> <span style="color: #DFDFDF;">n</span> =
    <span style="color: #51afef;">match</span> n <span style="color: #51afef;">with</span>
    <span style="color: #87cefa;">|</span> 1 <span style="color: #87cefa;">|</span> 0 -&gt; 1
    <span style="color: #87cefa;">|</span> _ -&gt; n * fat (n - 1)
</pre>
</div>

<p>
A precisão de entrada e saída, por padrão é Int32.
</p>
</div>
</div>

<div id="outline-container-org49ede0d" class="outline-3">
<h3 id="org49ede0d">Sequências, Listas e Arrays</h3>
<div class="outline-text-3" id="text-org49ede0d">
<p>
Em F# há três tipos de coleções usadas:
</p>

<ul class="org-ul">
<li>Seq</li>
<li>List</li>
<li>Array</li>
</ul>

<p>
List e Array possuem a diferença em que Arrays possuem tamanho
fixo, mas acesso constante. Listas possuem tamanhos arbitrários, mas por outro lado
o acesso é O(n).
</p>

<p>
Sequências são definidas como lazy lists, onde os elementos são avaliados
de forma preguiçosa. Um bom exemplo é um algoritmo para cálculo de números
primos de forma assíncrona:
</p>

<div class="org-src-container">
<pre class="src src-fsharp"><span style="color: #62686E;">/// </span><span style="color: #62686E;">A simple prime number detector</span>
<span style="color: #51afef;">let</span> <span style="color: #5cEfFF;">isPrime</span> (<span style="color: #DFDFDF;">n</span>:<span style="color: #FCCE7B;">int</span>) =
   <span style="color: #51afef;">let</span> <span style="color: #DFDFDF;">bound</span> = int (sqrt (float n))
   seq {2 .. bound} <span style="color: #87cefa;">|&gt;</span> Seq.forall (<span style="color: #51afef;">fun</span> <span style="color: #DFDFDF;">x</span> -&gt; n % x &lt;&gt; 0)

<span style="color: #62686E;">// </span><span style="color: #62686E;">We are using async workflows</span>
<span style="color: #51afef;">let</span> <span style="color: #5cEfFF;">primeAsync</span> <span style="color: #DFDFDF;">n</span> =
    <span style="color: #51afef;">async</span> { <span style="color: #51afef;">return</span> (n, isPrime n) }

<span style="color: #62686E;">/// </span><span style="color: #62686E;">Return primes between m and n using multiple threads</span>
<span style="color: #51afef;">let</span> <span style="color: #5cEfFF;">primes</span> <span style="color: #DFDFDF;">m</span> <span style="color: #DFDFDF;">n</span> =
    seq {m .. n}
        <span style="color: #87cefa;">|&gt;</span> Seq.map primeAsync
        <span style="color: #87cefa;">|&gt;</span> Async.Parallel
        <span style="color: #87cefa;">|&gt;</span> Async.RunSynchronously
        <span style="color: #87cefa;">|&gt;</span> Array.filter snd
        <span style="color: #87cefa;">|&gt;</span> Array.map fst

<span style="color: #62686E;">// </span><span style="color: #62686E;">Run a test</span>
primes 1000000 1002000
    <span style="color: #87cefa;">|&gt;</span> Array.iter (printfn <span style="color: #7bc275;">"%d"</span>)
</pre>
</div>
</div>
</div>
</div>

<div id="outline-container-orgf6a6241" class="outline-2">
<h2 id="orgf6a6241">Ecosystem</h2>
<div class="outline-text-2" id="text-orgf6a6241">
</div>
<div id="outline-container-org8ed81e4" class="outline-3">
<h3 id="org8ed81e4">Web Development</h3>
<div class="outline-text-3" id="text-org8ed81e4">
<ul class="org-ul">
<li>Giraffe é um webframework funcional para F#</li>
<li>Fable é usado para fazer transpiler de JS</li>
</ul>

<p>
Ou seja, Giraffe é recomendado para fazer backend em F#
e Fable frontend.
</p>
</div>
</div>

<div id="outline-container-org332232f" class="outline-3">
<h3 id="org332232f">API .NET Core</h3>
<div class="outline-text-3" id="text-org332232f">
<p>
Algumas coisas úteis que encontrei na API do .NET core:
</p>

<ul class="org-ul">
<li><code>System.IO.GetTempPath</code> retorna <code>/tmp</code></li>
</ul>
</div>
</div>
</div>

<div id="outline-container-org37b1048" class="outline-2">
<h2 id="org37b1048">Tooling</h2>
<div class="outline-text-2" id="text-org37b1048">
</div>
<div id="outline-container-orgd055089" class="outline-3">
<h3 id="orgd055089">Forge</h3>
<div class="outline-text-3" id="text-orgd055089">
<p>
Quem está me salvando ultimamente para criação de projetos na linha de comando
é o <code>Forge</code>. Um sistema de gerenciamento de projetos/soluções criado para
atuar em conjunto com o FAKE(build system de F#) e Paket, o gerenciador
de dependências.
</p>

<p>
Em geral você cria uma solução, então cria um projeto anexado a essa solução.
Quero ainda ver se é possível criar um projeto sem precisar criar uma solução,
mas não tenho certeza ainda se é possível.
</p>
</div>

<div id="outline-container-orgea9467b" class="outline-4">
<h4 id="orgea9467b">Forge add reference não funciona com o Nuget</h4>
<div class="outline-text-4" id="text-orgea9467b">
<p>
Algo que me deixou um pouco confuso foi o comando <code>forge add reference</code> que
só pode ser usado para referências locais, como <code>System.Drawing</code>.
Se for uma dependência externa, geralmente gerenciada pelo paket, deve ser adicionada
da seguinte maneira: forge paket <code>add -i Nuget Some.Dependency</code>
</p>

<p>
Não há pretensão de isso ser incluido como uma feature por quebra de design, já
que é algo que o paket faz. Esta <a href="https://github.com/fsharp-editing/Forge/issues/33">issue</a> descreve exatamente este problema.
</p>
</div>
</div>


<div id="outline-container-orgcaa4967" class="outline-4">
<h4 id="orgcaa4967">Adicionar um asset não compilável para fsproj</h4>
<div class="outline-text-4" id="text-orgcaa4967">
<p>
É necessário adicionar uma entrada semelhante a essa ao .fsproj
</p>

<div class="org-src-container">
<pre class="src src-xml">&lt;<span style="color: #5cEfFF;">Content</span> <span style="color: #DFDFDF;">Include</span>=<span style="color: #7bc275;">"Template.json"</span>&gt;
    &lt;<span style="color: #5cEfFF;">CopyToOutputDirectory</span>&gt;PreserveNewest&lt;/<span style="color: #5cEfFF;">CopyToOutputDirectory</span>&gt;
&lt;/<span style="color: #5cEfFF;">Content</span>&gt;
</pre>
</div>

<p>
Fiz uma issue perguntando se é possível fazer isso diretamente usar o forge.
Resta esperar uma resposta.
</p>

<p>
EDIT: <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-08-09 Wed 11:20&gt;</span></span>
Ainda não é possível fazer isso. <a href="https://github.com/fsharp-editing/Forge/issues/75">https://github.com/fsharp-editing/Forge/issues/75</a>
Embora seja possível fazer algo semelhante com a flag:
<code>--build-action Content</code> na qual a tag criada será &lt;Content&gt; invés de &lt;Compile&gt;.
Mas ainda não adicionará a tag &lt;CopyToOutputDirectory&gt; para copiar na compilação.
De toda maneira, vou ter que editar esses arquivos nojentos de projeto da Microsoft.
</p>
</div>
</div>
</div>
<div id="outline-container-org5c063d5" class="outline-3">
<h3 id="org5c063d5">Dotnet Self-Contained Apps</h3>
<div class="outline-text-3" id="text-org5c063d5">
<p>
Então, environment .NET Core é simplesmente infernal, como fazer
com que o seu <i>target host</i> não sofra o mesmo? Microsoft pensou nisso
considerando a dor descomunal que é ter uma instalação do .NET. Então
provê um meio de disponibilizar aplicações que contém o próprio
runtime.
</p>

<p>
Para exemplo desse tópico estarei criando um aplicação hello-world de
exemplo baseado no template console pra F#. Estou assumindo aqui que
esteja sendo usado .NET Core SDK 2.0 e o runtime também. Legacy is
dead.
</p>

<div class="org-src-container">
<pre class="src src-sh">dotnet new console -lang <span style="color: #7bc275;">'f#'</span> -n test
</pre>
</div>

<p>
Isto irá cria uma nova aplicação já pronta em <code>test/</code> com o seguinte
arquivo <code>Program.fs</code>:
</p>

<div class="org-src-container">
<pre class="src src-fsharp" id="org2740a65"><span style="color: #51afef;">open</span> <span style="color: #FCCE7B;">System</span>

<span style="color: #C57BDB; font-weight: bold;">[&lt;entryPoint&gt;]</span>
<span style="color: #51afef;">let</span> <span style="color: #5cEfFF;">main</span> <span style="color: #DFDFDF;">argv</span> =
    printfn <span style="color: #7bc275;">"Hello World, F#!"</span>
    0 <span style="color: #62686E;">// </span><span style="color: #62686E;">return an integer exit code</span>
</pre>
</div>

<p>
Isso funciona até bem, mas infelizmente eu tenho alguns problemas que
realmente me incomoda um bucado. Um desses problemas envolve a uma
certa necessidade de instalar dependências na máquina host. As que
precisei instalar explicitamente pra funcionar foram no Ubuntu Xenial
(16.04) <code>libicu-dev</code> e <code>libunwind8</code>. É importante também lembrar que
o aplicativo publicado fica em <code>/&lt;conf&gt;/&lt;runtime/publish</code>. Isso embora
pareça óbvio, eu me confundi inicialmente pq é compilado também na
raíz do runtime outra versão que não sei nem pq existe lá&#x2026;
</p>

<p>
Mas então, voltando aos passos, foi necessário os seguintes:
</p>

<div class="org-src-container">
<label class="org-src-name"><span class="listing-number">Listing 1: </span>Dependências necessárias para executar o self-contained app</label><pre class="src src-sh" id="org16e1003">sudo apt install libunwind8 libicu-dev
</pre>
</div>


<p>
Sendo que o procedimento de rele
</p>

<div class="org-src-container">
<pre class="src src-sh">dotnet publish -c Release -r ubuntu.16.04-x64 --self-contained
</pre>
</div>

<p>
A flag <code>--self-contained</code> parece fazer pouco sentido no começo, tendo
em vista que <code>publish</code> deveria já fazer isso de toda maneira, mas no
entanto não é o comportamento padrão. Se eu não passar essa flag, a
aplicação será apenas free-framework e dependências, mas ainda
precisará do runtime do .NET Core.
</p>


<p>
Eu ainda não achei uma forma de listar os runtimes disponíveis pela
linha de comando e se quer achei também uma documentação clara sobre
isso.
</p>

<p>
O que me incomoda ainda é o fato de eu ainda ter que instalar algumas
coisas no host para a <i>self-contained application</i> funcionar como é o
esperado. Se é <i>self-contained</i> porque eu tenho que instalar alguma
coisa a mais no host? Isso é muito chato&#x2026;
</p>


<p>
Uma compilação <i>self-contained</i> não é nada leve. É cerca de <b>70MB</b> puro
e uns <b>24MB</b> com <code>.tar.gz</code>, algoritmo de compactação <code>gzip</code>.
Por que tanto sofrimento?
</p>

<p>
Referências de problemas:
</p>

<ul class="org-ul">
<li><a href="https://github.com/dotnet/cli/issues/3390">Self-contained applications in Linux does not work</a></li>
<li><a href="https://github.com/dotnet/core/blob/master/Documentation/self-contained-linux-apps.md">Self-contained Linux applications</a></li>
<li><a href="https://github.com/dotnet/core/blob/master/Documentation/build-and-install-rhel6-prerequisites.md">How to use .NET Core on RHEL 6 / CentOS 6</a> (fala sobre embarcar third-libraries)</li>
</ul>
</div>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="programming" /><summary type="html"><![CDATA[Um breve relato de aventura entre Mono e .NET Core]]></summary></entry><entry><title type="html">Java - compilação e execução na linha de comando</title><link href="https://lerax.me/programming/java-command-line/" rel="alternate" type="text/html" title="Java - compilação e execução na linha de comando" /><published>2017-08-17T13:50:00+00:00</published><updated>2017-08-17T13:50:00+00:00</updated><id>https://lerax.me/programming/java-command-line</id><content type="html" xml:base="https://lerax.me/programming/java-command-line/"><![CDATA[<link rel="stylesheet"
      href="/assets/css/style.css"
      type="text/css"/>


<div id="outline-container-orgf771bb1" class="outline-2">
<h2 id="toc-org"><a id="orgf771bb1"></a>Sumário</h2>
<div class="outline-text-2" id="text-toc-org">
<ul class="org-ul">
<li><a href="#org9f2d55e">Descrição</a></li>
<li><a href="#org0ae4b3f">Ambiente</a></li>
<li><a href="#orgc9ff81a">Compilação</a></li>
<li><a href="#org2fe9e62">Execução</a></li>
<li><a href="#org1bc3233">Geração e execução de arquivos .jar</a>
<ul class="org-ul">
<li><a href="#orgf80bfea">Definir classe principal através do arquivo MANIFEST.mf</a></li>
<li><a href="#org0bc486c">Definir classe principal como argumento</a></li>
<li><a href="#org71315f2">Execução arquivo .jar</a></li>
</ul></li>
<li><a href="#org413cfd0">Referências</a></li>
</ul>
</div>
</div>

<div id="outline-container-org9f2d55e" class="outline-2">
<h2 id="org9f2d55e">Descrição</h2>
<div class="outline-text-2" id="text-org9f2d55e">
<p>
Este documento pretende demonstrar como é possível escrever um simples
programas em Java sem a necessidade de uso de uma IDE e a criação
de todo um projeto. O que pode ser muito útil pra execução de um rápido
exemplo ou no caso de uma IDE de Java não estar
disponível no sistema. Este tutorial foi inspirado em uma resposta dada
no Stack Overflow <a href="#orgc4d5684">{1}</a>.
</p>
</div>
</div>

<div id="outline-container-org0ae4b3f" class="outline-2">
<h2 id="org0ae4b3f">Ambiente</h2>
<div class="outline-text-2" id="text-org0ae4b3f">
<p>
Você deve ter instalado no seu sistema o <code>JDK</code> (Java Developer Kit), sendo
que esse tutorial foi testado através da <code>jdk8-openjdk</code> no Linux.
</p>

<p>
Além disso, os binários <code>java</code>, <code>jar</code> e <code>javac</code> devem estar presentes através
da variável de ambiente <code>PATH</code>, onde a configuração disso pode variar pra cada
sistema operacional. Tutorias na internet podem ser encontrados facilmente sobre como fazer isso no Linux
<a href="#org331c771">{2}</a> e Windows <a href="#orgaacba23">{3}</a>.
</p>
</div>
</div>

<div id="outline-container-orgc9ff81a" class="outline-2">
<h2 id="orgc9ff81a">Compilação</h2>
<div class="outline-text-2" id="text-orgc9ff81a">
<p>
Primeiramente você precisa escrever uma classe de exemplo.
</p>

<div class="org-src-container">
<pre class="src src-java"><span style="color: #51afef;">public</span> <span style="color: #51afef;">class</span> <span style="color: #FCCE7B;">HelloWorld</span> {
    <span style="color: #51afef;">public</span> <span style="color: #51afef;">static</span> <span style="color: #FCCE7B;">void</span> <span style="color: #5cEfFF;">main</span>(<span style="color: #FCCE7B;">String</span>[] <span style="color: #DFDFDF;">args</span>) {
        System.out.println(<span style="color: #7bc275;">"Hello world!"</span>)
    }
}
</pre>
</div>

<ol class="org-ol">
<li>Salve este arquivo como: <code>HelloWorld.java</code>.</li>
<li>Compile com: <code>javac HelloWorld.java</code>.</li>
</ol>

<p>
Isso irá criar um arquivo intermediário chamado <code>HelloWorld.class</code>
no mesmo diretório que foi chamado o comando anterior. A seguir é demonstrado
uma sequência de passos feitas em um terminal Linux [1].
</p>

<div class="org-src-container">
<pre class="src src-shell-script">$ cat &gt; HelloWorld.java
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println(<span style="color: #7bc275;">"Hello world!"</span>)
    }
}
$ javac HelloWorld.java
$ ls
HelloWorld.java HelloWorld.class
</pre>
</div>

<p>
[1]: <code>$</code> é apenas um carácter do terminal que indica o tipo de usuário
que está logado (nesse caso um usuário normal). Para forçar a saída do comando <code>cat</code> pressione
<code>Ctrl-D</code> pra emitir um <code>EOF</code> (<i>End of File</i>).
</p>
</div>
</div>

<div id="outline-container-org2fe9e62" class="outline-2">
<h2 id="org2fe9e62">Execução</h2>
<div class="outline-text-2" id="text-org2fe9e62">
<p>
A execução pode ser feita de uma maneira simples: <code>java HelloWorld</code>.
</p>

<div class="org-src-container">
<pre class="src src-shell-script">&gt; java HelloWorld
Hello world!
</pre>
</div>


<p>
Embora isso pareça estranho, pois não há nenhum arquivo <code>HelloWorld</code>
no seu diretório, o programa <code>java</code> espera que seja passado o nome da classe a ser executado e não
o arquivo <code>HelloWorld.class</code>.
</p>

<p>
Se você ingenuamente chamar <code>java HelloWorld.class</code> um erro será retornado:
</p>

<div class="org-src-container">
<pre class="src src-shell-script">&gt; java HelloWorld.class
Error: Could not find or load main class HelloWorld.class
</pre>
</div>
</div>
</div>

<div id="outline-container-org1bc3233" class="outline-2">
<h2 id="org1bc3233">Geração e execução de arquivos .jar</h2>
<div class="outline-text-2" id="text-org1bc3233">
<p>
Para criar um <i>bytecode</i> <code>.jar</code> que possa ser distribuído livremente, você tem duas alternativas:
escrever um arquivo <code>MANIFEST.mf</code> especificando a classe <i>Main</i> ou passando o nome da classe <i>Main</i>
para a linha de comando. Para criar um arquivo <code>.jar</code> você deve previamente já ter passado pelo
processo de compilação explicado na seção <a href="#orgc9ff81a">Compilação</a>, pois será necessário os arquivos <code>.class</code>.
</p>

<p>
Estarei exemplificando aqui os dois modos. Ambos no final irão gerar um
arquivo <code>HelloWorld.jar</code>.
</p>
</div>

<div id="outline-container-orgf80bfea" class="outline-3">
<h3 id="orgf80bfea">Definir classe principal através do arquivo MANIFEST.mf</h3>
<div class="outline-text-3" id="text-orgf80bfea">
<ol class="org-ol">
<li>Crie um arquivo <code>MANIFEST.mf</code> com apenas a linha <code>Main-Class: HelloWorld</code></li>
<li>Execute: <code>jar -cvfm HelloWorld.jar MANIFEST.mf HelloWorld.class</code></li>
</ol>
</div>
</div>

<div id="outline-container-org0bc486c" class="outline-3">
<h3 id="org0bc486c">Definir classe principal como argumento</h3>
<div class="outline-text-3" id="text-org0bc486c">
<ol class="org-ol">
<li>Execute: <code>jar -cvfe HelloWorld.jar HelloWorld HelloWorld.class</code></li>
</ol>
</div>
</div>


<div id="outline-container-org71315f2" class="outline-3">
<h3 id="org71315f2">Execução arquivo .jar</h3>
<div class="outline-text-3" id="text-org71315f2">
<p>
Para executar o arquivo <code>.jar</code> gerado execute.
</p>

<div class="org-src-container">
<pre class="src src-shell-script">$ java -jar HelloWorld.jar
Hello world!

</pre>
</div>
</div>
</div>
</div>


<div id="outline-container-org413cfd0" class="outline-2">
<h2 id="org413cfd0">Referências</h2>
<div class="outline-text-2" id="text-org413cfd0">
<ol class="org-ol">
<li><a id="orgc4d5684"></a> Stack Overflow, <a href="https://stackoverflow.com/questions/16137713/how-do-i-run-a-java-program-from-the-command-line-on-windows">How do I run a Java program from the command line on Windows</a>,
acesso em 17 de agosto de 2017.</li>
<li><a id="org331c771"></a> Viva o Linux,  <a href="https://www.vivaolinux.com.br/dica/Configurando-JDK-no-PATH-no-Linux-qualquer-distro">Configurando JDK no PATH no Linux qualquer distro</a>,
acesso em 17 de agosto de 2017.</li>
<li><a id="orgaacba23"></a> Java at Point, <a href="https://www.javatpoint.com/how-to-set-path-in-java">How to set path in java</a>,
acesso em 17 de agosto de 2017.</li>
</ol>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="programming" /><summary type="html"><![CDATA[Uma alternativa às IDE gulosas de Java]]></summary></entry><entry><title type="html">C++ Journey</title><link href="https://lerax.me/programming/cpp-journey/" rel="alternate" type="text/html" title="C++ Journey" /><published>2017-07-26T14:48:00+00:00</published><updated>2017-07-26T14:48:00+00:00</updated><id>https://lerax.me/programming/cpp-journey</id><content type="html" xml:base="https://lerax.me/programming/cpp-journey/"><![CDATA[<link rel="stylesheet"
      href="/assets/css/style.css"
      type="text/css"/>


<div id="outline-container-org9275f8f" class="outline-2">
<h2 id="toc-org"><a id="org9275f8f"></a>Tabela de Conteúdos</h2>
<div class="outline-text-2" id="text-toc-org">
<ul class="org-ul">
<li><a href="#org85a8674">Descrição</a></li>
<li><p>
<a href="#org20a38a0">HackerRank C++</a>
</p>
<ul class="org-ul">
<li><a href="#org5827cc2">The Type String</a></li>
<li><a href="#orgdfbf251">Streams</a></li>
<li><a href="#orgfa5433e">Attribute Parser</a></li>
</ul>
<ul class="org-ul">
<li><a href="#orgb3bdd50">Orientação a Objetos</a>
<ul class="org-ul">
<li><a href="#org988de22">Introdução</a></li>
<li><a href="#org9520052">Structs</a></li>
<li><a href="#org035eeef">Básico de Classes</a></li>
<li><a href="#org4afe0bb">Class constructors</a></li>
<li><a href="#orgbaa1a11">Exceptions</a></li>
<li><a href="#org5405fcb">Polymorphism and Abstract Base Classes</a></li>
</ul></li>
<li><a href="#org9ae1db9">Inheritance</a>
<ul class="org-ul">
<li><a href="#orgdf57fcc">Inheritance Introduction</a></li>
<li><a href="#orge23efb8">Rectangle Area</a></li>
<li><a href="#org375a563">Multi Level Inheritance</a></li>
<li><a href="#orgacf9b9f">Accessing Inherited Functions</a></li>
<li><a href="#orgdc23bd2">Magic Spells</a></li>
</ul></li>
<li><a href="#org52df3bc">STL - C++ Standard Library</a>
<ul class="org-ul">
<li><a href="#org0b36f92">Vector Sort</a></li>
<li><a href="#orgd096e87">Vector-Erase</a></li>
<li><a href="#org3ea81fe">Lower Bound</a></li>
<li><a href="#orgbb82af9">Sets</a></li>
<li><a href="#org13404ac">Maps</a></li>
<li><a href="#org961a552">Print Pretty</a></li>
<li><a href="#orgf0a0f5c">Deque</a></li>
</ul></li>
</ul></li>
<li><a href="#org20b6816">C++ prime checking</a></li>
<li><a href="#orgbba1fee">Estudos de caso</a>
<ul class="org-ul">
<li><a href="#org03ee752">Listas de inicialização para construtores</a></li>
<li><a href="#org4a30211">Separadores de escopo <code>::</code> e <code>.</code></a></li>
</ul></li>
</ul>
</div>
</div>

<div id="outline-container-org85a8674" class="outline-2">
<h2 id="org85a8674">Descrição</h2>
<div class="outline-text-2" id="text-org85a8674">
<p>
Minha jornada com C++ no HackerRank principalmente e outras coisas. Na maioria
das questões não uso todos os recursos de <code>C++14</code>, mas às vezes sim. Assume-se,
por via das dúvidas, que todos arquivos estão no padrão <code>C++14</code>.
</p>
</div>
</div>

<div id="outline-container-org20a38a0" class="outline-2">
<h2 id="org20a38a0">HackerRank C++</h2>
<div class="outline-text-2" id="text-org20a38a0">
</div>
<div id="outline-container-org5827cc2" class="outline-4">
<h4 id="org5827cc2">The Type String</h4>
<div class="outline-text-4" id="text-org5827cc2">
<p>
CLOSED: <span class="timestamp-wrapper"><span class="timestamp">[2017-07-05 Wed 16:04]</span></span>
</p>
<p>
Diferentemente de C, C++ implementa um tipo string não somente como uma cadeia
de caracteres, mas como um objeto. Possui métodos associados, como `string::length`.
É bem útil e menos difícil de tratar que <i>strings</i> em C, que são apenas vetores de caracteres.
</p>


<div class="org-src-container">
<pre class="src src-C++"><span style="color: #62686E;">// </span><span style="color: #62686E;">inicializa&#231;&#227;o de string</span>
<span style="color: #FCCE7B;">string</span> <span style="color: #DFDFDF;">a</span> = <span style="color: #7bc275;">"abc"</span>;
<span style="color: #62686E;">// </span><span style="color: #62686E;">tamanho</span>
a.size()
<span style="color: #62686E;">// </span><span style="color: #62686E;">concatena&#231;&#227;o</span>
<span style="color: #FCCE7B;">string</span> <span style="color: #DFDFDF;">b</span> = <span style="color: #7bc275;">"def"</span>
string c = a + b; <span style="color: #62686E;">// </span><span style="color: #62686E;">"abcdef"</span>

</pre>
</div>

<p>
O primeiro exercício do HackerRank:
</p>

<div class="org-src-container">
<pre class="src src-C++"><span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;iostream&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;string&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;algorithm&gt;</span>
<span style="color: #51afef;">using</span> <span style="color: #51afef;">namespace</span> <span style="color: #a991f1;">std</span>;

<span style="color: #FCCE7B;">int</span> <span style="color: #5cEfFF;">main</span>() {
    <span style="color: #FCCE7B;">string</span> <span style="color: #DFDFDF;">a</span>,<span style="color: #DFDFDF;">b</span>;
    cin &gt;&gt; a;
    cin &gt;&gt; b;
    cout &lt;&lt; a.size() &lt;&lt; <span style="color: #7bc275;">" "</span> &lt;&lt; b.size() &lt;&lt; endl;
    cout &lt;&lt; a + b &lt;&lt; endl;
    <span style="color: #FCCE7B;">char</span> <span style="color: #DFDFDF;">temp</span> = a[0];
    a[0] = b[0];
    b[0] = temp;
    cout &lt;&lt; a &lt;&lt; <span style="color: #7bc275;">" "</span> &lt;&lt; b &lt;&lt; endl;

    <span style="color: #51afef;">return</span> 0;
}

</pre>
</div>


<p>
Lidando com tamanho, concatenação e substituição de caracteres
em <code>strings</code>.
</p>
</div>
</div>

<div id="outline-container-orgdfbf251" class="outline-4">
<h4 id="orgdfbf251">Streams</h4>
<div class="outline-text-4" id="text-orgdfbf251">
<p>
SCHEDULED: <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-07-05 Wed&gt;</span></span>
</p>
<p>
Esse tópico refere-se ao gerenciamento de <i>stream</i> usando <i>strings</i>
para C++. Muito interessante. O operador &lt;&lt; insere informação,
por outro lado, o operador &gt;&gt; extrai informação.
</p>


<p>
O método de inicialização da <code>stringstream</code> cria uma <i>stream</i>. O cabeçalho é <code>&lt;sstream&gt;</code>.
<a href="https://github.com/ryukinix/cpp-journey/tree/master/Strings/strings-2.cpp">HackerRank-Problem-String</a>
O método <code>sstream::eof</code> verifica se a <i>stream</i> está no fim. <code>EOF</code> = End Of File.
</p>
</div>
</div>

<div id="outline-container-orgfa5433e" class="outline-4">
<h4 id="orgfa5433e">Attribute Parser</h4>
<div class="outline-text-4" id="text-orgfa5433e">
<p>
SCHEDULED: <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-07-05 Wed&gt;</span></span>
</p>
<p>
Nessa atividade, a última de <i>strings</i>, vou precisar fazer um <i>parser</i> de atributos
em CancerPlusPlus (aka C++). Um pouco da descrição do site é dada no <i>block</i> de código abaixo.
</p>

<div class="org-src-container">
<pre class="src src-xml">We have defined our own markup language HRML. In HRML, each element consists of
a starting and ending tag, and there are attributes associated with each tag.
Only starting tags can have attributes. We can call an attribute by referencing
the tag, followed by a tilde, '~' and the name of the attribute.
The tags may also be nested.

Sample Input

4 3
&lt;<span style="color: #5cEfFF;">tag1</span> <span style="color: #DFDFDF;">value</span> = <span style="color: #7bc275;">"HelloWorld"</span>&gt;
&lt;<span style="color: #5cEfFF;">tag2</span> <span style="color: #DFDFDF;">name</span> = <span style="color: #7bc275;">"Name1"</span>&gt;
&lt;/<span style="color: #5cEfFF;">tag2</span>&gt;
&lt;/<span style="color: #5cEfFF;">tag1</span>&gt;
tag1.tag2~name
tag1~name
tag1~value

Sample Output

Name1
Not Found!
HelloWorld
</pre>
</div>

<p>
A atividade está sendo desenvolvida no arquivo:
<a href="https://github.com/ryukinix/cpp-journey/tree/master/Strings/strings-3-attribute-parser.cpp">Attribute Parser</a>
</p>

<p>
Já estou há várias horas resolvendo esse problema. Sinceramente é um pouco
trabalhoso. Agora é <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-07-06 Thu 01:50&gt;</span></span>. Já se passou mais de 8 horas&#x2026;
que inferno! Mas eu dormi um pouco antes também. Cassete! terminei agora depois
de 14 horas! Uma completa desgraça!
</p>

<p>
QUE INFERNO!!!!!! TERMINEI!!!!
</p>

<p>
Primeiramente interpretei o problema um tanto errado, pensando que a primeira
tag seria a raíz da árvore. O que deu bastante problema para contornar.
Após isso havia vários erros, como o não tratamento de espaços antes das chaves,
como indentação. Isso não parece ter nenhum efeito durante a correção. Mas
só fui perceber todos os erros após conseguir o SUITE TESTCASE #4 de um
repositório do github. O problema central, depois de corrigir a modelagem errada,
era em relação ao método de pesquisa.
**
</p>
</div>
</div>
<div id="outline-container-orgb3bdd50" class="outline-3">
<h3 id="orgb3bdd50">Orientação a Objetos</h3>
<div class="outline-text-3" id="text-orgb3bdd50">
</div>
<div id="outline-container-org988de22" class="outline-4">
<h4 id="org988de22">Introdução</h4>
<div class="outline-text-4" id="text-org988de22">
<p>
SCHEDULED: <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-07-05 Wed&gt;</span></span>
</p>
<p>
Estou fazendo alguns exercícios de C++ no HackerRank. Até agora não estou
com muitos problemas. Na verdade C++ não é tão difícil quanto eu pensei.
De fato, na verdade, eu nunca tinha parado pra olhar direito como era a
linguagem e só ficava de tretinha básica.
</p>

<p>
OO em C++ parece ser divertido, apesar de ainda ter uma impressão <i>cancerígina</i>.
Não é pra menos&#x2026; <i>keywords</i>, <code>friend</code>, <code>public</code>, <code>private</code> e <code>protected</code>?
Mas, enfim, acho que vou conseguir me acostumar. Quero terminar hoje ainda a
introdução, estou na última parte envolvendo OO, herança e variáveis estáticas.
</p>

<p>
Método virtuais em C++ são usados para fazer polimorfismo dinâmicos em heranças.
<i>Protected</i> são membros acessíveis apenas pelas subclasses. <i>Private</i> são
acessíveis apenas pelos métodos da classe. <i>Public</i> são publicos para todos.
</p>

<p>
Por padrão, membros e métodos são privados em classes. Para fazer um membro ou
método público você deve o fazer explicitamente com a keyword <code>public</code> e o uso
de dois pontos <code>:</code>. É possível usar a <i>keyword</i> <code>friend</code> para acessar atributos
privados de outra classe. Provavelmente eu não deveria
estar falando desses tópicos avançados de OO na introdução (HAHA!). Mas
é bom que dá o gostinho de desgraça que C++ tem tanto de especial.
</p>
<div class="org-src-container">
<pre class="src src-C++"><span style="color: #51afef;">const</span> <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">NUMBER_OF_MARKS</span> = 6;

<span style="color: #51afef;">class</span> <span style="color: #FCCE7B;">Person</span> {
<span style="color: #51afef;">protected</span>:
    <span style="color: #FCCE7B;">string</span> <span style="color: #DFDFDF;">name</span>;
    <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">age</span>;
<span style="color: #51afef;">public</span>:
    <span style="color: #51afef;">virtual</span> <span style="color: #FCCE7B;">void</span> <span style="color: #5cEfFF;">putdata</span>(<span style="color: #FCCE7B;">void</span>){};
    <span style="color: #51afef;">virtual</span> <span style="color: #FCCE7B;">void</span> <span style="color: #5cEfFF;">getdata</span>(<span style="color: #FCCE7B;">void</span>){};
};

<span style="color: #51afef;">class</span> <span style="color: #FCCE7B;">Professor</span>: <span style="color: #51afef;">public</span> <span style="color: #FCCE7B;">Person</span> {
<span style="color: #51afef;">private</span>:
    <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">publications</span>;
    <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">cur_id</span>;
<span style="color: #51afef;">public</span>:
    <span style="color: #51afef;">static</span> <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">count</span>;
    <span style="color: #5cEfFF;">Professor</span>(<span style="color: #FCCE7B;">void</span>){
        cur_id = count + 1;
        count += 1;
    }
    <span style="color: #51afef;">virtual</span> <span style="color: #FCCE7B;">void</span> <span style="color: #5cEfFF;">putdata</span>(<span style="color: #FCCE7B;">void</span>) {
        <span style="color: #62686E;">// </span><span style="color: #62686E;">The function putdata should print the name, age,</span>
        <span style="color: #62686E;">// </span><span style="color: #62686E;">publications and the cur_id of the professor.</span>
        cout &lt;&lt; name &lt;&lt; <span style="color: #7bc275;">" "</span>;
        cout &lt;&lt; age &lt;&lt; <span style="color: #7bc275;">" "</span>;
        cout &lt;&lt; publications &lt;&lt; <span style="color: #7bc275;">" "</span>;
        cout &lt;&lt; cur_id &lt;&lt; endl;
    }

    <span style="color: #51afef;">virtual</span> <span style="color: #FCCE7B;">void</span> <span style="color: #5cEfFF;">getdata</span>(<span style="color: #FCCE7B;">void</span>) {
        cin &gt;&gt; name;
        cin &gt;&gt; age;
        cin &gt;&gt; publications;
    }
};

<span style="color: #51afef;">class</span> <span style="color: #FCCE7B;">Student</span>: <span style="color: #51afef;">public</span> <span style="color: #FCCE7B;">Person</span> {
<span style="color: #51afef;">private</span>:
    <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">marks</span>[NUMBER_OF_MARKS];
    <span style="color: #FCCE7B;">int</span> <span style="color: #5cEfFF;">_sum_marks</span>() {
        <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">total</span> = 0;
        <span style="color: #51afef;">for</span> (<span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">i</span> = 0; i &lt; NUMBER_OF_MARKS; i++) {
            total += marks[i];
        }
        <span style="color: #51afef;">return</span> total;
    }
    <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">cur_id</span>;
<span style="color: #51afef;">public</span>:
    <span style="color: #51afef;">static</span> <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">count</span>;
    <span style="color: #5cEfFF;">Student</span>(<span style="color: #FCCE7B;">void</span>) {
        cur_id = count + 1;
        count += 1;
    }
    <span style="color: #51afef;">virtual</span> <span style="color: #FCCE7B;">void</span> <span style="color: #5cEfFF;">putdata</span>(<span style="color: #FCCE7B;">void</span>) {
        <span style="color: #62686E;">// </span><span style="color: #62686E;">The function putdata should print the name, age,</span>
        <span style="color: #62686E;">// </span><span style="color: #62686E;">sum of the marks and the cur_id of the student.</span>
        cout &lt;&lt; name &lt;&lt; <span style="color: #7bc275;">" "</span>;
        cout &lt;&lt; age &lt;&lt; <span style="color: #7bc275;">" "</span>;
        cout &lt;&lt; _sum_marks() &lt;&lt; <span style="color: #7bc275;">" "</span>;
        cout &lt;&lt; cur_id &lt;&lt; endl;

    }

    <span style="color: #51afef;">virtual</span> <span style="color: #FCCE7B;">void</span> <span style="color: #5cEfFF;">getdata</span>(<span style="color: #FCCE7B;">void</span>) {
        cin &gt;&gt; name;
        cin &gt;&gt; age;
        <span style="color: #51afef;">for</span> (<span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">i</span> = 0; i &lt; NUMBER_OF_MARKS; i++){
            cin &gt;&gt; marks[i];
        }

    }

};

<span style="color: #FCCE7B;">int</span> <span style="color: #a991f1;">Professor</span>::<span style="color: #DFDFDF;">count</span> = 0;
<span style="color: #FCCE7B;">int</span> <span style="color: #a991f1;">Student</span>::<span style="color: #DFDFDF;">count</span> = 0;

</pre>
</div>

<p>
Construtores podem ser definidos uma ou várias vezes.
No entanto, destrutores só podem ser definidos uma vez.
</p>
</div>
</div>

<div id="outline-container-org9520052" class="outline-4">
<h4 id="org9520052">Structs</h4>
<div class="outline-text-4" id="text-org9520052">
<p>
SCHEDULED: <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-07-06 Thu&gt;</span></span>
</p>
<p>
Os structs em C++ são semelhantes de C, no entanto eles são como classes
com membros e métodos públicos por padrão. Usualmente structs são usados apenas
para agrupar membros de variáveis numa estrutura compartilhada, podendo assim,
criar estrutura de dados mais complexas.
</p>
</div>
</div>

<div id="outline-container-org035eeef" class="outline-4">
<h4 id="org035eeef">Básico de Classes</h4>
<div class="outline-text-4" id="text-org035eeef">
<p>
SCHEDULED: <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-07-05 Wed&gt;</span></span>
</p>
<p>
Por padrão classes tem seus métodos e atributos privados, sendo reservado as
keywords para controle de acesso: <code>protected</code>, <code>private</code> e <code>public</code>.
Uma prática comum em C++ é deixar todos os atributos privados ou protegidos
(case for uma classe base de herança), então criar <i>getters</i> e <i>setters</i> públicos.
</p>

<p>
Um exemplo de código abaixo é dado:
</p>

<div class="org-src-container">
<pre class="src src-C++"><span style="color: #51afef;">class</span> <span style="color: #FCCE7B;">Student</span> {
<span style="color: #51afef;">private</span>:
    <span style="color: #FCCE7B;">string</span> <span style="color: #DFDFDF;">name</span>;
    <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">age</span>;
<span style="color: #51afef;">public</span>:
    <span style="color: #FCCE7B;">string</span> <span style="color: #5cEfFF;">get_mame</span>() {
        <span style="color: #51afef;">return</span> name;
    }

    <span style="color: #FCCE7B;">string</span> <span style="color: #5cEfFF;">get_age</span>() {
        <span style="color: #51afef;">return</span> age;
    }

    <span style="color: #FCCE7B;">void</span> <span style="color: #5cEfFF;">set_name</span>(<span style="color: #FCCE7B;">string</span> <span style="color: #DFDFDF;">new_name</span>) {
        name = new_name;
    }

    <span style="color: #FCCE7B;">void</span> <span style="color: #5cEfFF;">set_age</span>(<span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">new_age</span>) {
        age = new_age;
    }
}

</pre>
</div>
</div>
</div>

<div id="outline-container-org4afe0bb" class="outline-4">
<h4 id="org4afe0bb">Class constructors</h4>
<div class="outline-text-4" id="text-org4afe0bb">
<p>
SCHEDULED: <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-07-06 Thu&gt;</span></span>
</p>

<p>
Construtores são chamados na inicialização de uma classe. Podem possuir um ou mais,
com diferentes assinaturas.
Os tipos de construtores são três:
</p>

<ol class="org-ol">
<li>Construtor padrão</li>
<li>Construtor parametrizado</li>
<li>Construtor de cópia</li>
</ol>

<p>
Exemplo: <a href="https://github.com/ryukinix/cpp-journey/tree/master/Classes/constructor.cpp">ConstructorsExample.cpp</a>
</p>
</div>
</div>

<div id="outline-container-orgbaa1a11" class="outline-4">
<h4 id="orgbaa1a11">Exceptions</h4>
<div class="outline-text-4" id="text-orgbaa1a11">
<p>
SCHEDULED: <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-07-06 Thu&gt;</span></span>
</p>

<p>
C++ permite criar exceções personalizadas ao criar uma herança da classe
<code>exception</code>. O método descritivo da exceção é <code>const char* what(){}</code>.
Uma atividade simples foi feita em: <a href="https://github.com/ryukinix/cpp-journey/tree/master/Classes/exception.cpp">Exceptions.cpp</a>
Blocos <code>try/catch</code> são usados pra lidar com exceções que ocorreram.
<code>throw Exception();</code> é usado para sinalizar uma exceção.
</p>

<p>
Minha próxima atividade no HackerRank é a respeito de um servidor para
capturar exceções customizadas.
<a href="https://github.com/ryukinix/cpp-journey/tree/master/Classes/CustomExceptions.cpp">CustomExceptions.cpp</a>
</p>

<p>
Todas as exceções padrões tem como base classe <code>std::exception</code>.
Uma maneira simples de capturar uma exceção e imprimi-la, é desta maneira:
</p>

<div class="org-src-container">
<pre class="src src-C++"><span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;exception&gt;</span> <span style="color: #62686E;">// </span><span style="color: #62686E;">defini&#231;&#227;o da classe base std::exception</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;stdexcept&gt;</span> <span style="color: #62686E;">// </span><span style="color: #62686E;">v&#225;rias exce&#231;&#245;es padr&#245;es para ser usadas</span>
<span style="color: #51afef;">try</span> {
    <span style="color: #a991f1;">std</span>::cout &lt;&lt; 1/0;
} <span style="color: #51afef;">catch</span>(<span style="color: #a991f1;">std</span>::<span style="color: #FCCE7B;">exception</span> <span style="color: #51afef;">const</span>&amp; <span style="color: #DFDFDF;">e</span>) {
    <span style="color: #a991f1;">std</span>::cout &lt;&lt; <span style="color: #7bc275;">"Erro do capeta: "</span> &lt;&lt; e.what();
} <span style="color: #51afef;">catch</span>(...) {
    <span style="color: #62686E;">// </span><span style="color: #62686E;">essa sess&#227;o captura qualquer exce&#231;&#227;o n&#227;o esperada</span>
}
</pre>
</div>

<p>
Exceções definidas no cabeçalho &lt;stdexcept&gt;
</p>
<ul class="org-ul">
<li><code>bad_alloc</code></li>
<li><code>bad_cast</code></li>
<li><code>bad_exception</code></li>
<li><code>bad_typeid</code></li>
<li><code>logic_error</code>
<ul class="org-ul">
<li><code>domain_error</code></li>
<li><code>invalid_argument</code></li>
<li><code>length_error</code></li>
<li><code>out_of_range</code></li>
</ul></li>
<li><code>runtime_error</code>
<ul class="org-ul">
<li><code>range_error</code></li>
<li><code>overflow_error</code></li>
<li><code>underflow_error</code></li>
</ul></li>
</ul>
</div>
</div>
<div id="outline-container-org5405fcb" class="outline-4">
<h4 id="org5405fcb">Polymorphism and Abstract Base Classes</h4>
<div class="outline-text-4" id="text-org5405fcb">
<p>
Comecei a fazer essa atividade agora às <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-07-06 Thu 20:51&gt;</span></span>.
Polimorfismo é quando um método na herança é modificado. Em C++
existem as chamadas Classes Abstratas de Base, onde é permitido que elas
possuam apenas métodos virtuais para futuramente, numa herança, realizar
polimorfismo.
</p>

<p>
Essa última atividade é bem <i>cabulosa</i>. O objetivo é implementar um sistema
de <i>cache</i> usando listas duplamente encadeadas e, além disso, fazer de tal maneira
que use os conceitos referentes a polimorfismo numa classe chamada Cache.
</p>

<p>
As atividades a serem desenvolvidas aqui podem ser encontradas em:
<a href="https://github.com/ryukinix/cpp-journey/tree/master/Classes/AbstractPolymorphism.cpp">AbstractPolymorphism.cpp</a>.
</p>

<p>
Depois de um dia tentando ter um progresso com essa atividade, já consegui
implementar a funcionalidade básica do <code>Cache</code>. No entanto, os testes com maiores
entradas estão com problemas. De acordo com a execução do HackerRank, está
ocorrendo <code>segfault</code>. Acredito que possa ser devido o não tratamento direto
da desalocação dos objetos Nó durante a chamada de void <code>pop_node();</code> que
desaloca a cauda da lista. Contínuo essa atividade mais tarde.
</p>

<p>
De fato durante o <code>pop_node()</code>; há um vazamento de memória. A referência do objeto
é perdida, mas no entanto o objeto em si não é removido. Foi realizado uma
verificação manual na versão deste <a href="https://github.com/ryukinix/cpp-journey/tree/master/commit/bb6741d41c74cca1974bb41f3cd0f865a0d7be2c">commit</a>.
A estratégia assumida é para gerenciar corretamente a memória durante as novas
alocações.
</p>

<p>
Como eu suspeitava, a função <code>LRUCache::pop_node()</code> que estava vazando memória.
Após a adição das instruções pra desalocar tanto a cauda como também a entrada
desse nó no <code>HashMap mp</code>, os testes do HackerRank passaram. Mas demorei demais pra
fazer tudo. Quase 30 horas! Bem que no HackerRank comentava que era uma questão
difícil.
</p>
</div>
</div>
</div>

<div id="outline-container-org9ae1db9" class="outline-3">
<h3 id="org9ae1db9">Inheritance</h3>
<div class="outline-text-3" id="text-org9ae1db9">
<p>
Este é um tópico especial envolvendo como funciona o conceito de herança
em C++, todo mal da orientação objetos, como também é uma prática comum
em muitos projetos que usam linguagens como C++.
</p>

<p>
Estarei linkando nos próximos títulos os códigos-fontes de cada
solução das questões.
</p>
</div>

<div id="outline-container-orgdf57fcc" class="outline-4">
<h4 id="orgdf57fcc">Inheritance Introduction</h4>
<div class="outline-text-4" id="text-orgdf57fcc">
<p>
Nessa atividade é pedido pra construir um método de descrição de uma sub-classe
de <code>Triangle</code> chamada <code>Isosceles</code>. A construção é bem direta e não é necessário
muita explicação. É tão estúpida que até pensei em não deixar o código fonte aqui.
Mas vamos lá&#x2026; <a href="https://github.com/ryukinix/cpp-journey/tree/master/Inheritance/TriangleInheritance.cpp">TriangleInheritance.cpp</a>
</p>
</div>
</div>

<div id="outline-container-orge23efb8" class="outline-4">
<h4 id="orge23efb8">Rectangle Area</h4>
<div class="outline-text-4" id="text-orge23efb8">
<p>
Nesta atividade será feito um exercício para cálculo
da área de um retângulo usando os conceitos de herança. Durante
a construção da solução foi possível perceber que era possível
chamar métodos da classe base com mesmo nome, no caso ambos possuíam
o método <code>void display</code>, mas a instância do objeto era <code>RectangleArea</code>.
Para acessar então, <code>display</code> de <code>Rectangle</code>, foi necessário a seguinte
sintaxe:
</p>

<div class="org-src-container">
<pre class="src src-C++"><span style="color: #FCCE7B;">RectangleArea</span> <span style="color: #DFDFDF;">r_area</span>;
r_area.<span style="color: #a991f1;">Rectangle</span>::display();
</pre>
</div>

<p>
A solução completa pode ser encontrada aqui:
<a href="https://github.com/ryukinix/cpp-journey/tree/master/Inheritance/RectangleArea.cpp">RectangleArea.cpp</a>
</p>
</div>
</div>

<div id="outline-container-org375a563" class="outline-4">
<h4 id="org375a563">Multi Level Inheritance</h4>
<div class="outline-text-4" id="text-org375a563">
<p>
     É possível fazer herança em mais de um nível. Um exemplo é dado
no exercício para a construção de uma classe <code>Equilateral</code>, que deriva
de <code>Isosceles</code>, que é derivado de <code>Triangle</code>. Isso demonstra a interdependência
das propriedades que uma instância de <code>Equilateral</code> tem entre <code>Isosceles</code>
e <code>Triangle</code>. O que é realmente verdade, já que um triângulo Equilátero
é obviamente também um Triângulo e é Isósceles.
</p>

<p>
A atividade foi direta de ser completa e está descrita a seguir:
<a href="https://github.com/ryukinix/cpp-journey/tree/master/Inheritance/IsoscelesEquilateral.cpp">IsoscelesEquilateral.cpp</a>
</p>
</div>
</div>

<div id="outline-container-orgacf9b9f" class="outline-4">
<h4 id="orgacf9b9f">Accessing Inherited Functions</h4>
<div class="outline-text-4" id="text-orgacf9b9f">
<p>
     Como comentada na questão <i>Rectangle Area</i>, é possível acessar
funções/métodos da classe base que foi herdada. Nessa atividade
irei descrever brevemente a implementação do exercício proposto no
HackerRank.
</p>

<p>
A atividade é descrita em: <a href="https://github.com/ryukinix/cpp-journey/tree/master/Inheritance/AcessingInheritedFunctions.cpp">AcessingInheritedFunctions.cpp</a>
</p>

<p>
A questão pede para se chegar a um número de entrada usando apenas as classes
de base A, B e C.
</p>
</div>
</div>
<div id="outline-container-orgdc23bd2" class="outline-4">
<h4 id="orgdc23bd2">Magic Spells</h4>
<div class="outline-text-4" id="text-orgdc23bd2">
<p>
Lá vem questão <b>HARD</b> de novo diretamente do inferno no HackerRank. Essa questão
envolve o uso de herança e <code>dynamic_cast</code>, que é basicamente o que tentei fazer
uma vez em C e só me fudi &#x2013; implementar uma variável de tipo dinâmico, acabei terminando com um <code>union</code> e <code>enum</code>.
Parece que C++ implementa algo parecido do que eu desejei pra lidar com esse tipo de problema.
</p>

<p>
Nesse caso <code>dynamic_cast</code> é usado para modelar uma instância compatível com outro tipo
ou classe. Se um <code>nullptr</code> é retornado, significa que os tipos não são compatíveis.
Nessa questão isso é usado para saber que tipo de que classe derivada de <code>Spell</code>
foi instanciada. A sintaxe é dada por <code>dynamic_cast&lt;Type*&gt;(instance*)</code>. Muito
semelhante ao <i>cast</i> estático de C, embora há também <code>static_cast&lt;Type&gt;(instance)</code>.
</p>

<p>
Estou tendo alguns problemas para construir um algoritmo do tipo LCS.
Isto é: Longest Common Substring. Quando o spell é da classe Base, out seja,
um tipo de magia desconhecida, é necessário que o mago olhe no catálogo de magias
e compare o nome da magia com o que foi recebido. Dada as duas strings, a recebida
e a do catálogo, devo retornar o tamanho da substring maior.
</p>

<p>
Ou seja, é dado o exemplo que para <code>AquaVitae</code> e <code>AruTaVae</code> a maior substring é
<code>AuaVae</code>. Não tenho tanta certeza se isso está correto, mas achei um código exemplo
em C++ pra testar. Está linkado em <a href="https://github.com/ryukinix/cpp-journey/tree/master/Inheritance/LongestCommonSubstring.cpp">LongestCommonSubstring.cpp</a>
</p>

<p>
Minha desconfiança sobre isso é da natureza que esse exemplo não retorna
exatamente a maior substring e sim a maior cadeia possível em sequência, se
necessário, removendo o que tiver no meio entre elas.
</p>

<p>
Vou dar uma pausa aqui nessa atividade agora às <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-07-08 Sat 13:48&gt;</span></span>.
Depois vou tentar voltar mais tarde. A parte inicial da atividade está feita
em: <a href="https://github.com/ryukinix/cpp-journey/tree/master/Inheritance/MagicSpells.cpp">MagicSpells.cpp</a>
</p>

<p>
Estou de volta nessa atividade dos demônios. Realmente a detecção das classes
filhas ao usar dynamic cast estão funcionando bem. Na verdade dynamic cast é
um pouco diferente do que pensei, você não pode fazer conversão de tipos
arbitrários, mas sim àqueles que são possíveis. Como no caso de um instância
Pai para uma classe Filha (derivada, herdada).
</p>

<p>
No entanto estou com problemas demais em relação a desgraça do algoritmo
para de cálculo de maior substring recorrente entre duas strings, pois esse
problema de fato não é o Longest Common Substring. Vou precisar fazer um algoritmo
personalizado pra isso. Talvez eu devesse começar fazendo em Python pra facilitar
a lógica e depois passar pra Câncer++.
</p>

<p>
Agora tudo faz sentido, eu estava tentando resolver um problema com a solução
para outro tipo de problema. Esse problema na verdade tem outro nome. Apesar
de semelhante ao Longest Common Substring, este se chama Longest Common
Subsequence. Uma solução em Python transcrita de um pseudo código pode ser vista
abaixo:
</p>

<div class="org-src-container">
<pre class="src src-python"><span style="color: #51afef;">def</span> <span style="color: #5cEfFF;">LCSLength</span>(X, Y):
    <span style="color: #51afef;">from</span> pprint <span style="color: #51afef;">import</span> pprint
    <span style="color: #DFDFDF;">m</span>, <span style="color: #DFDFDF;">n</span> = <span style="color: #C57BDB;">len</span>(X) + 1, <span style="color: #C57BDB;">len</span>(Y) + 1
    <span style="color: #DFDFDF;">C</span> = [[0 <span style="color: #51afef;">for</span> _ <span style="color: #51afef;">in</span> <span style="color: #C57BDB;">range</span>(n)] <span style="color: #51afef;">for</span> _ <span style="color: #51afef;">in</span> <span style="color: #C57BDB;">range</span>(m)]
    <span style="color: #51afef;">for</span> i <span style="color: #51afef;">in</span> <span style="color: #C57BDB;">range</span>(1, m):
        <span style="color: #51afef;">for</span> j <span style="color: #51afef;">in</span> <span style="color: #C57BDB;">range</span>(1, n):
            <span style="color: #51afef;">if</span> X[i-1] == Y[j-1]:
                C[i][j] = C[i-1][j-1] + 1
            <span style="color: #51afef;">else</span>:
                C[i][j] = <span style="color: #C57BDB;">max</span>(C[i][j-1], C[i-1][j])
    pprint(C)
    <span style="color: #51afef;">return</span> C[n-1][m-1]
</pre>
</div>

<p>
Vou tentar agora codificar isso em C++. Finalizado. Que desgraça hein.
A parte mais difícil desse problema não era exatamente lidar com o dynamic_cast
e detectar que classe filha estão sendo referenciadas. Na verdade esse problema
aí do Longest Common Subsequence é bem mais difícil. Engraçado porque esse tópico
é sobre herança, o que esse problema NP-Hard é simplemente sem relação!
</p>
</div>
</div>
</div>

<div id="outline-container-org52df3bc" class="outline-3">
<h3 id="org52df3bc">STL - C++ Standard Library</h3>
<div class="outline-text-3" id="text-org52df3bc">
</div>
<div id="outline-container-org0b36f92" class="outline-4">
<h4 id="org0b36f92">Vector Sort</h4>
<div class="outline-text-4" id="text-org0b36f92">
<p>
A Standard Library de C++ vem com muitos bultins. Um dos métodos
da biblioteca é <code>std::sort(vector::begin, vector::end)</code>.
</p>

<div class="org-src-container">
<label class="org-src-name"><span class="listing-number">Listing 1: </span>Ordenar n números</label><pre class="src src-C++"><span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;cmath&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;cstdio&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;vector&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;iostream&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;algorithm&gt;</span>
<span style="color: #51afef;">using</span> <span style="color: #51afef;">namespace</span> <span style="color: #a991f1;">std</span>;


<span style="color: #FCCE7B;">int</span> <span style="color: #5cEfFF;">main</span>() {
    <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">n</span>, <span style="color: #DFDFDF;">x</span>;
    cin &gt;&gt; n;
    <span style="color: #FCCE7B;">vector</span>&lt;<span style="color: #FCCE7B;">int</span>&gt; <span style="color: #DFDFDF;">v</span>;
    <span style="color: #51afef;">for</span>(<span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">i</span> = 0; i &lt; n; i++) {
        cin &gt;&gt; x;
        v.push_back(x);
    }
    sort(v.begin(), v.end());
    <span style="color: #51afef;">for</span>(<span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">x</span> :v) {
        cout &lt;&lt; x &lt;&lt; <span style="color: #7bc275;">" "</span>;
    }
    <span style="color: #51afef;">return</span> 0;
}

</pre>
</div>
</div>
</div>
<div id="outline-container-orgd096e87" class="outline-4">
<h4 id="orgd096e87">Vector-Erase</h4>
<div class="outline-text-4" id="text-orgd096e87">
<p>
A STL definida em <code>&lt;algorithm&gt;</code> e <code>&lt;vector&gt;</code> define alguns métodos
úteis, como por exemplo o método <code>vector::erase</code> para remover elementos
seja de apenas uma localização ou um intervalo.
</p>

<p>
O seguinte código foi feito para o exercício proposto do hackerrank:
</p>
<div class="org-src-container">
<pre class="src src-C++"><span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;cmath&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;cstdio&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;vector&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;iostream&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;algorithm&gt;</span>
<span style="color: #51afef;">using</span> <span style="color: #51afef;">namespace</span> <span style="color: #a991f1;">std</span>;


<span style="color: #FCCE7B;">int</span> <span style="color: #5cEfFF;">main</span>() {
    <span style="color: #FCCE7B;">vector</span>&lt;<span style="color: #FCCE7B;">long</span>&gt; <span style="color: #DFDFDF;">v</span>;
    <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">n</span>,<span style="color: #DFDFDF;">x</span>,<span style="color: #DFDFDF;">a</span>,<span style="color: #DFDFDF;">b</span>;
    cin &gt;&gt; n;
    <span style="color: #51afef;">for</span> (<span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">i</span> = 0; i &lt; n; i++) {
        cin &gt;&gt; x;
        v.push_back(x);
    }

    cin &gt;&gt; x;
    v.erase(v.begin()+x-1);
    cin &gt;&gt; a;
    cin &gt;&gt; b;
    v.erase(v.begin()+a-1, v.begin()+b-1);
    cout &lt;&lt; v.size() &lt;&lt; endl;

    <span style="color: #51afef;">for</span> (<span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">x</span> : v) {
        cout &lt;&lt; x &lt;&lt; <span style="color: #7bc275;">" "</span>;
    }
    <span style="color: #51afef;">return</span> 0;
}
</pre>
</div>

<p>
Ou seja, há duas definições para vector::erase.
</p>
<ul class="org-ul">
<li><code>vector::erase(const iterator n);</code></li>
<li><code>vector::erase(const iterator n, const iterator m);</code></li>
</ul>

<p>
O const iterator pode ser obtido a partido dos métodos:
<code>vector::begin</code> e <code>vector::end</code>.
</p>
</div>
</div>

<div id="outline-container-org3ea81fe" class="outline-4">
<h4 id="org3ea81fe">Lower Bound</h4>
<div class="outline-text-4" id="text-org3ea81fe">
<p>
Em C++ a STL provém funções úteis para iterações e comparações.
Um delas são os métodos <code>std::lower_bound</code> e <code>std::upper_bound</code>.
Ambas funções recebem três parâmetros, os dois primeiros sendo
o iterador inicial então o iterador final (<code>vector::begin</code> &amp; <code>vector::end</code>).
O terceiro elemento é um objeto de comparação que implementa operator&lt;
para <code>std::lower_bound</code> e <code>std::upper_bound</code>.
</p>

<p>
O método <code>std::lower_bound</code> retorna o número menor que a comparação que esteja
mais próximo desse número esquerda. <code>std::upper_bound</code> retorna o maior número que esteja
mais próximo desse pela direita. Isso, é claro supondo um vetor ordenado.
</p>

<p>
Pode-se encontrar uma solução para este problema no arquivo:
<a href="https://github.com/ryukinix/cpp-journey/tree/master/STL/LowerBound.cpp">LowerBound.cpp</a>
</p>
</div>
</div>

<div id="outline-container-orgbb82af9" class="outline-4">
<h4 id="orgbb82af9">Sets</h4>
<div class="outline-text-4" id="text-orgbb82af9">
<p>
Essa próxima atividade se refere a implementação de conjuntos na biblioteca
padrão de C++. Definida no cabeçalho <code>#include &lt;set&gt;</code> os métodos conhecidos para
o tipo set, são:
</p>

<ul class="org-ul">
<li><code>std::set&lt;int&gt; s</code>;</li>
<li><code>s.length()</code>; (tamanho do conjunto)</li>
<li><code>s.erase(int n)</code>; (apagar um elemento)</li>
<li><code>s.insert(int n)</code>; (inserir um elemento)</li>
<li><code>set&lt;int&gt;::iterator it = s.find(int n);</code> (procura um elemento, devolve um iterator)</li>
</ul>

<p>
Se o elemento não é encontrado <code>it == s.end();</code>
</p>

<p>
Um problema para explorar essas operações é proposto no HackerRank,
onde uma solução pode ser encontrada aqui: <a href="https://github.com/ryukinix/cpp-journey/tree/master/STL/Set.cpp">Set.cpp</a>
</p>
</div>
</div>

<div id="outline-container-org13404ac" class="outline-4">
<h4 id="org13404ac">Maps</h4>
<div class="outline-text-4" id="text-org13404ac">
<p>
HashMaps e Maps são implementados em C++ pela STL, Standard Library. Também conhecidos
em outras linguagens como dicionários (python), HashMaps armazenam unidades de
de pares <code>&lt;chave, valor&gt;</code> na qual a existência para uma dada chave é única.
</p>

<p>
Vale ressaltar, explicitamente, que HashMaps em C++ são conhecidos como <code>unordered_map</code>
e Maps são implementados com <code>red black trees</code>, árvores de busca do tipo balanceada.
A principal diferença é que <code>unordered_map</code> possui acesso/inserção com complexidade
O(1) se não houver colisão (se houver, no pior caso é O(n)). E <code>map</code> é <b>SEMPRE</b> O(log(n)).
</p>

<p>
Existem alguns métodos úteis implementados para HashMaps e Maps. O tipo <code>map</code> é definido
em <code>&lt;map&gt;</code> e segue que:
</p>

<div class="org-src-container">
<pre class="src src-C++"><span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;map&gt;</span>

<span style="color: #a991f1;">std</span>::<span style="color: #FCCE7B;">map</span>&lt;<span style="color: #FCCE7B;">int</span>, <span style="color: #FCCE7B;">string</span>&gt; <span style="color: #DFDFDF;">m</span>; <span style="color: #62686E;">// </span><span style="color: #62686E;">declara&#231;&#227;o</span>
m.insert(<span style="color: #a991f1;">std</span>::make_pair(1, <span style="color: #7bc275;">"banana"</span>)); <span style="color: #62686E;">// </span><span style="color: #62686E;">inser&#231;&#227;o</span>
m[1] = <span style="color: #7bc275;">"banana"</span>; <span style="color: #62686E;">// </span><span style="color: #62686E;">a&#231;ucar sint&#225;tico para inser&#231;&#227;o</span>
m.erase(<span style="color: #7bc275;">"banana"</span>); <span style="color: #62686E;">//</span><span style="color: #62686E;">remover elemento</span>
m.find(key); <span style="color: #62686E;">// </span><span style="color: #62686E;">m&lt;int,string&gt;::iterator</span>
<span style="color: #62686E;">// </span><span style="color: #62686E;">se um elemento n&#227;o &#233; encontrado ent&#227;o m.find(key) == m.end();</span>
m[1]; <span style="color: #62686E;">// </span><span style="color: #62686E;">"banana</span>
</pre>
</div>

<p>
Um problema é proposto no HackerRank para explorar essas operações.
A implementação está feita no arquivo <a href="https://github.com/ryukinix/cpp-journey/tree/master/STL/HashMap.cpp">HashMap.cpp</a>.
</p>

<p>
Edit: Pensei inicialmente que <code>map</code> de C++ eram HashMaps, por isso algumas trocas aqui.
</p>
</div>
</div>

<div id="outline-container-org961a552" class="outline-4">
<h4 id="org961a552">Print Pretty</h4>
<div class="outline-text-4" id="text-org961a552">
<p>
Preciso fazer essa atividade. Irei começar daqui a pouco. Basicamente
a atividade é em relação a imprimir diferente tipos de dados com uma determinada
característica. Por exemplos, notação científica para decimais. Números
decimais prefixado e também números inteiros com caracteres prefixado.
Parece que STL já implementa isso em algum lugar.
</p>

<p>
A atividade será desenvolvida em: <a href="https://github.com/ryukinix/cpp-journey/tree/master/STL/PrettyPrint.cpp">PrettyPrint.cpp</a>
</p>

<p>
Maiores anotações virão a seguir.
</p>

<p>
Bem&#x2026; trabalhar com formatação de IO em C++ é no mínimo doloroso.
Na verdade eu achei um completo inferno, mas vou tentar descrever algumas coisas
que entendi.
</p>

<p>
No cabeçalho <code>&lt;iomanip&gt;</code> é definido várias entradas para trabalhar com formatação
de stringstreams, ou necessariamente IO.
</p>

<p>
Entre diretrizes pra trabalhar com números de qualquer tipo tem-se:
</p>

<ul class="org-ul">
<li><code>showbase</code> &#x2013; mostra a base do número, como hex e octal</li>
<li><code>noshowbase</code> &#x2013; desativa a opção acima</li>
<li><code>showpos</code> &#x2013; todos números são definidos com sinal prefixado +/-</li>
<li><code>noshowpos</code> &#x2013; desativa a opção acima</li>
<li><code>setbase</code> &#x2013; define qual é a base no parsing, por exemplo 16 -&gt; hexadecimal</li>
<li><code>uppercase</code> &#x2013; base e outros caracteres são usados em uppercase</li>
<li><code>nouppercase</code> &#x2013; o contrário da opção acima</li>
</ul>

<p>
Para setbase temos atalhos predefinidos como <code>hex</code>, <code>oct</code> e <code>dec</code>.
</p>

<p>
Para preenchimento de string, largura máxima e alinhamento temos:
</p>

<ul class="org-ul">
<li><code>left</code> &#x2013; alinha pela esquerda</li>
<li><code>right</code> &#x2013; alinha pela direita</li>
<li><code>internal</code> &#x2013; aplica a formação no número em si</li>
<li><code>setw</code> &#x2013; define largura máxima</li>
<li><code>setfill</code> &#x2013; recebe um caracter e preenche de acordo com a largura máxima esperada</li>
</ul>

<p>
Para processamento de números flutuantes temos:
</p>

<ul class="org-ul">
<li><code>setprecision</code> &#x2013; precisão em casas decimais</li>
<li><code>fixed</code> &#x2013; notação prefixa =&gt; 10.001</li>
<li><code>scientific</code> &#x2013; notação científica-&gt; 3.30303E+03</li>
<li><code>default</code> &#x2013; notação padrão</li>
</ul>

<p>
Também tem hexfloat, mas isso é muito obscuro e não vou cobrir.
</p>

<p>
Para fazer uma definição global de formação podemos usar <code>setiosflags</code> e <code>resetiosflags</code>.
</p>

<p>
<code>setiosflags</code> recebe uma das <code>flags</code> acima não-parametrizada e define globalmente.
Como o argumento esperado é uma <code>bitmask</code>, é possível fazer qualquer operação de <code>bitwise</code>.
</p>

<p>
Por exemplo:
</p>
<div class="org-src-container">
<pre class="src src-C++"><span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;iostream&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;iomanip&gt;</span>

<span style="color: #FCCE7B;">int</span> <span style="color: #5cEfFF;">main</span>()
{
    <span style="color: #a991f1;">std</span>::cout &lt;&lt;  <span style="color: #a991f1;">std</span>::resetiosflags(<span style="color: #a991f1;">std</span>::<span style="color: #a991f1;">ios_base</span>::dec)
              &lt;&lt;  <span style="color: #a991f1;">std</span>::setiosflags(  <span style="color: #a991f1;">std</span>::<span style="color: #a991f1;">ios_base</span>::hex
                                   | <span style="color: #a991f1;">std</span>::<span style="color: #a991f1;">ios_base</span>::uppercase
                                   | <span style="color: #a991f1;">std</span>::<span style="color: #a991f1;">ios_base</span>::showbase) &lt;&lt; 42 &lt;&lt; <span style="color: #7bc275;">'\n'</span>;
}

<span style="color: #62686E;">// </span><span style="color: #62686E;">Output:</span>
<span style="color: #62686E;">// </span><span style="color: #62686E;">0X2A</span>

</pre>
</div>


<p>
Isso é o básico. Mais informações estão <a href="http://en.cppreference.com/w/cpp/io/manip">aqui</a>.
</p>
</div>
</div>

<div id="outline-container-orgf0a0f5c" class="outline-4">
<h4 id="orgf0a0f5c">Deque</h4>
<div class="outline-text-4" id="text-orgf0a0f5c">
<p>
Bem, esse problema refere-se ao uso do container Deque da STL.
É dado um array, o seu tamanho e um índice K. O problema deseja saber
quais são os valores máximos para cada subarray contínuo divididos em K.
</p>

<p>
Exemplo: [9,2,3,5,8], k=3
</p>

<p>
[9,2,3] =&gt; 9
[2,3,5] =&gt; 5
[3,5,8] =&gt; 8
</p>

<p>
Uma aproximação ingênua nos levaria a fazer um algoritmo O(nk). Mas,
percebendo que é somente necessário n comparações, com o auxílio de um deque
é possível armazenar os índices úteis dos valores para cada sub-array.
Complexidade de Espaço: O(k).
</p>

<p>
A idéia principal é criar um deque ordenado de maior valor ao menor, inserindo
os índices do array. Quando terminar o subarray, imprimir a cabeça do deque
e remover se ele não pertencer ao próximo array. Lembre-se que para cada sub-array,
os indices x &lt;= (i - k) não pertencem mais ao sub-array.
</p>

<p>
Uma aproximação ótima pode ser descrita nesta implementação: <a href="https://github.com/ryukinix/cpp-journey/tree/master/STL/Deque.cpp">Deque.cpp</a>
</p>
</div>
</div>
</div>
</div>

<div id="outline-container-org20b6816" class="outline-2">
<h2 id="org20b6816">C++ prime checking</h2>
<div class="outline-text-2" id="text-org20b6816">
<p>
SCHEDULED: <span class="timestamp-wrapper"><span class="timestamp">&lt;2017-07-05 Wed&gt;</span></span>
</p>
<p>
Usei as bibliotecas:
</p>
<div class="org-src-container">
<pre class="src src-C++"><span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;iostream&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;cstdlib&gt;</span>
<span style="color: #C57BDB; font-weight: bold;">#include</span> <span style="color: #7bc275;">&lt;cmath&gt;</span>
</pre>
</div>
<p>
Em iostream usei apenas cout. cstdlib precisei para a função atoi.
cmath para sqrt.
A linha de comando para compilação foi:
<code>g++ source.cpp -o primep -lm</code>
</p>

<p>
O arquivo pode ser encontrado em: <a href="https://github.com/ryukinix/cpp-journey/tree/master/Intro/primep.cpp">Prime Checking</a>
</p>
</div>
</div>
<div id="outline-container-orgbba1fee" class="outline-2">
<h2 id="orgbba1fee">Estudos de caso</h2>
<div class="outline-text-2" id="text-orgbba1fee">
</div>
<div id="outline-container-org03ee752" class="outline-3">
<h3 id="org03ee752">Listas de inicialização para construtores</h3>
<div class="outline-text-3" id="text-org03ee752">
<p>
Listas de inicialização é um tipo de sintaxe para escrever
brevemente construtores de classes, geralmente para inicializar valores.
A sintaxe é usada como a seguir:
</p>

<div class="org-src-container">
<pre class="src src-C++"><span style="color: #51afef;">struct</span> <span style="color: #FCCE7B;">Node</span> {
   <span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">value</span>;
   <span style="color: #FCCE7B;">Node</span>* <span style="color: #DFDFDF;">next</span>;
   <span style="color: #5cEfFF;">Node</span>(<span style="color: #FCCE7B;">int</span> <span style="color: #DFDFDF;">v</span> = 0, <span style="color: #FCCE7B;">Node</span>* <span style="color: #DFDFDF;">ptr</span>): value(v), next(ptr){};
}
</pre>
</div>

<p>
Dessa maneira, é possível construir de maneiras muito simplórias construtores
que apenas relacionam entradas de função para atributos de um objeto.
</p>

<p>
Vale lembrar que a ordem de inicialização deve estar de acordo com a declaração
dos membros. De acordo com um membro do StackOverflow, em <a href="https://stackoverflow.com/questions/1242830/constructor-initialization-list-evaluation-order">Constructor initialization-list evaluation order</a>,
foi dito que:
</p>

<p>
"The reason for which they are constructed in the member declaration order
and not in the order in the constructor is that one may have several
constructors, but there is only one destructor.
And the destructor destroy the members in the reserse order of construction.
– AProgrammer"
</p>

<p>
Ou seja, por conta de dependência entre os possíveis valores, a dependência
é que o destruidor destrói os membros de um objeto na ordem inversa de
construção, logo, a ordem importa e deve ser mantida.
</p>
</div>
</div>

<div id="outline-container-org4a30211" class="outline-3">
<h3 id="org4a30211">Separadores de escopo <code>::</code> e <code>.</code></h3>
<div class="outline-text-3" id="text-org4a30211">
<p>
   O operador <code>::</code> é usado como separador de escopo e acessar
métodos/atributos estáticos. Por outro lado, <code>.</code> é usado apenas para
acessar métodos/atributos de uma classe/struct que tenha instância. Além disso,
o operador <code>-&gt;</code> é usado no lugar de <code>.</code> quando o objeto é um ponteiro.
Ou seja, na verdade, <code>(*a).b</code> &lt;=&gt; <code>a-&gt;b</code>. Ou seja, <code>-&gt;</code> é apenas uma açúcar
sintático.
</p>

<p>
No StackOverflow, novamente, é possível ver uma resposta semelhante onde é
citado o que foi dito acima.
<a href="https://stackoverflow.com/questions/2896286/whats-the-difference-between-dot-operator-and-scope-resolution-operator">What's the difference between dot operator and scope resolution operator?</a>
</p>
</div>
</div>
</div>]]></content><author><name>Manoel Vilela</name></author><category term="programming" /><summary type="html"><![CDATA[Uma jornada no mundo infernal de C++ através do HackerRank]]></summary></entry><entry xml:lang="en"><title type="html">decorating: Literally decorating your terminal with decorators</title><link href="https://lerax.me/programming/decorating/" rel="alternate" type="text/html" title="decorating: Literally decorating your terminal with decorators" /><published>2017-04-06T00:00:00+00:00</published><updated>2017-04-06T00:00:00+00:00</updated><id>https://lerax.me/programming/decorating</id><content type="html" xml:base="https://lerax.me/programming/decorating/"><![CDATA[<p><a href="https://travis-ci.org/ryukinix/decorating"><img src="https://travis-ci.org/ryukinix/decorating.svg?branch=master" alt="Build Status" /></a>
<a href="https://codecov.io/gh/ryukinix/decorating"><img src="https://codecov.io/gh/ryukinix/decorating/branch/master/graph/badge.svg" alt="codecov" /></a>
<a href="https://requires.io/github/ryukinix/decorating/requirements/?branch=master"><img src="https://requires.io/github/ryukinix/decorating/requirements.svg?branch=master" alt="Requirements Status" /></a>
<a href="https://pypi.python.org/pypi/decorating/"><img src="https://img.shields.io/pypi/v/decorating.svg" alt="PyPi version" /></a>
<a href="https://pypi.python.org/pypi/decorating/"><img src="https://img.shields.io/pypi/pyversions/decorating.svg" alt="PyPI pyversions" /></a>
<a href="https://pypi.python.org/pypi/decorating/"><img src="https://img.shields.io/pypi/status/decorating.svg" alt="PyPI status" /></a></p>

<h2 id="description">Description</h2>

<p><a href="https://github.com/ryukinix/decorating">decorating</a> encourages an exploration into the limits of decorators in Python. While decorators might be new to beginners, they are an extremely useful feature of the language. They can be similar to Lisp Macros, but without changes to the AST, they actually only work like “Wrapper Macros”. Great decorator examples are <code class="language-plaintext highlighter-rouge">@animated</code> and <code class="language-plaintext highlighter-rouge">@writing</code> on this project. This repository is made from scratch, using only Python’s Standard Library, so there are no dependencies!</p>

<h2 id="showcase">Showcase</h2>

<p><img src="../assets/posts/decorating/animated-simple.gif" alt="animated-simple" /></p>

<p><img src="../assets/posts/decorating/animated-nested.gif" alt="animated-simple" /></p>

<h2 id="decorators-of-decorating">Decorators of Decorating</h2>

<h3 id="decoratingdebug">decorating.debug</h3>

<p>Print in a nicely way a output/input of a function call.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">decorating</span>

<span class="o">@</span><span class="n">decorating</span><span class="p">.</span><span class="n">debug</span>
<span class="k">def</span> <span class="nf">fib</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
    <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">2</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">n</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">fib</span><span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">+</span> <span class="n">fib</span><span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">2</span><span class="p">)</span>

<span class="k">print</span><span class="p">(</span><span class="s">"Result: {}"</span><span class="p">.</span><span class="nb">format</span><span class="p">(</span><span class="n">fib</span><span class="p">(</span><span class="mi">3</span><span class="p">)))</span>
<span class="c1"># OUTPUT:
# fib(1) -&gt; 1
# @fib(0) -&gt; 0
# @fib(2) -&gt; 1
# @fib(1) -&gt; 1
# @fib(3) -&gt; 2
# Result: 2
</span></code></pre></div></div>

<h3 id="decoratingcache">decorating.cache</h3>

<p>Memoizes the decorated function based on its arguments.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">decorating</span>

<span class="o">@</span><span class="n">decorating</span><span class="p">.</span><span class="n">debug</span>
<span class="o">@</span><span class="n">decorating</span><span class="p">.</span><span class="n">cache</span>
<span class="k">def</span> <span class="nf">fib</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
    <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">2</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">n</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">fib</span><span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">+</span> <span class="n">fib</span><span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">2</span><span class="p">)</span>

<span class="k">print</span><span class="p">(</span><span class="s">"Result: {}"</span><span class="p">.</span><span class="nb">format</span><span class="p">(</span><span class="n">fib</span><span class="p">(</span><span class="mi">30</span><span class="p">)))</span>

<span class="c1"># OUTPUT:
# @fib(1) -&gt; 1
# @fib(0) -&gt; 0
# @fib(2) -&gt; 1
# @fib(1) -&gt; 1
# @fib(3) -&gt; 2
# @fib(2) -&gt; 1
# @fib(4) -&gt; 3
# @fib(3) -&gt; 2
# @fib(5) -&gt; 5
# ... many calls! (erased)
# @fib(23) -&gt; 28657
# @fib(25) -&gt; 75025
# @fib(24) -&gt; 46368
# @fib(26) -&gt; 121393
# @fib(25) -&gt; 75025
# @fib(27) -&gt; 196418
# @fib(26) -&gt; 121393
# @fib(28) -&gt; 317811
# @fib(27) -&gt; 196418
# @fib(29) -&gt; 514229
# @fib(28) -&gt; 317811
# @fib(30) -&gt; 832040
# Result: 832040
</span></code></pre></div></div>

<p>Nicely! We wrote an awful <code class="language-plaintext highlighter-rouge">O(2^n)</code> function that takes <code class="language-plaintext highlighter-rouge">O(n)</code> in time and space! Beautiful.</p>

<h3 id="decoratingcounter">decorating.counter</h3>

<p>Return as side-effect a print on stdout about the time of calls of a function. On the terminal this is overwritten</p>

<p>using a <code class="language-plaintext highlighter-rouge">\r</code> carriage return character. Sometimes is usefull to see a high frequent function is used on some algorithm.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">decorating</span>

<span class="o">@</span><span class="n">decorating</span><span class="p">.</span><span class="n">counter</span>
<span class="k">def</span> <span class="nf">f</span><span class="p">():</span>
    <span class="k">pass</span>

<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">):</span>
    <span class="n">f</span><span class="p">()</span>

<span class="c1"># OUTPUT:
# f has been used: 1x
# f has been used: 2x
# f has been used: 3x
# f has been used: 4x
# f has been used: 5x
# f has been used: 6x
# f has been used: 7x
# f has been used: 8x
# f has been used: 9x
# f has been used: 10x
</span></code></pre></div></div>

<h3 id="decoratingcount_time"><strong>decorating.count_time</strong></h3>

<p>Calculate the time a function leaves to return a value after called.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">decorating</span>
<span class="kn">import</span> <span class="nn">time</span>

<span class="o">@</span><span class="n">decorating</span><span class="p">.</span><span class="n">count_time</span>
<span class="k">def</span> <span class="nf">f</span><span class="p">():</span>
    <span class="n">time</span><span class="p">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>

<span class="n">f</span><span class="p">()</span>

<span class="c1"># OUTPUT:
# 'f' func leave it 3.00 s to finish
</span></code></pre></div></div>

<h3 id="decoratinganimated">decorating.animated</h3>

<p>Make a cool animated bar using a on-side thread while the function is evaluated or the <code class="language-plaintext highlighter-rouge">with</code> block (context manager) is running. Useful to make human-friendly application whose some parts are slow and non-determinist sufficiently to do a progress bar. (like a socket listen, a process calculation and etc).</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">decorating</span>
<span class="kn">import</span> <span class="nn">time</span>

<span class="k">with</span> <span class="n">decorating</span><span class="p">.</span><span class="n">animated</span><span class="p">:</span>
	<span class="n">time</span><span class="p">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>

<span class="c1"># animation is running ~ until the context managers exists
</span></code></pre></div></div>

<h4 id="decoratingwriting">decorating.writing</h4>

<p>This decorator is used to intercept every stdout print using a delayed printer. It’s some like a human-type or a old computer. Check a partial implementation this on a non-released version of <a href="https://asciinema.org/a/ctt1rozymvsqmeipc1zrqhsxb">MAL</a> on asciicinema.</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">decorating</span>

<span class="k">with</span> <span class="n">decorating</span><span class="p">.</span><span class="n">writing</span><span class="p">:</span>
	<span class="k">print</span><span class="p">(</span><span class="s">"YES! THIS IS WILL BE DELAYED."</span><span class="p">)</span>
</code></pre></div></div>

<h2 id="give-a-try">Give a Try</h2>

<p><code class="language-plaintext highlighter-rouge">pip install decorating</code> # stable</p>

<p><code class="language-plaintext highlighter-rouge">pip install git+https://github.com/ryukinix/decorating</code> # new features</p>]]></content><author><name></name></author><category term="programming" /><category term="programming" /><category term="python" /><summary type="html"><![CDATA[A Meta-Repository for Decorators]]></summary></entry><entry xml:lang="en"><title type="html">Lisp Chat</title><link href="https://lerax.me/programming/lisp-chat/" rel="alternate" type="text/html" title="Lisp Chat" /><published>2017-04-06T00:00:00+00:00</published><updated>2017-04-06T00:00:00+00:00</updated><id>https://lerax.me/programming/lisp-chat</id><content type="html" xml:base="https://lerax.me/programming/lisp-chat/"><![CDATA[<h2 id="description">Description</h2>

<p>I did this as an exercise after reading the entire Land of Lisp book. On the other hand, I did it because I was too bored — I don’t know if this matters. But, anyway, it’s just another minimal, simple chat over TCP sockets without any smart, solid protocol (like IRC). It’s just raw data from client-to-server, and the server broadcasts the message to all connected clients.</p>

<p>The whole idea is very simple. The software is separated into <code class="language-plaintext highlighter-rouge">client.lisp</code> and <code class="language-plaintext highlighter-rouge">server.lisp</code>. While <code class="language-plaintext highlighter-rouge">server.lisp</code> is running, it listens for connections from a specified port (example: 5558) for the clients. On the other hand, <code class="language-plaintext highlighter-rouge">client.lisp</code>, well… connects to the server and lets the user send messages to it. All messages sent to <code class="language-plaintext highlighter-rouge">server.lisp</code>, when received, are broadcast by the server to all connected clients. It’s just like an IRC with a single room.</p>

<p>It seems very stupid, I know, but actually, because the implementation is so simple, we can assign a certain value to this. BTW, this post was my first front-page on <a href="https://news.ycombinator.com/item?id=13857880">Hacker News</a> with 114 points. I really didn’t expect something like that when I wrote it. So, well, this seems to have some beauty. Maybe the reason is: software
written in Lisp? (HAHAHA)</p>

<p>The system, both client and server, is implemented using SBCL (Common Lisp
Compiler) and USOCKET (TCP/UDP sockets). Just that. Cool, huh?</p>

<h2 id="showcase">Showcase</h2>

<p><img src="/assets/posts/lisp-chat/lisp-chat.png" alt="lisp-chat" /></p>

<p>Yes. Only me. Actually, on the HN trending day, some people cloned the
project, set it up, and ran it. I just saw the log later. HAHAH Some guys were typing things like <code class="language-plaintext highlighter-rouge">(quit)</code> or <code class="language-plaintext highlighter-rouge">ls</code>. Very funny. Actually, the server supports three undocumented commands: <code class="language-plaintext highlighter-rouge">/users</code>, <code class="language-plaintext highlighter-rouge">/help</code>, and <code class="language-plaintext highlighter-rouge">/log</code>. But don’t tell it to anyone.</p>

<p>P.S.: Yes, after <code class="language-plaintext highlighter-rouge">22:29:16</code>, I typed <code class="language-plaintext highlighter-rouge">/log</code>, and old messages came back.</p>

<h2 id="source">Source</h2>
<p>You can look to the source here on
<a href="https://github.com/ryukinix/lisp-chat">github</a> The minimal
instructions to build and setup the project is written on
README.md. At least for now, the day I wrote this post a server
instance is running at <code class="language-plaintext highlighter-rouge">server.lerax.me:5558</code>. As alternative I
provide too, for non-lispers, a simple Python client too. Both clients
and the servers are configured to running at <code class="language-plaintext highlighter-rouge">server.lerax.me:5558</code>.</p>]]></content><author><name></name></author><category term="programming" /><category term="programming" /><category term="lisp" /><summary type="html"><![CDATA[An experimental chat written in Common Lisp]]></summary></entry><entry xml:lang="pt"><title type="html">Eastan</title><link href="https://lerax.me/personal/eastan/" rel="alternate" type="text/html" title="Eastan" /><published>2017-01-01T00:00:00+00:00</published><updated>2017-01-01T00:00:00+00:00</updated><id>https://lerax.me/personal/eastan</id><content type="html" xml:base="https://lerax.me/personal/eastan/"><![CDATA[<h1 id="eastan">Eastan</h1>

<p>Hoje tive acho que um dos pesadelos mais assustador de todos. Mas não
sei se vou conseguir escrever ele com detalhes o suficiente para que
possa entender o porquê que foi tão assustador pra mim. Na verdade, o
pesadelo era autoconsciente na maior parte, eu sabia que estava
sonhando, mas no inicio eu não sabia que estava num sonho.</p>

<p>A primeira memória que consigo me lembrar é de eu tocando violão no
meu quarto. Lembro até do que tava tocando, uma variação de uma música
dos Engenheiros do Hawaii. Mas o violão estava diferente, ele estava
sem headstock (a parte que as cordas são amarradas). Aparentemente as
cordas estavam entrelaçadas na parte de trás do braço com alguma
gambiarra, mas eu não lembrava que eu tinha feito isso, achei estranho
no sonho. Uma mulher loira me observava perto de uma porta de costas,
como se sempre tivesse lá e fosse normal, mas eu não a conhecia. Acabo
mexendo nessa parte de trás com as cordas amarradas e todas se soltam.</p>

<p>Logo em seguida, mãe me chama dizendo que meus amigos estão me
esperando. Mas no sonho eu também tinha consciência que estou em outra
cidade e que não tenho amigos que viriam na minha casa, em
Sobral. Então vou lá com o violão quebrado e encontro dois amigos da
cidade que vim, Breu Branco. Ronaldo e Rovenilson. Rovenilson percebeu
logo que o violão estava quebrado e perguntou o que havia acontecido,
então expliquei a ele que mexi nele porque não lembrava de ter tirado
o headstock. Mas de forma direta eu pergunto: “Como vocês estão aqui?
Essa cidade é muito longe para vocês casualmente me visitarem.”. Os
dois respondem junto com minha mãe a palavra: “Diagrama”. Eu não
entendo. Olhei pra ele com uma cara confusa enquanto tentava processar
a ideia, foi então que percebi que aquilo não era real.</p>

<p>Fiquei um pouco surpreso com a naturalidade deles dizerem algo tão sem
sentido e resolvi sair de perto. Quando saí e abri uma porta, entrei
em um lugar totalmente diferente. A saída da casa onde morei na
infância, Fortaleza. Fico de joelho na areia olhando para o lugar, era
de dia. As castenheiras que sempre tiveram ainda estão lá e no trevo
logo a frente nenhum carro passa. Não havia ninguém em nenhum lugar,
completamente silencioso. Então vejo uma pessoa que conheço, Débora,
uma ex-colega de turma da UFPA. Por alguma razão eu grito por ela e a
chamo de “Denise”, mesmo o nome dela não sendo esse — provavelmente me
confundi com o nome da irmã dela. Mais uma coisa estranha, ela tava
andando de patins, subindo a rua e parece que não consegue me
ouvir. Como não consigo fazer com que ela pare, resolvo correr atrás
dela, mas ela começa a ir mais rápido. Quando vejo ela tá entrando num
prédio.</p>

<p>Não lembro de existir esse prédio nessa rua. Mas mesmo hesitante
resolvi entrar e continuar a seguir ela. O prédio não tem nada no
começo além de uma escada espiral em quadrados. Ela começa a subir e
eu também. Quando começo a ficar muito próximo dela duas coisas
esquisitas acontecem, eu percebo que vejo alguém no começo do prédio
vindo atrás de mim, parecia algum tipo de fotógrafo ou reporter, mas
com uma atmosfera muito esquisita. Andava com alguns equipamentos no
pescoço e com uma roupa toda preta. Fico ansioso e resolvo alcançar
Débora mais rápido, então quando a vejo ela está subindo as escadas de
joelho! Eu fico muito surpreso porque simplesmente não faz sentido
então o sonho começa a ficar turvo e minha visão se apaga.</p>

<p>Quando abro meus olhos estou na minha cama de novo, na mesma posição
que dormi, então o sonho acabou. Resolvo sair da cama e ir na
sala. Mãe tava servindo algum tipo de janta. Vou abrir a geladeira tem
um bucado de doces e brigadeiros, por alguma razão começo a ficar
ansioso sobre o que estou vendo. E começo a abrir a fechar a porta da
geladeira. Começo a falar alguma coisa pra mãe e ela começa a ficar
nervosa, essa parte do sonho não lembro o que acontecia na
conversa. Mas quando olho pra geladeira eu vejo duas gatas igual a que
tenho, gata Marie, então fecho a porta assustado. Mas aparece três
quando abro, fecho de novo e aparece quatro. Faço de novo e aparece
cinco. Então eu percebi nessa hora: eu estava alucinando.</p>

<p>Fico eufórico e começo a pensar se ainda estava sonhando, então na
busca de uma pista sobre o que está acontecendo, pego todos os
brigadeiros e coloco na boca pra observar se consigo sentir o
gosto. Mas consigo sentir muito bem o gosto de todos. Fico assustado
novamente com aquilo e resolvo sair novamente por uma das portas.</p>

<p>Quando saio, percebo que estou numa zona obscura de Breu Branco perto
de um posto. Novamente, não havia ninguém, mas dessa vez era de
noite. Há alguns destroços perto do posto, como resto de carros e
pneus. Mas não lembrava que existia esse lugar. Começo a andar rápido
e percebo algo saindo de um dos destroços. Algo semelhante há um
esteriótipo de alienígena, com olhos compridos pretos e pele
cinza. Ele começa vir rastejando pela minha direção se
deformando. Nessa hora já tava bem assustado com aquilo e começo a
correr. Novamente o sonho começa a escurecer e minha visão se apaga.</p>

<p>Acordo novamente na minha cama, no mesmo lugar. Dessa vez entendi que
estava realmente dentro de um sonho ainda. Comecei a imaginar a razão
porque eu não tava conseguindo acordar e algumas vozes soavam dizendo
que eu não iria acordar nunca mais. Penso então que se eu poderia ter
entrado em coma por algum acidente. Me levanto e pego um caderno
aberto que estava na frente da minha mesa. Começo a folhear ele e
sobrescrever por cima tudo que vejo de forma muito rápida. São
desenhos geométricos, números e fórmulas matemáticas. Os desenhos são
como labirintos em quadrados, os números ficam ligados como um mapa e
as fórmulas parecem ser sobre algum modelo de comportamento por
tempo. Por alguma razão penso que aquilo deve ter alguma relação com o
tempo que eu vou ter que levar pra sair do coma. Mas não entendo
porque pensei nisso.</p>

<p>Resolvo sair do quarto, Wanderson e mãe parecem muito preocupados ao
olharem pra mim, pensei que fosse pela situação que estamos
vivendo. Mas ao conversar com eles era sobre mim. Eles perceberam que
eu estava tendo algum tipo de alucinação. Começo a me tremer. Vou
abrir a geladeira pra pegar água e então a mãe fala: “Você vai ao
neurologista, certo?”. Então tudo fica em silêncio e minha vista
começa a escurecer. O sonho acaba novamente.</p>

<p>E, minha nossa, de novo acordo no mesmo lugar! Isso acontece ainda
muitas vezes e nem consigo mais contar quantas vezes foram de
verdade. Já depois de mais de umas 10 vezes tentando acordar, estou
num galpão de madeira arrodeado por uma floresta. Era escuro, estava
de noite. Começo a ascender as luzes só com a força do pensamento, já
que nesse momento tinha consciência total que tudo era controlado por
mim, quando vejo várias pessoas que conheço. Eles começam a dizer:
“Você sabe que não somos reais, certo? Você não pode mais se
autoenganar. Somos você.”. Então eu digo: “Mas vocês são reais, mesmo
sendo eu. Pois vocês fazem parte das minhas memórias! Então eu estou
falando comigo mesmo! O que é real.”.</p>

<p>Dito isso, todos eles desaparescem e as luzes também. Começa a soar um
sonho muito assustador de ferro ao redor do galpão e começo a correr
pela primeira direção que eu vejo, quando então consigo entrar pra um
quarto. Fico esperando algo que está me seguindo. Cada vez mais perto,
cada vez mais perto e aumentando o barulho. Minha visão novamente
começa a esvaecer. Tudo escurece. Mas então eu acordo novamente na
cama do meu quarto. Sinto meu corpo pesado e percebo que finalmente
estou acordado no mundo real.</p>

<p>Os detalhes podem não parecer tanto assustadores pra você, mas sei lá,
a sensação de nunca mais acordar foi horrível. E quantas coisas
bizarras sem sentido! Quem vai subir uma escada de joelhos? O que
diabos é “Diagrama”? Por qual razão vão querer me levar num
neurologista? Aqueles caderno cheio de rascunhos de gente maluca
também.</p>

<p>Um último detalhe, assistindo uma série aparentemente derivada de
terror, aparece um nome na tela que ficou um pouco marcante: “Eastan”.
Fim.</p>]]></content><author><name></name></author><category term="personal" /><category term="dreams" /><category term="personal" /><summary type="html"><![CDATA[Um sonho bizarro sobre meu estado mental]]></summary></entry><entry xml:lang="pt"><title type="html">Matemática: a mecânica de todos os universos</title><link href="https://lerax.me/mathematics/universe/" rel="alternate" type="text/html" title="Matemática: a mecânica de todos os universos" /><published>2016-08-28T00:00:00+00:00</published><updated>2016-08-28T00:00:00+00:00</updated><id>https://lerax.me/mathematics/universe</id><content type="html" xml:base="https://lerax.me/mathematics/universe/"><![CDATA[<p><img src="https://upload.wikimedia.org/wikipedia/commons/7/73/Frans_Hals_-_Portret_van_Ren%C3%A9_Descartes.jpg" alt="rene-descartes" /></p>

<p>A matemática moderna, como deve ser reconhecida, faz parte da reforma
filosófica no século XVI na qual deu o início ao que seria num futuro
próximo o método científico, revolucionada por Galileu Galilei. A filosofia racionalista defendida por
René Descarte teve uma supra importância no desenvolvimento da
racionalidade e a conexão entre realidade com pura lógica; em
contraste a John Locke com a filosofia empírica na qual defendia que
todo o conhecimento é inerente a realidade.</p>

<p>Nesse contexto, como contribuição a filosofia e a matemática,
Descartes deu uma breve incitiação sobre o que seria o existencialismo com a famosa frase Cogito Ergo
Sum (se penso, logo existo), fundando e escola de filosofia racionalista e na
matemática a criação da Geometria Analítica, unindo dois campos que
até então eram encarados de uma maneira muito separada: Geometria &amp;
Álgebra.</p>

<p>Tão importante dessa maneira, a matemática sempre deu abertura a evolução da
física, química, astronomia, biologia e, então, o nascimento da computação como conhecemos no
século XX. É de extrema importância reconhecer que a matemática tem
como seu objetivo algo de uma ambição inefável: controlar a mecânica de todos os
universos.</p>

<p>Portanto, não desvalorizem a matemática, nem a odeie, todo o seu
passado questionável é justificativa do seu meio. Toda a existência da
matemática está nos infinitos universos possíveis e dentro de nós
mesmos, como uma instância revoltada e irregular. A matemática é uma consequência da nossa existência, a
abstração de todos os possíveis subconjuntos do multiverso. Pergunto, portanto, por que odiaríamos
nosso próprio universo se é via ele que existimos? Estude matemática!</p>]]></content><author><name></name></author><category term="mathematics" /><category term="math" /><category term="science" /><summary type="html"><![CDATA[O núcleo de todas as ciências exatas]]></summary></entry><entry xml:lang="en"><title type="html">MAL: MyAnimeList Command Line Interface</title><link href="https://lerax.me/programming/mal/" rel="alternate" type="text/html" title="MAL: MyAnimeList Command Line Interface" /><published>2016-05-16T00:00:00+00:00</published><updated>2016-05-16T00:00:00+00:00</updated><id>https://lerax.me/programming/mal</id><content type="html" xml:base="https://lerax.me/programming/mal/"><![CDATA[<p><a href="https://pypi.python.org/pypi/mal/"><img src="https://img.shields.io/pypi/v/mal.svg" alt="PyPi version" /></a></p>

<h2 id="description">Description</h2>

<p><a href="https://github.com/ryukinix/mal"><code class="language-plaintext highlighter-rouge">mal</code></a> is a command-line client for <a href="http://myanimelist.net/">MyAnimeList.net</a>. It uses their official <a href="http://myanimelist.net/modules.php?go=api">API</a>, so it should remain functional indefinitely (unlike screen-scraping alternatives). But it is in alpha development yet, so new ideas are welcome! This version is a inspired tool from the slow-maintained <a href="https://github.com/pushrax/mal">mal</a>.</p>

<p>I actually used part of its code to get started (most of it is currently in <code class="language-plaintext highlighter-rouge">api.py</code> within my MAL project).</p>

<h2 id="reason">Reason</h2>

<p>Because the CLI is life and opening the browser is boring. I implemented most of the code in half a day, but the worst part was handling Packaging &amp; Distribution for Python. <code class="language-plaintext highlighter-rouge">setuptools + pypi == hell</code>. But now I’m okay with this, and it appears to work very well.</p>

<h2 id="my-animes">My animes</h2>

<p><strong>Main usage</strong>
<img src="../assets/posts/mal/mal-main.gif" alt="main-usage" /></p>

<p>WARNING: THIS SHIT SAVE YOUR CREDENTIALS IN PLAIN TEXT! :P</p>

<h2 id="features">Features:</h2>

<ul>
  <li>Search in your anime list</li>
  <li>Search current anime in the sublist (e.g: watching)</li>
  <li>Increment/Decrement anime watching</li>
  <li>Score in final watching</li>
  <li>Fetch all anime list</li>
  <li>Colorized output (heat scores)</li>
  <li>Easy command line interface (based on regex)</li>
</ul>

<h2 id="give-a-try">Give a Try:</h2>

<p><code class="language-plaintext highlighter-rouge">pip install mal</code> # stable</p>

<p>or</p>

<p><code class="language-plaintext highlighter-rouge">pip install git+https://github.com/ryukinix/mal</code> # new features</p>]]></content><author><name></name></author><category term="programming" /><category term="programming" /><category term="anime" /><category term="python" /><summary type="html"><![CDATA[A Command Line Interface for MAL]]></summary></entry><entry xml:lang="en"><title type="html">I’m so tired… it’s all a conspiracy!</title><link href="https://lerax.me/personal/depression/" rel="alternate" type="text/html" title="I’m so tired… it’s all a conspiracy!" /><published>2016-04-29T00:00:00+00:00</published><updated>2016-04-29T00:00:00+00:00</updated><id>https://lerax.me/personal/depression</id><content type="html" xml:base="https://lerax.me/personal/depression/"><![CDATA[<p><img src="https://68.media.tumblr.com/tumblr_m3e46kxM6H1qlcutao1_500.gif" alt="the-life" /></p>

<h2 id="life-for-now">Life for Now</h2>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>The life passes so fast, but sometimes, so slowly. All the days is the same thing.
</code></pre></div></div>

<p><img src="https://68.media.tumblr.com/d5a7e8ff619286fd89ab267cd198dc00/tumblr_n4no77cKRl1qby49yo1_500.gif" alt="loop-infinite" /></p>

<p>I’m really tired. So tired that I could really sleep for a month and nothing would change. Wake up. <del>Suffering</del> Code something. Sleep.</p>

<p>In the last two days, I have been watching an anime called <a href="http://myanimelist.net/anime/1210/NHK_ni_Youkoso"><code class="language-plaintext highlighter-rouge">Welcome to the NHK</code></a>. It tells a story about a 22-year-old schizophrenic guy (my current age) with extreme social anxiety and his <del>mis</del>adventures in life. <strong>Why does everything suck so hard?</strong> Because of societal rejection and his own depression, Satou (the main character) became a Hikikomori after his first period at Tokyo University. A Hikikomori is a person who lives isolated in their room and resists all efforts to leave their home. He has been living this way for the last three years.</p>

<p>The anime talks about themes like social isolation, hikikomori, otaku, depression, suicide, drugs, games, and programming (at some points). It’s a heavy mixture of reality, <a href="https://www.youtube.com/watch?v=_Ei2izPLpHc"><strong>sadness</strong></a> and <a href="https://www.youtube.com/watch?v=bkz6504BKng"><strong>comedy</strong></a>. Actually, it’s a truly wonderful adventure, and the anime is generally very funny. However, if you have a life similar to Satou’s, it can be really painful sometimes. Or it can be your savior too. Anyway, <code class="language-plaintext highlighter-rouge">Welcome to NHK</code> is worth watching.</p>

<h2 id="afinities-with-welcome-to-the-nhk">Afinities with <code class="language-plaintext highlighter-rouge">Welcome to the NHK</code></h2>

<p>But… In determined moment during the adventure of watching this… I really have it feel it that Satou, actually, is a mirror of myself.The similarities did keep since the first episode until the end. I really had a deep comprehension of Satou’s feelings. And this is really bad.</p>

<p>During the debugging of my jobs or my other painfull software activities, I have a deep feel to break all. Really this, with a hammer. But I cannot.
I’m living yet because of my computer.</p>

<p>The biggest afinity was when Satou said that sequence of phrases:</p>

<p><img src="http://pa1.narvii.com/5879/e31f7967b63740c1a4a590c3475f03c545d11be2_hq.gif" alt="satou-give-up" /></p>

<ul>
  <li>I don’t want to meet anyone</li>
  <li>I don’t want to answer my cell phone (mainly it)</li>
  <li>I don’t want to do anything</li>
  <li>I don’t even want to live</li>
  <li>But dying’s such a hassle.</li>
</ul>

<p>Always when Satou had a psychotic break he blamed that is a conspiracy behind of your life fucking all.</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>So I'll say now: `IT'S ALL A CONSPIRACY!`.
</code></pre></div></div>

<p><img src="https://33.media.tumblr.com/a70bf766b25520b79b017065b08e8a0b/tumblr_nvzttiFzDK1sgq8s0o1_500.gif" alt="conspiracy-of-all" /></p>

<h2 id="the-end">The end</h2>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>The biggest question whose comes to us sometime in a long sequence of conspiracy
</code></pre></div></div>]]></content><author><name></name></author><category term="personal" /><category term="anime" /><category term="personal" /><summary type="html"><![CDATA[It's dangerous to create a description for this.]]></summary></entry><entry xml:lang="en"><title type="html">DestructHub and ProjectEuler</title><link href="https://lerax.me/programming/project-euler/" rel="alternate" type="text/html" title="DestructHub and ProjectEuler" /><published>2016-04-25T00:00:00+00:00</published><updated>2016-04-25T00:00:00+00:00</updated><id>https://lerax.me/programming/project-euler</id><content type="html" xml:base="https://lerax.me/programming/project-euler/"><![CDATA[<h2 id="main-proposal">Main Proposal</h2>

<p>The aim of the <a href="https://www.github.com/DestructHub">organization</a> is to provide a collection of solutions to common and unusual challenges found in the programming world. Why? Because it’s fun, it’s useful for learning, and we can learn from other people! Currently, we are a small group, about one year old, with around 20 members.</p>

<p>We want as many polyglot programmers as possible. Currently, we have solutions in Python, C, C++, Go, Haskell, Elixir, Lua, Clojure, and Common Lisp!</p>

<p>You love math? We love it too! Currently, we have been focusing on <a href="https://www.github.com/DestructHub/ProjectEuler">Project Euler</a> since its creation! We have almost 100 solutions (counting the alternative solutions on all programming languages)!</p>

<p>Join us and enter the sea of destruction!</p>]]></content><author><name></name></author><category term="programming" /><category term="programming" /><category term="contest" /><summary type="html"><![CDATA[Computational challenges/problems, mathematicians, mystery and hacking.]]></summary></entry></feed>