<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Marcelo Camargo on Medium]]></title>
        <description><![CDATA[Stories by Marcelo Camargo on Medium]]></description>
        <link>https://medium.com/@haskellcamargo?source=rss-f8c552d9732b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*GSCA18dl92OhyOrR8E7qVA.jpeg</url>
            <title>Stories by Marcelo Camargo on Medium</title>
            <link>https://medium.com/@haskellcamargo?source=rss-f8c552d9732b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 05:39:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@haskellcamargo/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[OO: what you learnt is probably wrong]]></title>
            <link>https://medium.com/rung-brasil/oo-what-you-learnt-is-probably-wrong-9d28aba38927?source=rss-f8c552d9732b------2</link>
            <guid isPermaLink="false">https://medium.com/p/9d28aba38927</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[object-orientation]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[smalltalk]]></category>
            <dc:creator><![CDATA[Marcelo Camargo]]></dc:creator>
            <pubDate>Wed, 13 Dec 2017 16:35:01 GMT</pubDate>
            <atom:updated>2017-12-13T16:35:01.100Z</atom:updated>
            <content:encoded><![CDATA[<p>One of the most misrepresented concepts from computer science. This post doesn’t aims to make you sad, but show that what you learnt in university about object orientation ─ most probably ─ is wrong.</p><blockquote>INB4: In reference to the academic definition, not to the one later misunderstood by enterprises.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vek0xrbCaxgBR-cQXoY1oA.jpeg" /></figure><p>Sorry for the capybaras, but I like to insert them in every article or presentation I do.</p><p>It’s common for most universities to use languages such as <em>C++</em> or <em>Java</em> to teach object orientation concepts ─ or at least try ─ but it is not exactly OO that is taught, but a programming model based on a class system merged to the imperative paradigm. My objective in this article is not to create controversy, but try to demystify some concepts and try to explain what really object orientation is about, and how most modern programming languages do not obey to the its main principles, including the one which use OO support as an advantage for marketing.</p><h4>The OO history</h4><p>The paradigm is old. The modern essential notion of object orientation comes from 50’s, but had its concepts largely defined and represented by Alan Kay, and implemented as reference in the language <em>Smalltalk</em>, which until now is seen like the greatest reference in the paradigm. In general, the term OO is still seen with ambiguity, and there are a lot of flamewars around the Internet about it.</p><h4>OO is not about classes</h4><p>Sorry to make you sad, but a language doesn’t need to have classes to be OO. The language <em>Self</em> introduced a model based on <em>prototypes</em>, avoiding classes, and by default. A concept that could be used previously in <em>Smalltalk</em> since 80&#39;s! Do you want me to prove?<em> JavaScript</em> supports object orientation programming better then Java, and does that based purely on <a href="https://stackoverflow.com/questions/186244/what-does-it-mean-that-javascript-is-a-prototype-based-language"><em>prototype-based-programming</em></a>! Another <em>plot-twist</em>: ES6 also doesn’t have real classes. What you see is in truth syntax sugar for <em>prototypes</em> model that is used inside the VM.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/315/1*FBRi79TYnz-dAR8rx1f9Qg.gif" /></figure><h4>But what is OO?</h4><p>According to the definitions of who created the term, some core concepts must be respected:</p><ul><li><strong>Everything is an object</strong>: seriously. Everything must be an object. Classes must be an object, numbers, primitive values, like <em>strings</em> e <em>booleans</em> and also your dog must be an object.</li><li><strong>Objects communicate by message passing</strong>: this means objects must receive and dispatch messages from ─ and to ─ other objects. For example, the simple operation 1 + 1. Trivial, no? A OO language must deal with 1 as being an object, + as being a message and the other value as being another object. This way, the sum operation would be a message dispatched to the number and that would return another object; in this case, another number. Because of that, in <em>Smalltalk</em>, there is no <strong>operator precedence</strong>, because multiplication and addition are messages sent to the object, and not primitive operations. In this case, control structures you know in other languages ─ such asif, for and while ─ do not exist the same way you see in <em>Java </em>or <em>C++</em>, but you simulate their behaviors using messages.</li><li><strong>Every object is instance of some class</strong>: not exactly a “class” like in <em>Java</em>, but as a shape ─ and this also must be an object. This doesn’t limit prototype based programming.</li><li><strong>Behavior sharing</strong>: that is, the shape ─ the class ─ holds the shared behavior of the objects. For example, arithmetic operations would be behaviors/messages instances of Number!</li><li><strong>When start, the control goes for the first object</strong>: and everything else works with messages. The first object has the control.</li></ul><p>The concepts of Alan Kay for OO also were largely used as base for the concepts of Carl Hewitt for <em>Actors model</em> and concurrent programming. Tim Budd also proposed some additions to Kay’s specification:</p><ul><li>Objects can have their own memory, made up by other objects;</li><li>Adds vertical inheritance control to behavior sharing.</li></ul><h4>Why Java doesn’t satisfy OO?</h4><p>This is maybe the most controversial point of this article. The first broken principle by the definitions is that <strong>everything should be an object.</strong></p><ul><li><strong>Classes are not objects</strong>: however, every classes carries an instance of Class class to describe it. The classes per se are only abstractions. Classes also should be created by message passing.</li><li><strong>Primitive types</strong>: all the primitive values should be objects. <em>Java</em> provides wrappers for these types, like Integer for int, but int, per se, is not an object and thus <strong>do not receive messages</strong>. Arithmetic is native.</li><li><strong>Imperative control structures</strong>: for example, if. true andfalseshould be objects ─ Boolean instances ─ and should be able to receive calls to ifTrue andifFalse to continue the computations. The current concept of methods in <em>Java</em> is based in named methods, but how is it in <em>Smalltalk</em>? The Boolean class has the “methods” ifTrue:ifFalse:, ifTrue: andifFalse:. The dispatch is not based on the name, but in the message that is passed on! Some languages, like <em>Swift </em>and <em>Objective-C</em> provide good support for this behavior, and some support syntax sugar, like <em>Ruby</em>. Please note that <em>Smalltalk 98</em> specification allows some pseudo-messages ─ like conditionals ─ to be implemented “natively”; and disallows overloading them in <em>runtime</em>.</li></ul><p>However, an important detail is that, although <em>Java</em> per se doesn’t makes everything an object, the <a href="https://dzone.com/articles/why-java-is-purely-object-oriented-language-or-why-1">JVM, internally, uses all primitive types as being objects</a>!</p><h4>Cool! I want to see this in practice!</h4><p>Some time ago, me and <a href="https://github.com/ythecombinator">Matheus Albuquerque</a> created a <a href="https://github.com/ythecombinator/safadometro">repository aiming to implement the same algorithm in different programming languages and paradigms</a>, from LISP to <em>Brainfuck</em>, from <em>Rust</em> to <em>COBOL</em>! There you can compare the implementations of Java and C#, for example, with the <em>Smalltalk</em> one, and see stars blinking! Renan Ranelli ─ our famous brazilian Milhouse ─ also has a very interesting <a href="https://www.youtube.com/watch?v=hpP8MiLVd8k">video</a> in portuguese with a human explanation about OO “hipster” definition.</p><h4>Please, don’t kill me…</h4><p>When you learn OO in university, in general, you are learning a programming model based in classes for a language ─ or a set of languages ─ specifically, which inherits and implements ─ but not totally or at most ─ the core concepts of OO. Concepts like polymorphism, inheritance and visibility may be added, but they are not necessarily and intrinsically linked to the largely accepted definition of OO. I don’t what to create flamewars or to say that the language designers are lying to you, but show historical conceptual failures and make the original concept a bit clearer. Complaints, please redirect to Milton. Thanks!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*VwRjwQtxqH7n7yxaLh4NNw.jpeg" /></figure><h3>References and useful links</h3><ul><li><a href="https://softwareengineering.stackexchange.com/questions/115418/do-object-oriented-programming-languages-exist-that-are-not-class-based">Do object-oriented programming languages exist that are not class based?</a></li><li><a href="http://wiki.c2.com/?AlanKaysDefinitionOfObjectOriented">Alan Kay Definitions of Object Oriented</a></li><li><a href="http://wiki.c2.com/?EarlyHistoryOfSmalltalk">Early History of Smalltalk</a></li><li><a href="https://stackoverflow.com/questions/11990270/are-java-classes-objects">Are Java classes objects?</a></li><li><a href="https://stackoverflow.com/questions/6151497/what-makes-java-not-pure-object-oriented-language">What makes Java not pure object oriented language?</a></li></ul><p>This article is a translation from <a href="https://medium.com/rung-brasil/oo-o-que-voc%C3%AA-aprendeu-provavelmente-est%C3%A1-errado-c1ac7a240df8">portuguese one</a>, originally written by <a href="https://github.com/haskellcamargo">Marcelo Haskell Camargo</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9d28aba38927" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rung-brasil/oo-what-you-learnt-is-probably-wrong-9d28aba38927">OO: what you learnt is probably wrong</a> was originally published in <a href="https://medium.com/rung-brasil">Rung Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Então você ainda não entende monads?]]></title>
            <link>https://medium.com/rung-brasil/ent%C3%A3o-voc%C3%AA-ainda-n%C3%A3o-entende-monads-1ea62e0c14a7?source=rss-f8c552d9732b------2</link>
            <guid isPermaLink="false">https://medium.com/p/1ea62e0c14a7</guid>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[monads]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[haskell]]></category>
            <dc:creator><![CDATA[Marcelo Camargo]]></dc:creator>
            <pubDate>Tue, 12 Dec 2017 17:15:51 GMT</pubDate>
            <atom:updated>2017-12-12T17:23:02.769Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SkYxdjXOfBSo58NSuuc4uw.jpeg" /><figcaption>Um monad em seu habitat natural</figcaption></figure><blockquote>Acadêmicos, não me matem. Este artigo visa abordar monads de uma maneira humana e prática, analisando problemas e soluções, e não as leis matemáticas que os compõe. A Internet está cheia de artigos com a definição formal, mas faltam textos mais contextuais e filosóficos sobre o tema.</blockquote><p>Quando você começa a aprofundar-se em programação funcional, começa também a deparar-se com termos obscuros até então nunca sequer ouvidos, termos abstratos e que as pessoas tem dificuldade de explicar por envolverem outros termos tão abstratos quanto, termos matemáticos; então você finge que entendeu o conceito porque está em alta, porque é 🔝, porque é “apenas um monoid na categorias dos endofunctors”, mas por dentro ainda está confuso 😕.</p><p>Existem diversos tutoriais sobre monads na Internet com as mais bizarras analogias para tentar explicá-los. Analogias que variam de elefantes a burritos mexicanos. Monads foram aplicados às linguagens de programação para resolver problemas, mas que problemas eles resolvem e como resolvem? Vamos entender antes um pouco como a maioria das linguagens funcionais trabalham.</p><h3>Ordem? O que é isso?</h3><p>Levando em conta que todas as definições de um programa consistem de funções e possuímos imutabilidade, a ordem de computação das expressões do seu código deixa de ser importante porque temos segurança de que não existirão efeitos capazes interferir na resolução de dependências entre expressões. Considere a seguinte expressão, válida em Haskell e em JavaScript:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/23eaa017929792c3dfd408210b0d7cd5/href">https://medium.com/media/23eaa017929792c3dfd408210b0d7cd5/href</a></iframe><p>É apenas uma lista com operações em números inteiros, certo?</p><p>É sim, mas a diferença de Haskell para JavaScript é que em Haskell você não tem controle sobre a ordem em que as expressões são computadas. Enquanto JavaScript vai fazer 1 + 1, então 2 + 2 e assim computar sequencialmente, Haskell vai computar arbitrariamente porque não há dependência entre os valores; geralmente vai computar em paralelo (mais de uma expressão ao mesmo tempo), o que nos dá “de graça” grandes ganhos de performance através de garantia matemática, porque consegue realizar múltiplas computações em diferentes núcleos do seu processador e diferentes processos, mas nem tudo são flores.</p><h3>O problema</h3><p>Mas e quando a ordem realmente <strong>importa</strong>? E quando eu tenho efeitos e preciso que eles sigam uma sequência, como quando escrevo algo na tela em uma chamada de função ou leio algo da tela?</p><blockquote>Monads ao resgate!</blockquote><p>Monads não são sobre “purismo funcional”, são sobre <strong>sequenciamento</strong> e <strong>ordem</strong>. O termo é bastante elitizado, mas, basicamente, é uma especificação ─ um conjunto de leis ─ que permite controlarmos a ordem e a dependência de computações em linguagens funcionais e possuirmos algo relativamente próximo aos <em>statements</em> das linguagens imperativas. Analise o seguinte trecho em Python:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/474f36a1ec59913e58f79365268a15e9/href">https://medium.com/media/474f36a1ec59913e58f79365268a15e9/href</a></iframe><p>Note que o programa é composto por duas ações:</p><ul><li>Ler o nome do usuário;</li><li>Exibir o nome do usuário em uma mensagem.</li></ul><p>Nessa situação, precisamos de uma operação que bloqueie a UI e bloqueie a computação seguinte (por conta da dependência), mas linguagens puramente funcionais, como Haskell, não tem o conceito de sequenciar, então o que faremos?</p><h3>A solução</h3><p>Como a abstração de linguagens funcionais deriva do cálculo-λ, usamos a abstração matemática para moldar sequenciamento.</p><p>Um monad, então, programaticamente, é uma estrutura que pode ser composta com outra de maneira a retornar outra estrutura também capaz disso. Linguagens imperativas não precisam de monads porque já temos sequenciamento por padrão (atráves dos <em>statements</em>), mas o lado ruim delas é que é muito mais difícil para o compilador encontrar oportunidades de otimização). Vamos reescrever o programa em Python que vimos antes em Haskell:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d788209f7e0ebaf14df43a3f3f5fd1d4/href">https://medium.com/media/d788209f7e0ebaf14df43a3f3f5fd1d4/href</a></iframe><p>Utilizamos os operadores &gt;&gt; e &gt;&gt;= para sequenciar as operações. É como definimos os “passos” de um programa de maneira composicional.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*imxtCJUNJWFV9_LVTYrg7w.jpeg" /><figcaption>É como brincar de Lego!</figcaption></figure><p>As operações de escrever e ler da tela retornam monads. Escrever retorna um monad sem conteúdo interno e ler retorna um monad com o texto. O operador &gt;&gt; sequencia e ignora o valor interno do monad à esquerda e o operador &gt;&gt;= sequencia e chama a função à direita passando o conteúdo do monad e exige que outro monad seja retornado para poder continuar compondo. Uma analogia próxima das linguagens atuais é comparar monads com o ;; apesar das distinções “matemáticas”, o problema que visam resolver é similar.</p><h4>Quando monads são úteis?</h4><ul><li>Quando precisamos combinar computações;</li><li>Quando lidamos com computações que podem falhar e sua continuação é condicional;</li><li>Quando queremos lidar com computações bloqueantes e dependentes;</li><li>Se precisarmos definir um intervalo de tempo entre cada operação, similar ao setTimeout do JavaScript;</li><li>Quando queremos dizer para o amiguinho que conhecemos monads 😎.</li></ul><p>Há diversas aplicações práticas, mas que visam resolver problemas de linguagens com um <em>mindset</em> funcional. Se você utiliza apenas Java e C, você precisa conhecer monads tanto quanto um peixe precisa de sua bicicleta, mas se você utiliza ou estuda uma linguagem funcional, conhecer a definição vai ser de grande valia.</p><h3>De uma maneira mais formal</h3><p>Para ser considerado um monad, há leis matemáticas que precisam ser cumpridas 👮; esse não é o foco deste artigo. Você pode encontrar diversos tutoriais sobre a formalização; <strong>este é um tutorial para humanos</strong>.</p><h3>Leituras recomendadas</h3><ul><li><a href="https://wiki.haskell.org/All_About_Monads">All About Monads</a></li><li><a href="http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html">Functors, Applicatives and Monads In Pictures</a></li><li><a href="https://stackoverflow.com/questions/44965/what-is-a-monad">StackOverflow: What is a monad?</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1ea62e0c14a7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rung-brasil/ent%C3%A3o-voc%C3%AA-ainda-n%C3%A3o-entende-monads-1ea62e0c14a7">Então você ainda não entende monads?</a> was originally published in <a href="https://medium.com/rung-brasil">Rung Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[5 mitos desconstruídos sobre linguagens de programação]]></title>
            <link>https://medium.com/rung-brasil/5-mitos-desconstru%C3%ADdos-sobre-linguagens-de-programa%C3%A7%C3%A3o-867038f96c8d?source=rss-f8c552d9732b------2</link>
            <guid isPermaLink="false">https://medium.com/p/867038f96c8d</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[mitos]]></category>
            <category><![CDATA[matematica]]></category>
            <dc:creator><![CDATA[Marcelo Camargo]]></dc:creator>
            <pubDate>Mon, 04 Dec 2017 16:59:29 GMT</pubDate>
            <atom:updated>2017-12-07T16:21:12.382Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iIb2C0FcyfshkUERj62a4w.png" /></figure><p>Após essa publicação, provavelmente serei caçado pela Santa Inquisição, mas vejo como algo necessário em virtude da grande quantidade de falácias relacionadas a linguagens de programação e paradigmas que são diariamente disseminadas ─ principalmente entre as pessoas que estão começando a programar ─ e podem tornar-se uma bola de neve de mentiras e, eventualmente, prejudicar o aprendizado.</p><blockquote>De antemão, considero positiva a discussão de maneira saudável e argumentativa. Comentários como “você diz isso porque não sabe programar” e “minha linguagem é boa porque paga meu salário” apenas serão sumariamente ignorados <em>😄</em>!</blockquote><p>Prepare-se para ter seus sonhos destruídos!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/350/1*KfvvGZU3EW3IjB--X_0xCw.gif" /></figure><h3>1. Para programar, preciso ser bom em matemática</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*rYZNh58n6g_0EXNXphjtgg.png" /></figure><p>Que tal começarmos com algo não tão polêmico? É comum encontrarmos perguntas nos grupos de programação com esse teor; pessoas com desejo de aventurar-se no maravilhoso e depressivo mundo da p̶r̶e̶o̶c̶u̶p̶a̶ç̶ã̶o̶ programação, mas preocupadas se seus conhecimentos matemáticos atuais serão suficientes. Programar não é sobre matemática. Programar é sobre resolver e abstrair problemas. Você não precisa sequer possuir um conhecimento “acima da média” em matemática para isso. De maneira pessoal, a maioria dos excelentes programadores que conheço são <strong>péssimos em cálculo</strong> (isso não é um incentivo!).</p><p>Definitivamente, há modelos computacionais que utilizam a matemática como base, como o cálculo-λ, mas não é a matemática como você imagina. Matemática não é apenas sobre números; os números são apenas a ponta do <em>iceberg</em>.</p><h3>2. C é baixo nível</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wpR6wtI-dRbEHb8lql-lEg.png" /></figure><p>“C é baixo nível e próximo do código de máquina” é algo comum de ouvir-se principalmente quando inicia-se um curso na faculdade. Taxonomia, em ciência da computação, é algo realmente problemático e, em muitas situações, não há uma convenção ou universalidade de definição de um termo. Comparar os níveis de abstração de linguagens em relação ao seu modelo computacional é algo absurdamente relativo.</p><p><strong>Uma linguagem de baixo nível</strong> é uma linguagem de programação que provê <strong>pouca</strong> ou <strong>nenhuma</strong> abstração do conjunto de instruções de um computador, onde há um mapeamento direto ou quase direto entre as instruções. Geralmente, costuma-se ter um padrão ao classificar código de máquina ou Assembly dentro desse nível (mas não C). A palavra “baixo” refere-se justamente à abstração, à distância do <em>hardware</em> em questão. Programas escritos em linguagens de baixo nível tendem a <strong>não serem portáveis</strong>, principalmente devido a detalhes específicos da arquitetura do <em>hardware</em>.</p><p>Sumariamente, a linguagem C é considerada uma linguagem de alto nível, mas no baixo nível do espectro das linguagens de alto nível. A linguagem é abstrata o suficiente para expressar algoritmos e estruturas de dados sem preocupação direta com detalhes dependentes de <em>hardware</em>, tornando o código-fonte portável a uma variedade de <em>hardwares</em>, sendo o código escrito com portabilidade em mente. O código final emitido pelo compilador, a depender da arquitetura, pode ser absurdamente diferente do código de específico para a máquina.</p><p>Outro fator que permite incluirmos C no grupo das linguagens com maior abstração é o sistema de tipos que, apesar de inseguro, tenta rejeitar em tempo de compilação parte dos programas considerados inválidos, e é geralmente capaz de aplicar otimizações em cima da análise estática do código, que nos provê abstrações que distanciam-se da arquitetura com um foco maior em corretude.</p><h4>Referências e leituras recomendadas</h4><ul><li><a href="https://softwareengineering.stackexchange.com/questions/303117/is-c-programming-language-low-level-or-high-level">Is C programming language low lever or high level?</a></li><li><a href="https://www.quora.com/Why-is-C-considered-a-low-level-language">Why is C considered a low level language?</a></li></ul><h3>3. Java é totalmente orientada a objetos</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hJoPszIV6MtNUxqLBrDhqw.png" /></figure><blockquote>Espero não ser processado pela Oracle por usar o logo de Java aqui.</blockquote><p>O título pode parecer um pouco “tendencioso”, mas faz sentido. A orientação a objetos provavelmente não é o que você acha que é ou o que você aprendeu na faculdade. Se quiser detalhes sobre o paradigma, <a href="https://medium.com/rung-brasil/oo-o-que-voc%C3%AA-aprendeu-provavelmente-est%C3%A1-errado-c1ac7a240df8">escrevi um artigo com o tema</a>. Ao analisarmos utilizando a taxonomia comum a ciência da computação e a definição de <em>Alan Kay</em>, criador do paradigma, Java implementa orientação a objetos de maneira incompleta; e utiliza programação estruturada para satisfazer a grande parte do “buraco” que fica aberto na falha em implementar a real definição de orientação a objetos. O artigo mencionado acima possui maiores detalhes que vão esclarecer isso, mas posso resumir: orientação a objetos não é sobre classes, é sobre objetos comunicando-se por passagem de mensagens onde todo elemento da linguagem é um objeto (incluindo classes e tipos primitivos, o que não é verdade em Java).</p><p>Quando estuda-se orientação a objetos, Java passa longe de ser a melhor linguagem para abordar o paradigma. Smalltalk e até mesmo Ruby seriam mais adequadas.</p><h4>Referências e leituras recomendadas</h4><ul><li><a href="https://medium.com/rung-brasil/oo-o-que-voc%C3%AA-aprendeu-provavelmente-est%C3%A1-errado-c1ac7a240df8">OO: o que você aprendeu provavelmente está errado</a></li><li><a href="http://wiki.c2.com/?AlanKaysDefinitionOfObjectOriented">Alan Kays Definition Of Object Oriented</a></li><li><a href="https://stackoverflow.com/questions/974583/is-java-100-object-oriented">Is Java 100% object oriented?</a></li></ul><h3>4. Linguagens de programação são perfeitas</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V08-T5UGoGfeeyR9_i8a8A.png" /></figure><p>Projetistas de linguagens de programação não são deuses e linguagens de programação possuem falhas. Quem projetou sua linguagem de programação provavelmente foi um programador como você e eu. É muito comum vermos em grupos de programação as pessoas defendendo suas linguagens com unhas e dentes porque pagam seus salários e aceitarem as falhas técnicas como características não acidentais em virtude disso. A batalha de ego geralmente favorece isso ainda mais. Há uma extensa área dentro de ciência da computação com foco em teoria de linguagens de programação. Há pessoas trabalhando para encontrar falhas em linguagens de programação, corrigi-las e tornar as linguagens do futuro melhores e capazes de resolver com mais eficácia os problemas. Engana-se quem pensa que levantar os pontos negativos das tecnologias é algo negativo ou “coisa de hater”. É assim que as coisas evoluem, é quando as pessoas estão insatisfeitas com soluções atuais e buscam soluções melhoradas.</p><h3>5. Lógica de programação é universal</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lUN03Z8owK7pl7jz6IqIMw.png" /></figure><p>Talvez essa seja a seção que faça vocês enviarem cocô via <em>SEDEX</em> para o meu endereço. O termo “lógica de programação” é amplamente utilizado no Brasil, principalmente na academia (universidades em geral) no ensino da programação básica. O engraçado é que “lógica de programação” não é realmente algo que <strong>existe</strong>. O termo é utilizado <strong>somente</strong> na nossa literatura e não possui equivalência na literatura estrangeira, e também não é visto como um modelo lógico (como a lógica de predicados, por exemplo). Seríamos nós, os brasileiros, os detentores dessa maravilhosa fonte de conhecimento ou teríamos apenas generalizado e deturpado o termo?</p><p>O que referencia-se no Brasil por lógica de programação nada mais é do que a lógica assertiva imperativa, o modelo de algoritmos (sequencial) utilizado para moldar programas em um paradigma específico ─ em 1 paradigma dos mais de 150 existentes. Por causa dessa falha de definição, as pessoas tendem a acreditar que para aprender uma nova linguagem é necessário “apenas a lógica, já que ela é universal”, o que não é verdade. Aprender uma linguagem torna mais fácil o aprendizado de novas linguagens da mesma família e paradigma dela, por exemplo, se você aprender Java, ficará fácil aprender C#, mas você terá a mesma dificuldade para aprender Haskell ou Prolog que alguém que nunca programou, e generalizar programação como programação imperativa é ignorar diversos outros modelos computacionais e linguagens de programação amplamente utilizadas (inclusive para modelar <em>hardware</em>). Engana-se caso acredite que “toda linguagem tem if, toda linguagem tem for”.</p><h4>Referências e leituras recomendadas</h4><ul><li><a href="https://www.youtube.com/watch?v=VpzhH9CXOy0">Lógica de programação não existe</a></li><li><a href="https://mitpress.mit.edu/sicp/">Structure and Interpretation of Computer Programs</a></li></ul><h3>TL;DR</h3><p>Minha intenção não é causar problemas e plantar <em>baits</em>, mas estimular discussões e questionamentos. Sinta-se à vontade para argumentar e expor seus pontos, ficarei feliz. Quem gostou, bate palma 🎉; quem não gostou, paciência 😞. Obrigado e até próxima, amiguinhos!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=867038f96c8d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rung-brasil/5-mitos-desconstru%C3%ADdos-sobre-linguagens-de-programa%C3%A7%C3%A3o-867038f96c8d">5 mitos desconstruídos sobre linguagens de programação</a> was originally published in <a href="https://medium.com/rung-brasil">Rung Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pipe operator em JavaScript com o Babel]]></title>
            <link>https://medium.com/rung-brasil/pipe-operator-em-javascript-com-o-babel-f6557dffdc42?source=rss-f8c552d9732b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f6557dffdc42</guid>
            <category><![CDATA[compilers]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[babeljs]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[functional-programming]]></category>
            <dc:creator><![CDATA[Marcelo Camargo]]></dc:creator>
            <pubDate>Mon, 27 Nov 2017 18:57:45 GMT</pubDate>
            <atom:updated>2017-12-07T16:21:54.685Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>…ou como ter um fluxo decente e legível ao trabalhar com funções</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/929/1*6gI5oQsAfgq5xLrxhwdrGQ.png" /></figure><p>Quando trabalhamos diretamente com funções em JavaScript, é comum nos perdermos em meio à complexa pilha de chamadas encadeadas e dezenas de parênteses um tanto confusos. O operador de pipe é comum nas linguagens funcionais, como LiveScript, OCaml, Elixir e F#, e ajuda a modelar o fluxo de uma forma mais humana do que a composição direta.</p><p>Se você usa o <em>Babel</em>, deve saber que o compilador possui uma extensividade tremenda. No <a href="https://rung.com.br/">Rung</a>, utilizamos amplamente a extensibilidade do compilador para modelar soluções para nossos problemas; normalmente através de plugins para o compilador.</p><p>Há a <a href="https://github.com/tc39/proposal-pipeline-operator">proposta do operador de pipe</a> |&gt; para JavaScript, mas ela possui diversas limitações (como não permitir corretamente parcialização), e dificulta o trabalho com algumas bibliotecas, como a <em>Ramda. </em>No entanto, não nos limitaremos. Podemos sobrecarregar o operador | para trabalhar com funções.</p><h4>Configure o Babel</h4><p>O processo é relativamente simples. O plugin está disponível no <a href="https://github.com/Swizz/babel-plugin-pipe-operator-curry">GitHub</a>. Tudo que precisamos fazer é instalá-lo como dependência de desenvolvimento e adicionar sua configuração ao .babelrc:</p><p>npm install --save-dev babel-plugin-pipe-operator-curry</p><p>E no .babelrc:</p><pre>&quot;plugins&quot;: [&quot;pipe-operator-curry&quot;]</pre><p>Então, toda ocorrência de x | f(y) será substituída por f(y)(x).</p><p>Isso nos permite simplificar grandemente séries de transformações:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/663/1*lIkRCj0RHxLTus1j5e1Y2g.png" /></figure><p>Se você trabalha amplamente com funções, outra utilidade pode ser o <a href="https://github.com/haskellcamargo/babel-plugin-function-composition/">babel-plugin-function-composition</a>, que sobrecarrega o operador &amp; para compor funções e retornar funções mais complexas a partir disso. Dessa maneira, poderíamos modelar o exemplo acima por composição, criando uma função isolada e usando <em>tacit programming</em>, também conhecida como programação <em>point-free</em>, onde funções são criadas mesmo com os argumentos omitidos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/1*WnKQXA6X2DTLHoHPr53nFQ.png" /></figure><p>Nessa situação, getValue será não um valor literal, mas uma função, que quando aplicada a uma lista sequenciará as computações. Utilizamos ali uma técnica conhecida como <em>aplicação parcial</em>.</p><h4>Não tenha medo do compilador</h4><p>O <em>Babel</em> é seu amigo. Não tenha medo dele. A sua extensibilidade permite adaptar a linguagem da maneira que melhor resolve seu problema, e existem diversos <a href="https://github.com/babel/awesome-babel#plugins"><em>plugins</em></a> excelentes para ele. Aproveite sem medo 😄!</p><h4>Referências</h4><ul><li><a href="https://www.npmjs.com/package/babel-plugin-pipe-operator-curry">babel-plugin-pipe-operator-curry</a></li><li><a href="https://github.com/haskellcamargo/babel-plugin-function-composition/">babel-plugin-function-composition</a></li><li><a href="https://github.com/tc39/proposal-pipeline-operator">TC39 proposal-pipe-operator</a></li><li><a href="https://github.com/babel/awesome-babel">Awesome Babel</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f6557dffdc42" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rung-brasil/pipe-operator-em-javascript-com-o-babel-f6557dffdc42">Pipe operator em JavaScript com o Babel</a> was originally published in <a href="https://medium.com/rung-brasil">Rung Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OO: o que você aprendeu provavelmente está errado]]></title>
            <link>https://medium.com/rung-brasil/oo-o-que-voc%C3%AA-aprendeu-provavelmente-est%C3%A1-errado-c1ac7a240df8?source=rss-f8c552d9732b------2</link>
            <guid isPermaLink="false">https://medium.com/p/c1ac7a240df8</guid>
            <category><![CDATA[object-orientation]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[smalltalk]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[developer]]></category>
            <dc:creator><![CDATA[Marcelo Camargo]]></dc:creator>
            <pubDate>Tue, 12 Sep 2017 15:59:31 GMT</pubDate>
            <atom:updated>2017-09-28T18:17:48.056Z</atom:updated>
            <content:encoded><![CDATA[<p>Um dos conceitos mais deturpados e mal-interpretados de ciência da computação. O objetivo deste post não é acabar com a sua alegria, mas de mostrar que o que você aprendeu na faculdade sobre o paradigma ─ muito provavelmente ─ está errado.</p><blockquote>INB4: Referindo-se à definição acadêmica, não à definição posteriormente banalizada pelo mercado.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zl0uz9kcZJvBPCf2CG-fgg.jpeg" /></figure><p>Perdão pelas capivaras, mas gosto de inseri-las em todo artigo ou apresentação.</p><p>É comum que a maior parte das instituições universitárias utilizem linguagens como <em>C++</em> ou <em>Java</em> para ensinar os conceitos de orientação a objetos ─ ou tentar ─ mas não é exatamente OO que é repassado, mas um modelo de programação baseado em um sistema de classes e mesclado ao paradigma imperativo. Meu objetivo neste artigo não é causar polêmica, mas desmistificar alguns conceitos e tentar explicar sobre o que realmente se trata orientação a objetos, e como a maior parte das linguagens modernas não satisfaz ao princípio do paradigma, mesmo usando a capacidade de ser OO como uma “vantagem”.</p><h4>Quando surgiu OO?</h4><p>O paradigma é antigo. A noção essencial moderna de orientação a objetos surgiu no final dos anos 50, mas teve seus conceitos amplamente definidos e representados por Alan Kay, e implementados como referência na linguagem <em>Smalltalk</em>, que até os dias atuais é atualizada e vista como referência do paradigma. No geral, o termo OO ainda é visto com grande ambiguidade, e é alvo de <em>flamewars</em> com uma certa frequência.</p><h4>OO nao é sobre classes</h4><p>Desculpe decepcioná-lo, mas uma linguagem não precisa possuir classes para ser OO. A linguagem <em>Self</em> introduziu um modelo baseado em <em>prototypes</em>, livre de classes, de maneira padrão. Um conceito que já podia anteriormente ser utilizado em <em>Smalltalk</em> desde os anos 80! Quer uma prova? <em>JavaScript</em> permite programação orientada a objetos de uma maneira ainda mais pura que Java, e o faz baseando-se em <a href="https://stackoverflow.com/questions/186244/what-does-it-mean-that-javascript-is-a-prototype-based-language"><em>prototype-based-programming</em></a>! Um outro <em>plot-twist</em>: Nem mesmo <em>ES6</em> tem classes de verdade. O que você vê são abstrações sintáticas para o modelo padrão baseado em protótipos que é utilizado dentro da VM.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/315/1*DBGdHlkB6DVjBy62d3TANQ.gif" /></figure><h4>Mas o que é OO?</h4><p>Segundo as definições do criador do termo, alguns conceitos precisam ser respeitados:</p><ul><li><strong>Tudo é um objeto</strong>: é sério. Tudo deve ser um objeto. Classes devem ser um objeto, números, valores primitivos, como <em>strings</em> e <em>booleans</em> e até mesmo seu cachorro deve ser um objeto.</li><li><strong>Objetos se comunicam por passagem de mensagem</strong>: isso significa que objetos devem receber e despachar mensagens de ─ e para ─ outros objetos. Por exemplo, a operação simples 1 + 1. Trivial, não? Uma linguagem OO deve tratar o valor 1 como sendo um objeto, + como sendo uma mensagem e o outro valor como sendo outro objeto. Dessa maneira, a operação de soma seria uma mensagem repassada ao número, que retornaria outro objeto; no caso, outro número. Por essa razão, em <em>Smalltalk</em>, não há <strong>precedência de operadores</strong>, porque multiplicação e adição são mensagens repassadas ao objeto, e não operações primitivas. No caso, as estruturas como você conhece em outras linguagens ─ como if, for e while ─ não existem da mesma maneira que você vê em <em>Java</em> ou <em>C++</em>, mas você simula o comportamento delas usando mensagens.</li><li><strong>Todo objeto é uma instância de uma classe</strong>: mas não necessariamente uma “classe” nos conceitos definidos em <em>Java</em>, mas de um molde, uma forma ─ e esta também deve ser um objeto. Isso não limita a programação baseada em protótipos.</li><li><strong>Compartilhamento de comportamento</strong>: ou seja, o molde ─ a classe ─ carrega o comportamento compartilhado para os objetos. Por exemplo, as operações aritméticas seriam comportamentos/mensagens de instâncias de Number!</li><li><strong>Ao iniciar, o controle é passado para o primeiro objeto</strong>: e o restante é tratado como mensagens. O primeiro objeto retém o controle.</li></ul><p>Os conceitos de Alan Kay para OO também foram amplamente aproveitados para os conceitos de Carl Hewitt para <em>Actors model</em> e programação concorrente. Tim Budd propôs alguns adicionais à especificação de Alan Kay:</p><ul><li>Objetos possuem sua própria memória, que consiste de outros objetos;</li><li>Adiciona-se o conceito de herança vertical para compartilhamento de comportamento.</li></ul><h4>Por que <em>Java</em> não satisfaz OO?</h4><p>Talvez o ponto mais polêmico deste artigo. O primeiro princípio é inicialmente quebrado pelas definições de que <strong>tudo deve ser um objeto</strong>.</p><ul><li><strong>Classes não são objetos</strong>: no entanto, toda classe carrega uma instância da classe Class para descrevê-la. As classes por si são apenas abstrações. Até mesmo as classes deveriam poder ser criadas a partir de mensagens.</li><li><strong>Existência de tipos primitivos</strong>: até mesmo os valores primitivos devem ser objetos. <em>Java</em> provê <em>wrappers </em>para esses tipos, como Integer para int, mas int, por si, não é um objeto e <strong>não recebe mensagens</strong>. A aritmética é nativa.</li><li><strong>Existência de estruturas imperativas</strong>: por exemplo, if. true e false deveriam ser objetos ─ instâncias de Boolean ─ e deveriam poder receber chamadas para ifTrue e ifFalse para continuar as computações. O conceito atual de métodos de <em>Java</em> é baseado em nomes únicos em métodos, mas como é em <em>Smalltalk</em>? A classe Boolean possui os “métodos” ifTrue:ifFalse:, ifTrue: e ifFalse:. No caso, o despacho não ocorre baseado no nome do método, mas no que ele recebe! Algumas linguagens, como <em>Swift </em>e <em>Objective-C</em> suportam bem esse comportamento, e algumas o suportam com abstrações sintáticas, como <em>Ruby</em>. Note que o padrão <em>Smalltalk 98</em> permite que algumas pseudo-mensagens ─ como ações condicionais ─ possam ser implementadas “nativamente”; e que não possam ser sobrecarregadas em <em>runtime</em>.</li></ul><p>No entanto, um detalhe bastante importante é que, apesar de <em>Java</em> por si não tratar tudo como um objeto, a <a href="https://dzone.com/articles/why-java-is-purely-object-oriented-language-or-why-1">JVM, internamente, trata todos os primitivos como sendo objetos</a>!</p><h4>Legal! Quero ver isso na prática!</h4><p>Há um tempo, eu e o <a href="https://github.com/ythecombinator">Matheus Albuquerque</a> criamos um <a href="https://github.com/ythecombinator/safadometro">repositório com o objetivo de implementar o mesmo algoritmo em diferentes linguagens e paradigmas</a>, de <em>LISP</em> a <em>Brainfuck</em>, de <em>Rust</em> a <em>COBOL</em>! Nele vocês podem comparar a implementação de <em>Java</em> ou <em>C#</em>, por exemplo, com a de <em>Smalltalk</em>, e ver estrelinhas brilharem! O Renan Ranelli ─ nosso Milhouse ─ também tem um <a href="https://www.youtube.com/watch?v=hpP8MiLVd8k">vídeo</a> bem interessante e humano sobre a definição de OO “hipster”.</p><h4>Por favor, não me matem…</h4><p>Quando vocês aprendem OO na faculdade, no geral, estão aprendendo um modelo de programação baseado em classes para uma linguagem ─ ou grupo de linguagens ─ em específico, que herda e implementa ─ mas não em sua totalidade ou maior parte ─ os conceitos de OO. Os conceitos de polimorfismo, herança e visibilidade podem ser adicionados, mas não estão necessariamente e intrinsecamente ligados à definição amplamente aceita de OO. Meu objetivo não é causar tretas ou dizer que a linguagem não é o que diz ser, mas apontar falhas conceituais históricas e deixar o conceito original um pouco mais claro. Reclamações, favor falar com o Milton. Obrigado!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*0jd_Kjoj3BXLi9b0QSyW2A.jpeg" /></figure><h3>Referências e links úteis</h3><ul><li><a href="https://softwareengineering.stackexchange.com/questions/115418/do-object-oriented-programming-languages-exist-that-are-not-class-based">Do object-oriented programming languages exist that are not class based?</a></li><li><a href="http://wiki.c2.com/?AlanKaysDefinitionOfObjectOriented">Alan Kay Definitions of Object Oriented</a></li><li><a href="http://wiki.c2.com/?EarlyHistoryOfSmalltalk">Early History of Smalltalk</a></li><li><a href="https://stackoverflow.com/questions/11990270/are-java-classes-objects">Are Java classes objects?</a></li><li><a href="https://stackoverflow.com/questions/6151497/what-makes-java-not-pure-object-oriented-language">What makes Java not pure object oriented language?</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c1ac7a240df8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rung-brasil/oo-o-que-voc%C3%AA-aprendeu-provavelmente-est%C3%A1-errado-c1ac7a240df8">OO: o que você aprendeu provavelmente está errado</a> was originally published in <a href="https://medium.com/rung-brasil">Rung Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>