Revisão do Haxe: Recursos e pontos fortes do Haxe 4

Nossa análise anterior do Haxe terminou com uma olhada no próximo Haxe 4. Com o lançamento oficial do Haxe 4 (e logo depois, dois lançamentos de correções de bugs - versão 4.0.1 e 4.0.2), é hora de uma nova análise do Haxe . Quais são as últimas adições a essa linguagem de programação em expansão? Para onde está indo a comunidade de linguagem de programação Haxe? Os motores de jogo Haxe ainda são seu pilar?

Revisão do Haxe: Novos recursos do Haxe 4

Com mais de três anos de desenvolvimento desde o último grande lançamento, a versão 4 da linguagem de programação Haxe melhora o desempenho de macros, a experiência do desenvolvedor e a sintaxe. Três de seus aprimoramentos ainda são considerados experimentais, mas merecem destaque: o novo destino de bytecode da JVM, suporte para marcação em linha e verificações de segurança nula.

O Destino Experimental de Compilação de Bytecode da JVM no Haxe 4

O novo destino de bytecode JVM do Haxe 4 torna o desenvolvimento Java via Haxe um pouco mais eficiente, eliminando uma etapa importante de compilação: Não há uma segunda etapa de ter o próprio compilador Java ( javac ) compilando a saída do código-fonte Java do transpilador do Haxe.

Esse método de compilação com o Haxe 4 também remove totalmente a dependência do Java developer kit (JDK) e abre as portas para a depuração interativa a ser implementada no futuro.

Até que a versão principal do hxjava seja compatível com o Haxe 4, a configuração básica envolve a instalação do Haxe e do Haxelib e, em seguida, a execução haxelib install hxjava 4.0.0-alpha . Feito isso, o fluxo de desenvolvimento é simples:

 # transpile directly to JVM bytecode with Haxe (-D jvm would also work): haxe --main HelloWorld --java jar_output --define jvm # run JVM bytecode with Java: java -jar jar_output/HelloWorld.jar

Dado que a compilação direta da JVM ainda tem status experimental no Haxe 4, ela vem com algumas ressalvas:

• Existem alguns problemas específicos do Android.
• O desempenho do tempo de execução não é tão bom, mesmo que eventualmente seja mais rápido que o método indireto.

No entanto, é um passo notável na direção certa para qualquer um que utilize tecnologias baseadas em Java.

Suporte de marcação em linha experimental no Haxe 4

JSX, alguém? O Haxe 4 habilita a marcação em linha, permitindo que os desenvolvedores escrevam, por exemplo, HTML diretamente no código-fonte do Haxe:

 var dom = jsx( <div> <h1>Hello!</h1> <p>This is a paragraph.</p> </div> );

Como jsx() aqui pode ser uma função de macro estática, isso permite que um projeto tenha verificações em tempo de compilação se a marcação está em conformidade com qualquer especificação XML que o desenvolvedor queira implementar. Como o próprio suporte a XML está embutido na API Haxe, a verificação pode alavancar Xml.parse() , mas para a capacidade de análise “XML-ish” básica, nem isso é necessário:

 static macro function jsx(expr) { return switch expr.expr { case EMeta({name: ":markup"}, {expr: EConst(CString(s))}): macro $v{"XML MARKUP: " + s}; case _: throw new haxe.macro.Expr.Error("not an xml literal", expr.pos); } }

A intenção com esse recurso é ajudar a empurrar Haxe para fora da bolha de desenvolvimento de jogos (embora certamente tenha usos lá também). É geral o suficiente para ser implementado no nível do compilador - portanto, não precisa da API Haxe na macro acima - mas a verificação de DSLs específicas é a próxima questão para a equipe do compilador e a comunidade descobrirem.

Segurança nula experimental em Haxe 4

Desde a invenção da referência nula em 1965, a questão da segurança nula tem sido frequentemente a ruína dos desenvolvedores em ambientes de tipo nulo como o da linguagem de programação Haxe. Aleksandr Kuzmenko estima que o GitHub corrige erros de referência de ponteiro nulo acima de 10 milhões.

O Haxe 4 possui macros de segurança nulas em tempo de compilação, que podem ser habilitadas incluindo uma linha @:nullSafety logo antes de uma determinada definição. Ele vem nos @:nullSafety(Loose) (o padrão) e @:nullSafety(Strict) e pode ser desabilitado conforme necessário com @:nullSafety(Off) . O modo Strict examinará as chamadas de função em busca de mutações de campo que possam atribuir nulo, mesmo em um contexto nulo de segurança desabilitada.

Desenvolvedores Ruby podem se perguntar se o prático operador de navegação segura ( ?. em Ruby) está no radar. Ainda não, mas como em muitos aspectos da programação no Haxe, existe uma macro para isso (observe que ela usa !. em vez disso).

Experiência do desenvolvedor (DX) com Haxe 4: adições de sintaxe, açúcar sintático e muito mais

As adições relacionadas ao DX à linguagem de programação Haxe e ao suporte ao Haxe IDE trazem a experiência do Haxe 4 pelo menos ao nível de outras linguagens de programação em várias frentes. De certa forma, o Haxe procura ser tudo para todos, mas a equipe do compilador adota uma abordagem cuidadosa para integrar os recursos e convenções mais úteis de outras linguagens.

O resultado é que a linguagem de programação Haxe e a API padrão evoluem sem comprometer sua estabilidade, sensibilidade e coesão. Nem tudo nesta revisão do Haxe parecerá digno de hype, e esse é precisamente o ponto: o DX está melhorando, e isso é a favor de simplesmente perseguir “features du jour ” chamativos.

No entanto, há um equilíbrio a ser obtido: as mudanças do Haxe são feitas com a consciência dos padrões que outras linguagens estão seguindo, e o Haxe 4 certamente faz um esforço para atrair os recém-chegados de linguagens mais populares.

Nova Sintaxe “Tipo de Função”

Nessa nota, Haxe agora suporta duas formas principais de representar tipos de função. A sintaxe antiga “sugere que auto-currying e aplicação parcial são suportados, mas não são”, de acordo com a proposta de recurso original:

 Int -> String -> Void

A nova sintaxe permite argumentos nomeados, o que melhora o DX:

 (id:Int, name:String) -> Void

Mas deixando de lado o DX, usar a nova sintaxe do Haxe 4 para tipos de função é um bom hábito, pois a antiga sintaxe inferior pode ser removida em uma futura versão principal.

Açúcar sintático... mais ou menos

Talvez não seja inovador, mas as melhorias sintáticas do Haxe 4 serão boas notícias tanto para os desenvolvedores Haxe existentes com certos antecedentes de desenvolvimento (ES6, por exemplo) quanto para aqueles que podem estar vindo deles para o Haxe pela primeira vez.

A sintaxe da função de seta (“short lambda”) agora é suportada, que no caso de Haxe é mais ou menos apenas um atalho para digitar function e return . As sintaxes de iteração de valor-chave e valor de índice (para mapas e matrizes, respectivamente) agora também são suportadas. Declarações de tipo usando extensões estáticas podem usar apenas uma instrução using globalmente em vez de precisar delas em todos os lugares em que os métodos de extensão estática correspondentes são usados.

Enums e enum abstracts têm algumas outras melhorias, uma das quais é que o último passou da competência de macros para ter suporte direto ao compilador. Outros recursos movidos de forma semelhante incluem classes finais, interfaces finais e campos externos.

Alguns recursos que dependem de macros permaneceram dependentes de macros, mas melhoraram mesmo assim. A sobrecarga do operador foi nivelada para incluir os configuradores de campo e os metadados agora podem ser espaçados com . separadores como em @:prefix.subprefix.name .

Chamar as mudanças acima de açúcar sintático é reconhecidamente simplista demais, mas os leitores são bem-vindos para se aprofundar nas propostas originais vinculadas às notas de lançamento do Haxe 4, onde precisam de mais detalhes.

Mais reforços Haxe 4 DX

Embora a depuração interativa já fosse possível no Haxe para vários destinos compilados, o novo destino eval torna possível a depuração interativa para código interpretado. Para um exemplo simples, você pode pegar qualquer diretório de projeto do tutorial Haxe “Hello, World” e adicionar um arquivo chamado whatever-you-want.hxml parecido com isto:

 --main HelloWorld --interp

…e obtenha depuração interativa no VSCode IDE simplesmente por:

1. Abrindo o diretório do projeto no VSCode;
2. Adicionando um ponto de interrupção em algum lugar; e
3. Pressionar F5 e escolher “Haxe Interpreter” no menu suspenso.

Esse recurso também permite depurar o código de macro interativamente da mesma maneira, mesmo se você estiver compilando para um destino específico como java (em vez de usar --interp ). O único requisito de instalação além do próprio Haxe e VSCode é a extensão Haxe VSCode.

Serviços de IDE

Falando em IDEs, o Haxe 4 apresenta um novo protocolo de serviços IDE, que já está aproveitado na mais recente extensão do VSCode Haxe, vshaxe. Além de um aumento significativo de desempenho, isso permite que o vshaxe forneça algumas melhorias DX extremamente úteis, incluindo:

• Importações automáticas (muito aguardadas)
• Dicas de preenchimento automático mostrando mais detalhes, como responder à pergunta "De onde é este campo?"
• Autocompletar muito completo de várias maneiras novas, como conclusão de tipo esperado, conclusão de postfix e conclusão de substituição
• Otimizações simples ao digitar o código

É muito mais fácil ver o valor disso através das excelentes demonstrações visuais do changelog relevante do vshaxe. vshaxe com VSCode não é o único Haxe IDE disponível—HaxeDevelop e Kode Studio são específicos para Haxe, e existem plugins Haxe IDE para IntelliJ IDEA, Sublime Text, Atom, etc.—mas parece estar à frente do pacote em termos de fazer uso do novo protocolo de serviços IDE do Haxe 4, seguido de perto pelo IntelliJ-Haxe.

Literais Unicode

Os desenvolvedores que desejam usar literais de string Unicode reais encontrarão suporte para isso no Haxe 4, mas há algumas nuances a serem observadas.

Matrizes somente leitura

A API padrão do Haxe agora possui arrays somente leitura. Eles são tão fáceis de usar quanto declarar uma variável do tipo, por exemplo, haxe.ds.ReadOnlyArray<Int> , após o qual tentar definir, enviar ou remover valores resulta em vários erros do compilador. Adicione a palavra-chave final à declaração e reatribuir a própria matriz também não será permitida.

Inlining do site de chamada

Inlining de site de chamada é um novo recurso da linguagem Haxe que permite aos desenvolvedores controle refinado sobre onde as funções são inline, útil ao otimizar funções chamadas com frequência, onde a relação tamanho-desempenho geral poderia ser uma decisão de perder ou perder.

Estas são adições valiosas à já excelente linguagem de programação Haxe. O que os desenvolvedores da comunidade Haxe estão construindo agora que o Haxe 4 foi lançado?

Além dos motores de jogo Haxe: Desenvolvimento Web com Haxe 4

A base de usuários da Haxe tem sido historicamente dominada por programadores de jogos. Mas há muitos exemplos de uso do Haxe – em escala – em outros segmentos, como pilhas de negócios, aplicativos móveis e web, tanto para desenvolvimento de front-end quanto de back-end.

Para esse fim, o Haxe 4 fornece externos HTML regenerados, o que significa que a API padrão js.html do Haxe foi atualizada com a API da Web mais ampla conforme o MDN a define, além de corrigir bugs e adicionar APIs ausentes. (Por exemplo, o Haxe 4 agora inclui a API Push.)

Na palestra de Juraj Kirchheim, Weaving a Better Web with Haxe, ele aponta exemplos de soluções Web baseadas em Haxe sendo muito mais eficientes—mas também mais robustas—em um ambiente corporativo.

Ele também argumenta contra a abordagem arquitetural do Rails (em termos de hierarquia de pastas), mas os desenvolvedores que preferem um framework web completo como o Rails ainda podem encontrar um. Outras vezes, pode ser benéfico para os desenvolvedores revisar o código-fonte de um projeto web completo, nesse caso vale a pena dar uma olhada no repositório público do Giffon, uma plataforma de crowd-gifting que suporta o Haxe 4. Da mesma forma, centrado na web, aberto bibliotecas Haxe de origem, como o Haxe Modular de divisão de JavaScript, o genérico thx.core e suas bibliotecas irmãs, e o venerável kit de ferramentas da Web Haxe Tinkerbell já suportam o Haxe 4. O mesmo acontece com a solução de interface do usuário multiplataforma HaxeUI, que suporta um contexto da web, mas visa um escopo muito mais amplo, incluindo desenvolvimento de aplicativos de negócios e desktop; ele, em particular, continuou a amadurecer até o lançamento do novo idioma Haxe.

Web, jogos, empresas... independentemente da plataforma e do tipo de aplicativo que uma equipe de desenvolvimento - mesmo uma equipe de um - está visando, os desenvolvedores do Haxe eventualmente terão que lidar com o gerenciamento de dependências. Para isso, um recurso útil para os desenvolvedores do Haxe revisarem são os slides da palestra de Adam Breece, Escalando bem com outros.

Haxe como a melhor linguagem de programação para jogos

Existe uma única linguagem “melhor” para o desenvolvimento de jogos? É uma questão subjetiva e fácil de encontrar debates acalorados. Maior do que se poderia esperar apenas pelo tamanho de sua comunidade, o sucesso de Haxe na esfera de desenvolvimento de jogos certamente não é coincidência. Joe Williamson fornece algumas dicas sobre por que isso pode acontecer em uma entrevista sobre a vitória no jogo Ludum Dare 45 em 2019, e isso parece provável que continue com Haxe 4.

O criador original de Haxe, Nicolas Cannasse, já está usando Haxe 4 em produção com Northgard da Shiro Games. A Motion Twin também está usando o Haxe 4 na produção de Dead Cells. Ambos os jogos têm dezenas de milhares de críticas positivas no Steam e estão disponíveis para PCs (Win, Mac e Linux) e consoles - um resultado verdadeiramente formidável, considerando que ambos os jogos têm equipes de desenvolvimento menores, mas bases de usuários na casa dos milhões. Dead Cells ainda tem uma versão iOS, com uma versão Android em seu radar também.

Em termos de biblioteca, vários dos principais mecanismos de jogo do Haxe estão definitivamente acompanhando as mudanças do Haxe 4. Os mecanismos compatíveis com Haxe 4 incluem Kha (e uma parte dos muitos mecanismos construídos em cima dele - por exemplo, Armory), HaxeFlixel e sua principal dependência OpenFL, NME e Heaps - naturalmente, já que é isso que Northgard e Dead Cells usam. O HaxePunk também está trabalhando na compatibilidade do Haxe 4; em um caso, uma biblioteca, Nape, foi bifurcada para trabalhar com o Haxe 4.

Alguns desenvolvedores também fazem seus próprios motores em vez de usar um dos muitos já existentes. Por exemplo, Kirill Poletaev, que detalha como e por que ele escreveu seu próprio mecanismo de jogo 3D Haxe. Como esse mecanismo é interno, faz sentido que seja um exemplo de projeto que ainda não migrou para o Haxe 4.

Haxe 4: Continuando a progressão suave de uma excelente cadeia de ferramentas

Com o Haxe tendo uma utilidade tão ampla, os recursos mais importantes do Haxe 4 variam de acordo com o desenvolvedor, portanto, esta revisão do Haxe não é de forma alguma exaustiva. Algumas das mudanças do Haxe 4 estão faltando acima, incluindo:

• A adição da saída ES6 para o destino JavaScript
• A remoção de recursos (alguns dos quais ainda estão disponíveis através da biblioteca hx3compat ) e alvos (PHP5 e em breve AS3)
• Os sinalizadores da CLI estão sendo mais consistentes com as ferramentas comuns ( -lib - usando arquivos .hxml precisarão ser alterados para -L ou --library , por exemplo).
• Além de final agora ser uma palavra-chave (que, portanto, não pode ser usada como nome de variável), operator e overload também são palavras-chave recém-reservadas.

Houve também algumas mudanças importantes, mas são tão poucas que muitas bibliotecas mantidas ativamente nem se dão ao trabalho de anunciar explicitamente a compatibilidade do Haxe 4 - em geral, diz-se que a migração do Haxe 3 é bastante direta. Afinal, um dos objetivos do Haxe é a estabilidade em meio ao suporte de malabarismo para um grande número de plataformas alvo, e o Haxe 4 não decepciona aqui.

E os novos usuários? No final, cabe ao leitor decidir se Haxe é a melhor linguagem de codificação para jogos, se o ecossistema Haxe oferece as bibliotecas mais robustas para desenvolvimento web ou se as ferramentas específicas do Haxe fornecem o DX mais sensato para um fluxo de trabalho específico. No mínimo, Haxe continua a ser um concorrente viável em muitos espaços, oferecendo uma vantagem secreta para praticamente qualquer desenvolvedor.

Leitura adicional: Desenvolvedores novos no Haxe podem estar interessados ​​em um tutorial do Haxe relativamente novo por John Gabriele, e também as notas de lançamento do Haxe 4.1.0 e Haxe 4.1.1.