<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Gustavo Aguiar</title>
    <description>The latest articles on DEV Community by Gustavo Aguiar (@gustavohoa).</description>
    <link>https://dev.to/gustavohoa</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F409660%2F15527d73-6ecc-4b4b-9b58-e0ed897bc70c.jpg</url>
      <title>DEV Community: Gustavo Aguiar</title>
      <link>https://dev.to/gustavohoa</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/gustavohoa"/>
    <language>en</language>
    <item>
      <title>Why Elixir?</title>
      <dc:creator>Gustavo Aguiar</dc:creator>
      <pubDate>Sun, 21 Mar 2021 04:13:51 +0000</pubDate>
      <link>https://dev.to/gustavohoa/why-elixir-2j4</link>
      <guid>https://dev.to/gustavohoa/why-elixir-2j4</guid>
      <description>&lt;p&gt;From the languages I love, Elixir is the only dynamically typed one. I have been mulling over why Elixir, and this post surmises it.&lt;/p&gt;

&lt;p&gt;When reasoning about why Elixir, I first reasoned about why ReScript and Rust—the other languages I love. It came down  to one thing: Type Systems.&lt;/p&gt;

&lt;p&gt;Type Systems gives me the reliability that my code is at least handling the assumptions on data and interface correctly. This, in turn, gives me confidence on the code I'm working with. When I arrived at this conclusion it clicked for me: Elixir gives me confidence even without a Type System.&lt;/p&gt;

&lt;p&gt;That confidence comes from Erlang/OTP, which has really great primitives to create fault tolerant systems. So while ReScript and Rust gives me confidence "pre-deploy" because of the Type System, Elixir gives me confidence "post-deploy" because of Erlang/OTP.&lt;/p&gt;

</description>
      <category>elixir</category>
      <category>reliability</category>
      <category>distributedsystems</category>
    </item>
    <item>
      <title>The Pleasure of Clojure(Script): Part 1</title>
      <dc:creator>Gustavo Aguiar</dc:creator>
      <pubDate>Thu, 07 Jan 2021 03:39:19 +0000</pubDate>
      <link>https://dev.to/gustavohoa/the-pleasure-of-clojure-script-part-1-l85</link>
      <guid>https://dev.to/gustavohoa/the-pleasure-of-clojure-script-part-1-l85</guid>
      <description>&lt;p&gt;I like learning languages, and usually give a shot to any language that has some buzz — like Go, Rust, Elixir, ReasonML (now ReScript). But there's one kind of language I have never tried learning, and it was because I thought it so alien. Maybe, just maybe, you can guess which kind of language I'm talking about by the title of this post (spoilers: It's Lisp languages).&lt;/p&gt;

&lt;p&gt;Most people when telling the wonders of Lisp talk about data as code. Now, I haven't quite gone there yet so I don't know what that's about, but I still had a lot of fun using ClojureScript.&lt;/p&gt;

&lt;p&gt;Since I had some free time at my hands (two weeks paid time off), I decided to go knee deep into Lisp and see it in action for myself.&lt;br&gt;
I  fired up Emacs (learned some org while I'm at it), opened up ClojureScript documentation—which is rather scarce sadly—and went on to achieve my goal: Build a static blog with Reagent, which reads from .org files at runtime.&lt;/p&gt;

&lt;p&gt;This series of post is a form to consolidate what I learn along the way until I achieve my final goal.&lt;/p&gt;




&lt;p&gt;Most of the materials I saw teaching people how to build a language used a Lisp syntax. I gave credit for syntax simplicity those times, but the simplicity didn't stay restricted to the syntax.&lt;/p&gt;

</description>
      <category>clojure</category>
      <category>clojurescript</category>
      <category>rust</category>
      <category>javascript</category>
    </item>
  </channel>
</rss>
