Freenode #clj-br 2014-07-29

freenode_clj-sp_2014-07-29.txt

[09:50] == pbalduino [b3a45769@gateway/web/freenode/ip.179.164.87.105] has joined #clj-br
[09:50] <pbalduino> mario-goulart: bom dia
[09:51] <mario-goulart> Alô pbalduino.  Bom dia.
[09:56] == andrewhr [[email protected]] has joined #clj-br
[09:56] == andreanastacio [[email protected]] has joined #clj-br
[10:01] <mario-goulart> andreanastacio e andrewhr: vocês são a mesma pessoa? :-)
[10:02] <andreanastacio> hehe nao
[10:02] <andreanastacio> trabalhamos juntos
[10:02] <mario-goulart> !
[10:02] <mario-goulart> Bacana. :-)
[10:02] <andrewhr> hehehhehe
[10:02] <andrewhr> ola mario-goulart :)
[10:03] <mario-goulart> Dois usuarios com prefixo "andre" conectando ao mesmo tempo nos mesmos canais, usando o mesmo IP... :-)
[10:04] <andrewhr> fique tranquilo, não há nenhuma conspiração aqui ;)
[10:04] <mario-goulart> :-D
[10:04] <andreanastacio> ele é andrew e eu sou andre
[10:04] <mario-goulart> Ah, ok.
[10:05] <mario-goulart> Vocês usam clojure no trabalho?
[10:05] <mario-goulart> pbalduino? ^
[10:05] <andrewhr> nope, eu uso (primariamente) Ruby
[10:06] <andrewhr> mas ultimamente todo meu tempo livre que programo procuro usar Clojure (mas nada significativo)
[10:07] <andreanastacio> Ruby aqui tambem e estou sem tempo livre para brincar com clojure :/
[10:09] <pbalduino> mario-goulart: sim
[10:09] <pbalduino> mario-goulart: temos alguns projetos aqui que foram reescritos em clojure. stealthy and low profile, mas foram
[10:10] <mario-goulart> andrewhr, andreanastacio: estão investindo em clojure na perspectiva de usá-la no trabalho, ou por curiosidade?
[10:10] <mario-goulart> pbalduino: bacana.  Em que área? (caso possas falar)
[10:11] <pbalduino> backend
[10:12] <pbalduino> pra web estão usando grails. apesar de eu também programar em groovy, acho uma linguagem bem mais fraca que clojure. mas para web eu não arriscaria usar clojure aqui.
[10:12] <pbalduino> com certeza usaria rails com jruby
[10:12] <andrewhr> mario-goulart: nenhum plano malígno ainda, mas gostaria de me capacitar bem por conta de ser uma ótima ferramenta para por no cinto de utilidades.
[10:12] <andreanastacio> por enquanto é curiosidade, eu gosto de desenvolvimento de jogos e me interessei com a estrutura que foi trabalhada no lighttable.
[10:12] <andrewhr> como fazemos muito web, caio nesse mesmo caso do pbalduino: ainda nada superara o bom e velho rails para esse use-case
[10:13] <andreanastacio> eu estou pensando em usar com o libgdx para desenvolver algum game
[10:13] <mario-goulart> Interessante.  Sou analfabeto em Ruby, mas achei que Clojure já fosse uma alternativa à altura.
[10:14] <mario-goulart> Honestamente, sou analfabeto em Clojure também. :-)
[10:14] <andreanastacio> somos 2 mario-goulart
[10:14] <andrewhr> mario-goulart: depende. Olhei (bem por cima) em coisas como o http://caribou.github.io
[10:15] <mario-goulart> andrewhr: recebi um 404
[10:15] <andrewhr> e acho muito elegando a forma como hiccup pode gerar o HTML. Mas sendo bem sincero, acho difícil a “moda pegar”
[10:15] <andrewhr> desculpe, url errada: http://let-caribou.in
[10:16] <mario-goulart> Ah, ok.  Essa funciona.  Obrigado.
[10:18] <mario-goulart> Interessante.  Parece ser algo como o Rails, não?
[10:18] <pbalduino> **disclaimer: essa é a minha opinião e não reflete a opinião oficial do clojure**: eu acho que o Clojure, pela sua ideia de trabalhar com funções que vão compondo uma solução para algo maior, apresenta uma série de libs bem bacanas
[10:18] <pbalduino> mas no conjunto, especialmente pra quem vem do comodismo de um Rails, acaba sendo menos produtivo
[10:19] <pbalduino> e, pelo menos na minha experiência, cedo ou tarde vc acaba agregando coisas para ter parte da produtividade que se tem no Rails
[10:19] <pbalduino> não em termos de linguagem. eu considero Clojure superior ao Ruby
[10:19] <pbalduino> mas em termos de ferramental
[10:20] <pbalduino> o core team do rails investe bastante em segurança
[10:20] <pbalduino> já o clojure para web ainda não é tão maduro quanto nesse ponto
[10:20] <mario-goulart> Entendi.
[10:20] <pbalduino> </opiniao> :)
[10:21] <andrewhr> agree
[10:21] <mario-goulart> Pelo que entendi, Ruby tem mais coisas integradas e prontas para uso do que Clojure então?
[10:21] <pbalduino> se eu usaria clojure pra web? não usaria como vou usar em dois projetos bacanas para a comunidade. mas aqui na empresa, não.
[10:21] <pbalduino> o Rails especificamente é um monolito gigante
[10:22] <pbalduino> vc não tem tanta flexibilidade com ele quanto vc teria com as libs do Clojure
[10:22] <pbalduino> mas normalmente vc não precisa de tanta flexibilidade
[10:22] <pbalduino> vc quer a coisa pronta
[10:22] <pbalduino> o trabalho entregue
[10:22] <pbalduino> vc quer o "good enough", nao o estado da arte
[10:23] <mario-goulart> Às vezes flexibilidade é o que atrapalha em "frameworks".  Meio que vai contra a parte do "frame". :-)
[10:23] <pbalduino> sim
[10:23] <pbalduino> frame é moldura. vc fica preso a ela.
[10:23] <pbalduino> não estou nem discutindo se é melhor ou pior
[10:23] <mario-goulart> Pois é.
[10:23] <pbalduino> mas as vezes vc só precsa de um crud
[10:23] <mario-goulart> Sim, é só uma característica.
[10:24] <pbalduino> que é o caso aqui. os sistemas web são coleções gigantes de cruds e exibição de tabelas de dados. nada além disso.
[10:24] <pbalduino> rails g scaffold foobar e tá pronto o crud
[10:25] <pbalduino> aliás, vou aproveitar pra compartilhas as ideias com vcs
[10:27] <pbalduino> a primeira é o ClojureDocs BR
[10:27] <pbalduino> http://www.clojuredocs.com.br/
[10:28] <mario-goulart> pbalduino: interessante.
[10:28] <pbalduino> os problemas:
[10:28] <pbalduino> está incompleto, bugado, e feito com rails
[10:28] <pbalduino> é o que deu pra fazer em duas tardes :)
[10:28] <mario-goulart> Por outro lado, sou meio cético com relação aos resultados de esforços de tradução na nossa área.
[10:29] <pbalduino> pq?
[10:30] <mario-goulart> Eu acho que dificilmente um programador vai ser ser competente (ou vai conseguir exercer sua plena competência) sem saber inglês.
[10:30] <pbalduino> mario-goulart: vi essa discussão sobre o Ruby Inside traduzido e sobre o Stack Overflow pt-BR e discordo
[10:31] <pbalduino> acho que o incompetente vai ser incompetente a menos que queira mudar, independente de idioma
[10:31] <pbalduino> e como um primeiro contato acho válido. é importante para nós que o Clojure se popularize, por mais que isso traga uma Orkutização natural
[10:32] <pbalduino> o cara esforçado vai se sentir limitado cedo ou tarde e vai buscar o material em ingles
[10:32] <mario-goulart> Entendo.
[10:32] <andrewhr> pbalduino: você leu algo sobre o grimoire?
[10:32] <pbalduino> como aconteceu comigo e com vcs
[10:32] <mario-goulart> Não acho que seja algo ruim, apenas questiono a relação custo/benefício.
[10:32] <pbalduino> andrewhr: vi o anúncio e dei uma olhada por alto
[10:33] <andreanastacio> conrcordo com o pbalduino. No inicio com ruby eu procurava material em portugues, depois de ler dois livros em portugues eu desisti :P
[10:33] <pbalduino> akita e urubatan (6)
[10:34] <pbalduino> mario-goulart: nesse início, o custo é altíssimo e os benefícios são questionáveis
[10:34] <pbalduino> o retorno é perto de zero
[10:34] <pbalduino> mas alguém tem que fazer a cama
[10:35] <pbalduino> e, principalmente, mostrar que LISP em geral, e Clojure em particular, não tem nada de complicado ou monstruoso
[10:35] <pbalduino> eu tenho uma apresentação chamada "LISP em cinco minutos"
[10:35] <mario-goulart> Mas será que a cama não deveria ser com outro colchão? :-)  Por exemplo, incentivar o aprendizado de inglês.
[10:35] <pbalduino> e dá tempo
[10:35] <pbalduino> mario-goulart: esse seria o mundo perfeito
[10:36] <pbalduino> mario-goulart: e seria o mundo onde eu gostaria de viver
[10:36] <andreanastacio> eu acho que a sintaxe assusta no inicio e agrada mais quem já tem um pouco mais de experiencia com desenvolvimento
[10:36] <pbalduino> mas se as pessoas quisessem mesmo se esforçar e evoluir, o PHP teria caído em desuso
[10:36] <pbalduino> as pessoas querem conforto
[10:36] <andreanastacio> o que faz com que reduza a quantidade de pessoas que só estão interessadas em entregar o produto rapido
[10:36] <pbalduino> querem comida na boca
[10:36] <andreanastacio> que é o que acontece com PHP/Ruby
[10:36] <pbalduino> eu não gosto nada disso, mas é como o mundo funciona
[10:37] <mario-goulart> Entendo.
[10:37] <pbalduino> eu posso tentar mudar o mundo, ou posso jogar com o que tenho para que ele comece a andar na direção que eu gostaria
[10:37] <pbalduino> vc não atravessa um rio nadando em linha reta
[10:37] <pbalduino> ou contra a correnteza
[10:38] <pbalduino> mario-goulart: eu concordo 110% com vc
[10:38] <pbalduino> mas infelizmente o mundo não é assim
[10:38] <andreanastacio> Ruby não tem tanto sobrinhos quanto PHP, pois n temos um wordpress da vida... mas tem muito Phpezeiro que está vindo pro ruby e quebrando um pouco a cara
[10:40] <pbalduino> Buda já dizia que tentar evitar o sofrimento só vai causar mais sofrimento. aceite que ele existe e viva melhor com isso.
[10:40] <pbalduino> PHP e os sobrinhos são um sofrimento
[10:40] <pbalduino> as pessoas acomodadas que não querem aprender ingles tambem
[10:40] <andrewhr> pbalduino: muitas decisões de design da própria linguagem e ecosistema partem justamente desse princípio
[10:41] <andrewhr> pois o mundo ideal clojure seria self-hosting… mas é muito mais prático construir em cima da JVM
[10:41] <pbalduino> crie um ambiente amigável para essas pessoas menos esforçadas, faça-as se sentir a vontade, e depois venda cursos pra elas :P
[10:41] <andrewhr> datomic é um DB que se hospeda em cima de outros DBs
[10:41] <andrewhr> o recém-lançado transit é um encoding em cima de outro encoding… etc
[10:41] <pbalduino> yup
[10:42] <pbalduino> clojurescript é outro
[10:42] <andrewhr> isso!
[10:42] <mario-goulart> pbalduino: acho que é uma estratégia interessante mas, via de regra, dificilmente funcionaria com Lisp. :-)
[10:42] <pbalduino> não funcionou nos ultimos 55 anos
[10:42] <pbalduino> e não acho que clojure vá mudar isso
[10:43] <pbalduino> mas podemos aproveitar a viagem
[10:43] <pbalduino> eu estou gostando muito de programar em clojure
[10:43] <pbalduino> até mais do que quando descobri o ruby
[10:43] <mario-goulart> Usuários de Lisp têm um perfil bem distinto.  Algumas coisas não funcionam com Lispers como funcionam com outros tipos de programadores.
[10:44] <pbalduino> verdade
[10:44] <andrewhr> fica a pergunta: alguém tinha contato REAL com Lisp antes de clojure? Por que isso particularmente explodiu minha cabeça quando comecei a estudar…
[10:45] <pbalduino> o konrad
[10:45] <mario-goulart> alguém daqui desse canal?
[10:45] <andrewhr> “como? Ruby é tão dinâmico e não chega perto disso!”
[10:45] <pbalduino> hehehe
[10:45] <pbalduino> eu comecei com scheme, mas nunca usei para nada importante
[10:45] <pbalduino> scheme/racket
[10:45] <pbalduino> mas só fui ter o click mesmo com o clojure
[10:46] <mario-goulart> Eu, na verdade, não uso clojure.  Estou aqui só porque clojure é Lisp e eu queria ter uma idéia do público brasileiro.  Além de curiosidade sobre a linguagem, claro.
[10:47] <pbalduino> manja reader macro?
[10:47] <pbalduino> #(* % %)
[10:47] <pbalduino> #( ) é reader macro para (fn [ ] )
[10:47] <mario-goulart> Em clojure?
[10:47] <pbalduino> sim
[10:47] <mario-goulart> Não sei praticamente nada sobre clojure. :-)
[10:47] <pbalduino> #{ } é reader macro para (set)
[10:47] <pbalduino> explicando por alto:
[10:47] <mario-goulart> ok
[10:48] <pbalduino> clojure tem três fases distintas:
[10:48] <mario-goulart> Sei o conceito de reader macro, mas não sei como é em clojure.
[10:48] <pbalduino> read time, compile time e runtime
[10:48] <pbalduino> quando vc usa o REPL, o R é read
[10:48] <pbalduino> "Leia"
[10:48] <pbalduino> E é EVAL, que contém compile time e run time
[10:48] <mario-goulart> Sim, essa parte eu sei.
[10:48] <pbalduino> e o P é final do runtime
[10:48] <pbalduino> funções são executada em runtime
[10:49] <pbalduino> macros são executadas em compile time
[10:49] <pbalduino> e reader macros são executadas em read time
[10:49] <pbalduino> ou seja
[10:49] <pbalduino> vc pode executar código enquanto o seu código está sendo lido e interpretado
[10:49] <pbalduino> vc pode executar código antes da compilação
[10:50] <pbalduino> bom, no common lisp vc pode criar seus próprios read macros
[10:50] <pbalduino> no clojure vc não pode
[10:50] <mario-goulart> !
[10:50] <pbalduino> o clojure core achou que não seria uma boa ideia dar essa arma na mão do usuário
[10:50] <pbalduino> o "problema" é que dev lisp não é um dev comum
[10:50] <pbalduino> e clojure é java, no final das contas
[10:51] == emerson_ [[email protected]] has joined #clj-br
[10:51] <pbalduino> vc abre o fonte do compilador, vê como os read macros são declarados e escreve em clojure invocando java o código para adicionar seus próprios read macros
[10:51] <pbalduino> a linguagem é tão flexível que vc consegue alterá-la a ponto de mexer no tempo de leitura e interpretação do código
[10:51] <pbalduino> emerson_: bom dia
[10:51] <pbalduino> por exemplo
[10:52] <pbalduino> existe uma coleção persistente para lidar com filas
[10:52] <emerson_> Bom dia!
[10:52] <pbalduino> PersistentQueue
[10:52] <pbalduino> só que não existe um reader macro pra ela nem nenhum literal que facilite o uso, como acontece com listas, mapas, arrays e sets
[10:52] <mario-goulart> Alô emerson_
[10:53] <mario-goulart> Segue o baile, pbalduino. :-)
[10:53] <pbalduino> aí vc pode escrever código que crie um literal para que vc crie filas sem ter que invocar clojure.lang.PersistentQueue diretamente
[10:53] <pbalduino> tipo
[10:53] <pbalduino> (def lista '(1 2 3))
[10:53] <pbalduino> (def vetor [1 2 3])
[10:53] <pbalduino> (def fila #<1 2 3<)
[10:53] <pbalduino> ou qualquer outra sintaxe que vcs acharem mais bonita
[10:54] <mario-goulart> Não entendi.  Clojure permite a definição de reader macros ou não?
[10:54] <mario-goulart> No início eu tinha entendido que não.  Agora parece que sim.
[10:55] <pbalduino> não permite
[10:55] <pbalduino> mas se vc usar os internals em Java do Clojure, vc consegue criar
[10:55] <mario-goulart> Ah, ok.
[10:55] <pbalduino> vc puxa as tripas do Clojure pra fora e faz o que bem entender
[10:55] <mario-goulart> Ok.  agora entendi.
[10:56] <pbalduino> *isso* sim é ser flexível
[10:56] <pbalduino> http://briancarper.net/blog/449/clojure-reader-macros
[10:57] <pbalduino> nesse texto carper cria um reader macro #U que converte em read time uma string pra maiuscula
[10:57] <pbalduino> já o common lisp te dá esse recurso como parte da linguagem, sem hacks
[10:58] <pbalduino> (mas eu não gosto de common lisp)
[10:59] <mario-goulart> Alguma razão especial?
[11:00] <pbalduino> pra não gostar de CL?
[11:00] <mario-goulart> É
[11:00] <pbalduino> pelo mesmo motivo de não gostar de python
[11:01] <pbalduino> acho python uma linguagem sensacional, recomendo fortemente que aprendam
[11:01] <pbalduino> mas o santo não bateu
[11:01] <pbalduino> não consigo te dar nenhum motivo técnico e sensato a respeito
[11:01] <mario-goulart> ok
[11:01] <pbalduino> e não gostei do que vi na "comunidade" CL
[11:02] <pbalduino> é tudo o que eu não encontrei no clojure
[11:02] <pbalduino> recem chegados não são bem aceitos por lá, não são bem tratados
[11:02] <pbalduino> só o fato de chamarem o Common Lisp apenas de "Lisp" já mostra a visão do mundo dos caras.
[11:02] <pbalduino> é meio como "somos o único e verdadeiro lisp. vcs todos são farsas."
[11:03] <pbalduino> o mimimi do "Clojure não é Lisp" parte deles
[11:05] <mario-goulart> Na verdade, acho que chamar CL de Lisp tem um pouco de inércia e outro pouco de ignorância.  Quem tem conhecimento tem a inércia, e quem não tem inércia normalmente não tem o conhecimento para dicernir Lisp de CL. :-)
[11:05] == emerson_ [[email protected]] has quit [Remote host closed the connection]
[11:05] <pbalduino> eu vejo isso nos EUA se chamando de "America"
[11:05] <mario-goulart> Afinal, CL surgiu de um consenso sobre o que "Lisp" deveria ser.
[11:05] <andrewhr> até hoje não entendi esse lance do “Clojure não é Lisp”. É por conta do lance híbrido com Java?
[11:05] <pbalduino> também
[11:06] <pbalduino> mas, na essência, é pq clojure não é common lisp
[11:06] <pbalduino> e clojure tem mais aceitação do que common lisp, justamente por causa da JVM
[11:06] <mario-goulart> andrewhr: não há argumento técnico que refute o fato de Clojure ser Lisp.
[11:06] <pbalduino> se o clojure fosse autocontido, seria só mais um lisp irrelevante
[11:06] <andrewhr> kudos para Rich
[11:06] <pbalduino> common lisp nasceu da mesma forma que o cobol: num comitê corporativo
[11:07] <pbalduino> não que isso desmereça a linguagem
[11:07] <pbalduino> mas é uma linguagem criada por um comitê de pessoas usando gravata
[11:08] <mario-goulart> É, mas os caras usando gravata naquele comitê sabem muito. :-)
[11:08] <pbalduino> a spec do common lisp é gigante
[11:08] <pbalduino> ah sim
[11:08] <pbalduino> só o guy steele tem um cérebro quad core
[11:08] <mario-goulart> O pessoal daquele comitê fazia hardware que rodava lisp nativamente. :-)
[11:09] <pbalduino> eu fico achando que, se um dia eu conhece-lo, não vou ter nem assunto pra conversar
[11:09] <mario-goulart> (dentre outras coisas)
[11:09] <pbalduino> e o comitê resolveu um problema que o scheme até hoje tem
[11:09] <pbalduino> vc não porta seu código scheme de um compilador pro outro
[11:09] <pbalduino> muito menos de uma plataforma pra outra
[11:09] <pbalduino> isso pra software "sério" é o inferno
[11:10] <pbalduino> e o CL gera código muito rápido, muito eficiente
[11:11] <mario-goulart> CL é impressionante em termos de desempenho, de fato.
[11:12] <pbalduino> é bem possível que se eu entrar a sério no CL, minha opinião mude radicalmente
[11:12] <pbalduino> mas opinião é pra mudar mesmo
[11:12] <mario-goulart> :-)
[11:15] <andreanastacio> só para entender melhor, pbalduino vc usa qual editor? você usa a estrutura de projeto do leiningen ou o padrão do java (maven/ant/etc)?
[11:16] <pbalduino> lein
[11:16] <pbalduino> lein all the way
[11:16] <andreanastacio> eu vejo uma "bagunça" com jruby. mas jruby virou mais uma alternativa de ruby rapido do que ecosistema
[11:17] <andreanastacio> como virou scala/clojure... ele n ficou independente... ele virou mais uma opção.
[11:17] <pbalduino> andreanastacio: uma implementação alternativa, vc diz?
[11:17] <andreanastacio> exato
[11:18] <pbalduino> verdade
[11:18] <andreanastacio> talvez para facilitar o port de codigo do MRI
[11:18] <pbalduino> ninguem diz que programa em Rhino ou DynJS
[11:18] <pbalduino> vc programa em JS numa engine Java
[11:18] <pbalduino> idem JRuby
[11:18] <pbalduino> brincando com Lein: https://github.com/pbalduino/lein-groovyc / https://github.com/pbalduino/groovy-test
[11:19] <andreanastacio> eu acho que seria mais divertido ser algo como clojure, n ser apenas syntax
[11:19] <andreanastacio> mas n vai acontecer
[11:20] <andreanastacio> preciso correr atras de um bot para gerar um log das conversas aqui
[11:21] <andreanastacio> acho que seria legal manter um historico
[11:21] <pbalduino> pensei a mesma coisa :)
[11:21] <pbalduino> de preferencia um que fique quieto, ao contrário do wyrd
[11:22] <andreanastacio> hehe, tem o bot do #clojure
[11:23] <andreanastacio> vou dar uma olhada nele depois
[11:23] <pbalduino> boa
[11:23] <andreanastacio> ia ser legal ter um bot escrito em clojure para n virar putaria hehe
[11:23] <pbalduino> aproveitando a ideia do andreanastacio
[11:24] <pbalduino> a minha segunda ideia é um portal Clojure Brasil, com forum, possiveis vagas de emprego, links interessantes e o log do IRC para consulta futura
[11:24] <pbalduino> já usei o log do #clojure algumas vezes como referencia
[11:24] <mario-goulart> Para saber se o sujeito é um troll? :-)
[11:24] <andreanastacio> perfeito pbalduino, se precisar de ajuda estamos ai :D
[11:25] <pbalduino> vou precisar de muita ajuda :)
[11:25] <andreanastacio> depois vc pode montar um organization no github para centralizar os repositorios
[11:27] <pbalduino> excelente
[11:27] <mario-goulart> andreanastacio: com relação a "mas jruby virou mais uma alternativa de ruby rápido": a implementação em Java de Ruby é mais rápida do que a implementação em C?
[11:27] <andreanastacio> eu vou fazer um fork do bot do #clojure e dar uma estudada e ai qualquer coisa eu subo nessa organization
[11:28] <andreanastacio> mario-goulart sim
[11:28] <mario-goulart> que maluquice
[11:28] <andreanastacio> bom o que mata no MRI é o multi-thread
[11:28] <mario-goulart> E totalmente compatível?
[11:29] <andreanastacio> acho que a maior barreira é escrever o codigo thread-safe
[11:29] <pbalduino> mario-goulart: não sei como está o CRuby/MRI atualmente, mas só o fato do JRuby não ter GIL já faz uma pta diferença
[11:29] <andreanastacio> n tenho experiencia para falar
[11:29] <pbalduino> a JVM tem umas otimizações bizarras
[11:29] <pbalduino> o GC da JVM está muitos anos a frente do GC do Ruby
[11:30] <pbalduino> e o Charles Nutter come invokedynamic com farinha. tanto que ele ajudou muito o DynJS nesse ponto.
[11:31] <pbalduino> mario-goulart: o código que vc escrever em puro Ruby é totalmente compatível
[11:31] <pbalduino> as gems é que pegam
[11:32] <pbalduino> tem muita gem escrita em C. aí tem que migrar pra java
[11:32] <mario-goulart> Interessante.
[11:41] <andrewhr> mas jruby não suporta ruby 2.1 completamente… acho que tem algum problema com kwargs ou ou outra coisa parecida. Não me recordo
[11:42] <andrewhr> no geral dá usar muito bem
[11:42] <mario-goulart> E o uso de memória? :-)
[11:45] <mario-goulart> Pergunto porque, até onde sei: 1. Java representa strings com UTF-16; 2. Símbolos não são (eram?) coletados em Ruby.  Se 1 e 2 forem verdadeiros, e se a implementação de símbolos de Ruby for feita usando strings de Java, programas em Ruby na JVM devem comer uma memória considerável.
[11:48] <pbalduino> taí uma excelente pergunta pra se fazer ao Nutter
[11:50] <pbalduino> quanto ao 2, um symbol no JRuby é um objeto RubySymbol
[11:50] <pbalduino> que recebe o nome como String no momento da criação
[11:50] <pbalduino> =\
[11:55] <pbalduino> acho que isso responde: https://github.com/jruby/jruby/blob/master/core/src/main/java/org/jruby/RubySymbol.java#L87-L108
[11:56] <mario-goulart> Então o consumo de memória deve ser meio violento, pelo que entendi.
[11:57] <pbalduino> é, parece ser mesmo
[12:48] <pbalduino> https://gist.github.com/pbalduino/4674b4391687b3cd3917
[13:12] <formiga> e ae pessoal
[13:12] <formiga> blza
[13:12] <formiga> gostaria de saber oque seria esse clojure
[13:12] <formiga> Alguem pode me explicar?
[13:13] <andreanastacio> formiga você tem alguma duvida um pouco mais especifica?
[13:14] <formiga> Não
[13:14] <formiga> kk
[13:14] <formiga> So vi este canal agora e gostaria de saber oque é clojure
[13:14] <andreanastacio> ah ta, vc entrou aleatoriamente
[13:14] <formiga> isto isto
[13:15] <andreanastacio> bom, basicamente clojure é uma linguagem de programação
[13:15] <formiga> estava procurando canais brasileiros e achei este ai
[13:15] <formiga> imaginei
[13:15] <andreanastacio> no freenode é o que vc vai encontrar
[13:16] <formiga> Vou participar bastante aqui entao se permitirem pois estou começando na programação agora
[13:16] <andreanastacio> basicamente é projetos open source e linguagens
[13:16] <formiga> aa ok
[13:16] <formiga> Ontem chegou meu primeiro livro de logica de programação
[13:16] <formiga> Algoritmos e Logica de programação
[13:16] <formiga> Ei obr por enquanto tenho q ir
[13:17] <formiga> Trabalhar
[13:17] <formiga> ate mais
[13:17] <formiga> ;)
[13:17] <andreanastacio> até :D
[13:23] <pbalduino> whoa, that was fast
[13:24] <andreanastacio> hehe
[13:25] <andreanastacio> eu n sabia o que responder, tive que perguntar se ele entrou aleatoriamente
[13:26] <pbalduino> andreanastacio: relaxa, vc mandou bem
[13:26] <pbalduino> não daria tempo de explicar o clássico "pq clojure"
[13:27] <andreanastacio> sim, ainda mais pq ele nem começou a programar
[13:28] <pbalduino> eu ia fazer uma pergunta bem idiota. se irc não tem como mandar imagem.
[13:28] <pbalduino> ¬¬
[13:30] <pbalduino> em primeira mão: https://dl.dropboxusercontent.com/u/20066030/preview.png
[13:46] <andreanastacio> wow
[13:46] <andreanastacio> não vejo a hora :D só tive experiencia ruim com os livros que eu comprei da casa do codigo
[13:47] <andreanastacio> talvez esse me satisfaça :P
[13:53] <andrewhr> “O REPL é tão importante…” -> gostei do capítulo. Muito bom :)
[13:59] <mario-goulart> pbalduino: estás escrevendo esse livro?
[13:59] <pbalduino> sim
[14:00] <mario-goulart> Jóia!