[quote=fredferrao]
1 - É sobre hot code swapping que estas falando?[/quote]
Estou falando de alterações no código surtirem efeito sem precisar reiniciar a aplicação. Chame isso do que quiser.
[quote=fredferrao]
2 - Clojure consegue fazer isto DENTRO da JVM? Pois a pergunta do post é sobre linguagem para a JVM.[/quote]
Atualmente clojure so roda na jvm, apesar que existe um projeto em andamento para portar para CLR.
[quote=mochuara][quote=fredferrao]
1 - É sobre hot code swapping que estas falando?[/quote]
Estou falando de alterações no código surtirem efeito sem precisar reiniciar a aplicação. Chame isso do que quiser.
[quote=fredferrao]
2 - Clojure consegue fazer isto DENTRO da JVM? Pois a pergunta do post é sobre linguagem para a JVM.[/quote]
Atualmente clojure so roda na jvm, apesar que existe um projeto em andamento para portar para CLR.[/quote]
Então é possivel isto com Clojure? Bacana, e como chamam esta feature? Tem nome?
Confesso que exagerei ao puxar sardinha para linguagens dinamicas em geral, como ultimamente programa apenas em clojure minha tendencia é acreditar que toda linguagem dinamica poderia oferecer esse tipo de coisa. Mas creio que seja mérito da linguagem clojure mesmo. Ruby por exemplo apesar de dinamica, não sei se da pra fazer isso normalmente, ou seja, sem qualquer tipo de magia negra ou outros subterfugios inconvenientes, como hacks na propria linguagem. Alguem com mais experiencia em Ruby poderia se manifestar?
Mas o fato é que, o simples fato da linguagem ser dinamica e nao haver etapas de compilação obrigatorio, já é suficiente para reduzir o down-time da aplicação e isso é muito importante em aplicações web.
[quote=fredferrao]
Então é possivel isto com Clojure? Bacana, e como chamam esta feature? Tem nome?[/quote]
Veja o link que passei anteriormente. Se não me engano é a primeira feature disponivel no menu a esquerda.
Sobre o Hot Swap…
A JVM realmente não suporta o Hot Swap, caso você altere assinaturas de métodos, ou altere os membros de uma classe por exemplo. MAS as linguagens dinâmicas que rodam na JVM costumam suportar isso. Como?
As linguagens dinâmicas não traduzem a classe em bytecode igual Java traduz… Ao invés disso, são criados mapas com os atributos e métodos, os atributos e métodos então podem ser adicionados e removidos desse mapa dinamicamente. Mas o código não está por exmeplo em um método separado igual é na linguagem Java. Por isso, uma linguagem dinâmica, teria que ter performance inferior a uma linguagem Java… Imagine que Java é nativo para a JVM e uma linguagem dinamica tem que ser interpretada…
em java vc tem em bytecode:
class MyClass {
public void meuMetodo(){
....
}
}eu uma linguagem dinamica, o mesmo código poderia virar em bytecode:
class MyClass {
public Object executeMethod(String name, Object[] params){
if(name.equals("meuMetodo"){
....
}
}
}Nao é exatamente assim… mas dá pra entender aqui… como funcionaria o hotswap…
Dá pra fazer alguma coisa nesse sentido também… usando um class loader turbinado…
Existe um class loader chamado jRebel… que permite que seja usado o hotswap…
[quote=mochuara][quote=fredferrao]
Então é possivel isto com Clojure? Bacana, e como chamam esta feature? Tem nome?[/quote]
Veja o link que passei anteriormente. Se não me engano é a primeira feature disponivel no menu a esquerda.[/quote]
É eu acabei achando isto aqui http://travis-whitton.blogspot.com/2009/09/hot-code-swapping-with-clojure.html, um cara mostrando como fazer.
Voce quer pintar todas as linguagens pra JVM no mesmo quadro e acaba falando abobrinha. Linguagens dinamicas como clojure são compiladas, e quando isso acontece vira bytecode e já era, não ha qualquer diferenca entre código nativo e codigo dinamico.
[quote=mochuara][quote=juliocbq][quote=fredferrao][quote=juliocbq]nenhuma delas na minha opinião. Sobre performance, todas teriam a mesma, pois quem dita isso é a jvm.
Eu preferiria que a jvm suportasse c#. Acho uma linguagem muito boa. É só uma questão de opinião pessoal . [/quote]
Na verdade nao!! depende do compilador que fizerem. Por exemplo é fato que o JRuby é lento, e que o do Scala roda praticamente igual java na JVM![/quote]
JRuby é mais lento porque carrega mais dependencias na inicialização. Isso é perfeitamente visível usando um debugger. Depois que o hotspot compilou para código nativo, ele roda na mesma velocidade que java, ou qualquer outro código na jvm, porque são praticamente o mesmo código. Quem dita isso é o hotspot.[/quote]
Ou seja, nem todas as linguagens na JVM tem a mesma performance, depende de como ela foi projetada. Se ela faz uso constante de reflection por exemplo, claro que sera mais lenta. Não fale besteira.[/quote]
Besteira onde?. Java usa reflection e não é lenta. O problema do jruby e do jpython se referem a inicialização e nada mais. Faça um benchmark e use uma ferramenta chamada depurador.
Não existe diferença de velocidade entre bytecodes(são a mesma coisa).
Cada uma…
[quote=mochuara]
Voce quer pintar todas as linguagens pra JVM no mesmo quadro e acaba falando abobrinha. Linguagens dinamicas como clojure são compiladas, e quando isso acontece vira bytecode e já era, não ha qualquer diferenca entre código nativo e codigo dinamico.[/quote]
Você mesmo disse. Não há diferença mesmo. Passou no hotspot é tudo farinha do mesmo saco.
Em ambiente de desenvolvimento, isso é possível, mas não sei se pode-se chamar isso de hot swapping, no mesmo sentido que usam para erlang. Em producao, no caso do passenger/mod_rails que é uma das alternativas mais usadas, são criadas várias instâncias da aplica’cão e guardadas em um pool (as AST’s de todo o código são geradas e reusadas para todos os requests). Se vc quiser atualizar essas instancias pré-carregadas vc precisa reiniciar o servidor, mas o processo é muito simples (no nginx basta um touch tmp/restart.txt).
[quote]
Voce quer pintar todas as linguagens pra JVM no mesmo quadro e acaba falando abobrinha. Linguagens dinamicas como clojure são compiladas, e quando isso acontece vira bytecode e já era, não ha qualquer diferenca entre código nativo e codigo dinamico.[/quote]
O Rogel estava certo quando disse que “As linguagens dinâmicas não traduzem a classe em bytecode igual Java traduz…”, já que existe diferenca entre bytecodes gerados por linguagens diferentes.
Deem uma olhada nessa apresentacao: http://www.infoq.com/presentations/click-fast-bytecodes-funny-languages
[quote]A JVM realmente não suporta o Hot Swap, caso você altere assinaturas de métodos, ou altere os membros de uma classe por exemplo. MAS as linguagens dinâmicas que rodam na JVM costumam suportar isso. Como?
As linguagens dinâmicas não traduzem a classe em bytecode igual Java traduz… Ao invés disso, são criados mapas com os atributos e métodos, os atributos e métodos então podem ser adicionados e removidos desse mapa dinamicamente. Mas o código não está por exmeplo em um método separado igual é na linguagem Java. Por isso, uma linguagem dinâmica, teria que ter performance inferior a uma linguagem Java… Imagine que Java é nativo para a JVM e uma linguagem dinamica tem que ser interpretada… [/quote]
Por que vc insiste no exemplo de trocar de métodos em tempo de execucão? Se for disso que vc está falando, isso não tem nada a ver com hotswap, pois vc pode inserir/remover/alterar métodos de uma classe em tempo de execucao em algum programa Ruby, sem precisar mudar o codigo que está carregado na VM. Ainda, se for isso disso mesmo que vc está falando, a insercão dos métodos não acontece do jeito que vc disse, usando mapas com atributos e métodos.
No caso do JRuby, quando um método é adicionado uma nova classe é criada e carregada. Tem muito tempo que eu li esse artigo (http://www.realjenius.com/2009/10/06/distilling-jruby-the-jit-compiler/) e posso ter falado algo errado, mas acho que resumidamente é isso mesmo.
[quote=mochuara][quote=rogelgarcia]
As linguagens dinâmicas não traduzem a classe em bytecode igual Java traduz… Ao invés disso, são criados mapas com os atributos e métodos, os atributos e métodos então podem ser adicionados e removidos desse mapa dinamicamente. Mas o código não está por exmeplo em um método separado igual é na linguagem Java. Por isso, uma linguagem dinâmica, teria que ter performance inferior a uma linguagem Java… Imagine que Java é nativo para a JVM e uma linguagem dinamica tem que ser interpretada…
[/quote]
Voce quer pintar todas as linguagens pra JVM no mesmo quadro e acaba falando abobrinha. Linguagens dinamicas como clojure são compiladas, e quando isso acontece vira bytecode e já era, não ha qualquer diferenca entre código nativo e codigo dinamico.[/quote]
Bicho… vc é dificil demais… e depois fala que os outros é que nao sabem interpretar textos…
[quote=dlt]
Por que vc insiste no exemplo de trocar de métodos em tempo de execucão? Se for disso que vc está falando, isso não tem nada a ver com hotswap, pois vc pode inserir/remover/alterar métodos de uma classe em tempo de execucao em algum programa Ruby, sem precisar mudar o codigo que está carregado na VM. Ainda, se for isso disso mesmo que vc está falando, a insercão dos métodos não acontece do jeito que vc disse, usando mapas com atributos e métodos.
No caso do JRuby, quando um método é adicionado uma nova classe é criada e carregada. Tem muito tempo que eu li esse artigo (http://www.realjenius.com/2009/10/06/distilling-jruby-the-jit-compiler/) e posso ter falado algo errado, mas acho que resumidamente é isso mesmo. [/quote]
Mas o Ruby não roda na JVM…
O hotswap sobre inserir remover alterar métodos de uma classe não funcionam em Java… e funcionam em algumas linguagens dinamicas… por isso coloquei como exemplo…
O negócio de mapas com atributos e métodos… uma vez li sobre uma linguagem que faz assim… infelizmente não lembro qual aqui… mas isso poderia ser uma forma de fazer…
O texto que vc citou é sobre o JRuby… esse sim roda na JVM… mas cada linguagem pode ter uma estratégia de fazer o HotSwap…
Nesse mesmo texto que vc citou… tem lá
Acho que vc não tá muito “aware” sobre isso… heheheh
[quote=juliocbq][quote=mochuara]
Voce quer pintar todas as linguagens pra JVM no mesmo quadro e acaba falando abobrinha. Linguagens dinamicas como clojure são compiladas, e quando isso acontece vira bytecode e já era, não ha qualquer diferenca entre código nativo e codigo dinamico.[/quote]
Você mesmo disse. Não há diferença mesmo. Passou no hotspot é tudo farinha do mesmo saco. [/quote]
Se for compilado para o mesmo código em bytecode não faz diferença. Mas vc não disse isso, vc falou que todas as linguagens tem a mesma performance. Mas isso não pode ser dito por que cada linguagem é implementada de uma maneira.
E o fato da linguagem ser dinamica significa que não se sabe quando o código vai ser compilado. Isso faz parte do projeto da linguagem. Pode ser em tempo de execução, pode ser antes se houver type hints, pode ser nunca, que seria o pior em termos de performance.
Design influencia performance até mesmo em aplicações feitas em puro Java. Porque seria diferente com linguagens?
[quote]Mas o Ruby não roda na JVM…
Eu sei que vc não é obrigado a saber que o JRuby existe desde 2001, mas poderia pelo menos ter clicado no link que eu postei antes de responder. 
O hotswap sobre inserir remover alterar métodos de uma classe não funcionam em Java… e funcionam em algumas linguagens dinamicas… por isso coloquei como exemplo…
O negócio de mapas com atributos e métodos… uma vez li sobre uma linguagem que faz assim… infelizmente não lembro qual aqui… mas isso poderia ser uma forma de fazer…
O texto que vc citou é sobre o JRuby… esse sim roda na JVM… mas cada linguagem pode ter uma estratégia de fazer o HotSwap…
Nesse mesmo texto que vc citou… tem lá
Java, as you may or may not be aware, prevents the modification of any loaded classes in the VM
Acho que vc não tá muito “aware” sobre isso… heheheh [/quote]
Uai, uma hora vc fala que não roda na JVM e algumas linhas abaixo fala que roda.
Estamos falando de linguagens na JVM, certo? Ruby é uma delas, não é? Eu estava ‘aware’ que java não deixa modificar classes na carregadas na JVM, foi por isso que eu disse o lance do JRuby criar as classes novas toda vez que um método é adicionado.
Editei para corrigir uma trollagem desnecessária. O guj me deixa assim. 
[quote=mochuara][quote=juliocbq][quote=mochuara]
Voce quer pintar todas as linguagens pra JVM no mesmo quadro e acaba falando abobrinha. Linguagens dinamicas como clojure são compiladas, e quando isso acontece vira bytecode e já era, não ha qualquer diferenca entre código nativo e codigo dinamico.[/quote]
Você mesmo disse. Não há diferença mesmo. Passou no hotspot é tudo farinha do mesmo saco. [/quote]
Se for compilado para o mesmo código em bytecode não faz diferença. Mas vc não disse isso, vc falou que todas as linguagens tem a mesma performance. Mas isso não pode ser dito por que cada linguagem é implementada de uma maneira.
E o fato da linguagem ser dinamica significa que não se sabe quando o código vai ser compilado. Isso faz parte do projeto da linguagem. Pode ser em tempo de execução, pode ser antes se houver type hints, pode ser nunca, que seria o pior em termos de performance.
Design influencia performance até mesmo em aplicações feitas em puro Java. Porque seria diferente com linguagens?[/quote]
O design influencia na performance no quesito de haver mais código gerado pelo programador, e que é compilado. A linguagem não tem nada haver com isso.
As instruções geradas pelo compilador de python e do de java são exatamente iguais para o hotspot.
O único problema de performance entre as linguagens é do programador, como citado anteriormente. Agora, isso vale se o compilador python ou ruby seguem o mesmo desenho do java. Não estou falando de lexico ou semantico, mas o linkador, que vai gerar bytecode.
Se ele é diferente não haveria nem porque implementar essas linguagens na jvm.
Eu sei que vc não é obrigado a saber que o JRuby existe desde 2001, mas poderia pelo menos ter clicado no link que eu postei antes de responder. [/quote]
Já que vc editou a trollagem… editei tb… 
Eu falei que a JVM não suporta o code swap… Então vc tem que usar algumas técnicas… para simular o hotswap…
Tudo certo então… estamos falando a mesma coisa… eheh
Da mesma forma que uma aplicação A feita por João não vai gerar os mesmo bytecodes que uma aplicação B feita por José.
Mas isso não tem nada a ver com o fato da linguagem ser dinamica ou estatica.
Rogel, le o texto inteiro pra vc entender do que estou falando.
O que eu disse que não tem a ver é a questão do hot-swapping, que realmente não tem nada a ver com trocar métodos em tempo de execucao. Tem a ver com carregar código novo na VM, atualizar uma aplicacao sem reiniciar o servidor, etc…
[quote=mochuara][quote=dlt]
O Rogel estava certo quando disse que “As linguagens dinâmicas não traduzem a classe em bytecode igual Java traduz…”, já que existe diferenca entre bytecodes gerados por linguagens diferentes.
Deem uma olhada nessa apresentacao: http://www.infoq.com/presentations/click-fast-bytecodes-funny-languages
[/quote]
Da mesma forma que uma aplicação A feita por João não vai gerar os mesmo bytecodes que uma aplicação B feita por José.
Mas isso não tem nada a ver com o fato da linguagem ser dinamica ou estatica.[/quote]
Tem a ver com o fato de uma linguagem ser diferente da outra… logo… o compilador de uma … pode gerar código melhor do que o compilador da outra