GWT é uma pilha de software que converte o código Java e um subconjunto da biblioteca de classes do Java Runtime em código JavaScript.

Em comparação com os kits de ferramentas JavaScript, o GWT pode parecer alienante, por natureza e por uso, e excessivamente complexo para fazer coisas simples, retirando grande parte do controle refinado que você teria usando JavaScript diretamente.

Por que um desenvolvedor da Web escolheria usar uma ferramenta como o GWT, que usa uma linguagem originalmente não direcionada para a Web, em vez de usar estruturas e kits de ferramentas puros JavaScript e JavaScript?

É mensurável melhor e com base em quais critérios?

Pilhas incluídas

Ferramentas Java

É simplesmente incrível:

• IDEs: mesmo que alguns IDEs suportem JavaScript, o nível de suporte simplesmente não se compara. Tente refatorar o código JavaScript em grandes bases de código (digamos, 40K + LOC) e chore.
• Teste de unidade: embora isso tenha aumentado nos últimos anos, também é muito mais maduro no mundo Java.
• Integração Contínua e Inspeção Contínua
• Geração de documentação: Claro que você tem o JSDoc e alguns outros

Digitação estática

Ele pega bugs cedo. (Endereço do Google Closure que mantém um pouco o desenvolvedor no mundo JavaScript, se você preferir).

JavaScript otimizado

O GWT grava JavaScript mais rápido e mais compacto que você (para aplicativos grandes) e permite determinar o que é enviado ao cliente sem dúvida mais facilmente do que com soluções JS completas equivalentes.

Arquitetura

Ele fornece uma boa separação de preocupações para aplicativos grandes, com arquiteturas MVC ou MVP decentes já pré-definidas com as pontas dos dedos.

Biblioteca decente

O GWT fornece bibliotecas interessantes e facilita (bem, mais fácil) a criação de aplicativos habilitados para I18N com carregamento dinâmico de pacotes.

Teste de unidade

Usando JUnit no Eclipse IDE e na linha de comandos. Isso se refere ao meu primeiro ponto. Você também pode usar algumas das ferramentas de qualidade de código do Java em um projeto GWT (para verificações de origem, não verificações de código de código, pois não há nenhuma).

É tudo sobre você!!

GWT não é para todos. Isso torna algumas pessoas mais produtivas e fornece uma boa ferramenta para desenvolvedores não JS criar aplicativos da Web profissionais com front-ends dinâmicos sem tocar em JavaScript (demais). Mas se não funcionar, basta usar outra coisa.

Se você deseja a maioria das opções acima, mas não deseja Java, talvez veja o Google Closure ou o Dojo Toolkit .

Foi uma boa idéia na época: a história importa !!

O mundo do JavaScript (e as tecnologias de front-end da Web em geral) está extremamente ativo atualmente, então as coisas estão melhorando. Mas apenas alguns anos atrás, as coisas não eram tão brilhantes. LESS / SASS não eram tão populares, o jQuery ainda não era a biblioteca JS de fábrica, as bibliotecas JavaScript não eram geradas a cada duas semanas e as ferramentas não eram tão boas em geral.

Mas já havia uma demanda crescente por aplicativos Web profissionais e grandes, com front-ends dinâmicos, então havia uma lacuna a ser preenchida para tornar os desenvolvedores mais produtivos. O JavaScript tem muitas armadilhas e esquisitices que você precisa conhecer, e talvez seja melhor nem precisar se preocupar com elas. Daí o nicho de ferramentas como o GWT.

Desde então, outros surgiram (o CoffeeScript vem à mente, o Dart está a caminho, mas também grandes estruturas JavaScript, a revolução do JS do lado do servidor com o Node.JS e outros, e um forte retorno do JavaScript como "suficientemente bom". idioma ao redor para ser usado não apenas no lado do cliente, mas também em outras partes da pilha de negócios.

Notas Adicionais

Com relação à sua pergunta original (agora editada) sobre o uso do Firebug

Você pode depurar o código GWT com o Firebug, é claro, mas o ideal seria depurá-lo diretamente do depurador do Eclipse IDE, que agora oferece suporte à depuração de código ativo.

No entanto, o Firebug ainda pode ser utilizado, embora você tenha em mente que o GWT gera JavaScript otimizado e compactado, o que pode não ser fácil de depurar como está.

Com relação à sua pergunta original (agora editada) sobre CSS

Sim, você ainda precisa escrever o código CSS, é claro. Você associa seu projeto GWT a outras ferramentas (como o SASS), com mais ou menos facilidade.

É apenas uma ferramenta!

Não confunda o GWT com o que não é: você não escreve código Java para ser executado diretamente no lado do cliente como código de código Java. Você escreve código na linguagem Java, que é convertida em JavaScript para maior eficiência e para permitir o uso de uma linguagem de nível superior (ou, pelo menos, é assim que deve ser vista).

Indiscutivelmente , Java e JavaScript podem ser considerados comparáveis ​​em termos de níveis de abstração. No entanto, o Java possui algumas vantagens (detalhadas acima), daí a vantagem de colher os benefícios das ferramentas existentes sem a necessidade de reescrevê-las. Os desenvolvedores do Google tiveram a ideia inteligente de tornar possível reutilizar as ferramentas orientadas a Java existentes, mas desenvolver aplicativos JavaScript.

Além disso, eles resolvem outro problema, que era o gerenciador de aplicativos da Web em dois idiomas, geralmente complicado, onde o código JavaScript e o Java eram tratados separadamente. O uso do GWT permite um certo nível de convergência para os dois lados do processo de desenvolvimento.

Leitura adicional:

• O que você achou da GWT?
• Para pilhas JavaScript, consulte Combinações de estruturas JavaScript / CSS / HTML

Depois de passar anos desenvolvendo um aplicativo Web no GWT, minha opinião é que o GWT tem desvantagens tão sérias que eu nunca o usaria novamente se não sou obrigado a fazê-lo.

Árvore DOM

Embora o desempenho do JavaScript possa ser melhor, a árvore DOM renderizada geralmente é desnecessariamente complexa. Por exemplo, a implementação em árvore usa mais de 13 elementos DOM, incluindo uma <table> para cada item individual. O uso de árvores grandes (cerca de 10.000 itens) simplesmente congela o navegador. Uma árvore JavaScript / HTML / CSS pura foi capaz de lidar com a mesma quantidade de itens facilmente.

Desenvolvimento

O ciclo de modificação e tentativa da fonte JavaScript / HTML / CSS pura não pode ser superado. Você acabou de salvar seu arquivo de origem e atualizar a página no navegador. Esse é um fator chave na produtividade e o GWT simplesmente não pode competir, mesmo usando o servidor de código.

Depurar JavaScript é absolutamente fácil e prazeroso com o depurador do Chrome ou Firebug.

Especialistas em martelo

A idéia de usar Java para tudo é para desenvolvedores que são "especialistas em martelos". Eles são donos de seu martelo, então tudo é um prego. Eu acho que essa abordagem está muito errada. O uso do GWT também requer conhecimento de CSS e HTML. Sem isso, os desenvolvedores do GWT geralmente se deparam com problemas que consideram quase impossíveis de resolver, enquanto alguém com experiência em HTML / CSS pode encontrar uma solução. Se os desenvolvedores precisarem dessa competência, eles poderão facilitar o desenvolvimento em HTML.

Minha opinião é que a maioria das vantagens oferecidas pelo GWT são pelo menos questionáveis, enquanto as desvantagens são muito mais graves em comparação com o desenvolvimento em JavaScript / HTML / CSS puro.

Não é mensurável melhor.
Para o uso diário, considere jQuery , AmpleSDK ou algum polyfill html5 .

O GWT tem muitas despesas gerais: reais e conceituais.

Pode ser útil se você tiver um aplicativo java ou algum código java do servidor para portar para um front-end da web.

Poucos benefícios do uso do GWT em que penso (mais detalhes, leia meu blog http://www.pandurangpatil.com/2012/09/benefits-of-using-gwt.html )

1. Como o aplicativo cliente GWT é escrito em Java, é possível obter erros sintáticos no momento da compilação devido ao mesmo (embora ele não suporte todas as classes JRE, pois esses recursos não são suportados pelo próprio navegador). Vamos dar um exemplo para entender o que estou dizendo. Se você digitar incorretamente um nome de variável JavaScript usando a biblioteca JavaScript pura. A única maneira de detectar esse erro é executar o aplicativo e testar os resultados desejados. Recursos Java como Genéricos e Anotações são de uso completo e podem ser usados ​​em seu aplicativo.

2. Pode-se fazer uso das bibliotecas disponíveis existentes ou escrever uma para gerar código conforme o requisito com facilidade, pois o código que precisa ser gerado precisa estar em Java. O compilador GWT se encarrega de compilá-lo e convertê-lo em JavaScript.

3. O gerenciamento de código se torna mais fácil.

4. Pode-se simplesmente escrever alguma lógica comercial comum de tal maneira que possa ser usada no código do lado do cliente GWT e também no código do lado do servidor como em Java, por exemplo, validação de dados ou algumas funções comuns do utilitário.

5. Com o uso do plug-in GWT eclipse, você pode depurar facilmente o código do cliente em Java para sua lógica de negócios.

6. Como o compilador GWT compila o código Java do seu cliente e gera JavaScript a partir dele. É necessário implantá-lo no servidor e ele é veiculado e executado no navegador do usuário quando solicitado. Ao gerar esse JavaScript, ele fará algumas otimizações.

   • Ele não considera código morto durante a geração de JavaScript, quando digo código morto, quero dizer "código que existe, mas não é chamado do fluxo principal". Por sua vez, reduz o tamanho efetivo do seu código JavaScript final.

   • Ele cuida de ofuscar o código JavaScript gerado.

   • Faz minificação do código JavaScript gerado.

   • E mais importante, ele gerará código otimizado específico do navegador separadamente. Quando digo separadamente, ele gera JavaScript separado específico do navegador, que será exibido quando a solicitação respectiva for recebida do navegador fornecido. O que, por sua vez, reduz o tamanho do código JavaScript que é baixado para um navegador específico, pois não contém toda a manipulação específica do navegador em um único código.

7. Se você está escrevendo seu aplicativo para diferentes idiomas, como inglês, hindi, marathi etc., usando o recurso Internacionalização do GWT. Ao gerar o código JavaScript, ele cria uma cópia por idioma e combinação do navegador. O que torna o código JavaScript gerado para uma determinada combinação de idioma e navegador mais otimizado e pequeno.

8. Caso você precise usar JavaScript direto, que pode ser chamado a partir do código Java GWT, é possível fazê-lo usando JSNI (JavaScript Native Interface). Pode-se até chamar o código Java GWT de volta do JavaSctipt.

9. Se você quiser tornar as páginas compatíveis com os Favoritos, poderá usar o recurso Histórico do GWT.

10. Se você deseja usar o JSON como formato de dados para comunicação e manipulação, ele possui um recurso muito bom, chamado JavaScript Overlay Types.

11. O recurso de adiamento de ligação do GWT é um bom recurso que, suponho, é possível fornecer por causa do Java.

12. Você pode construir sua interface com o usuário usando os widgets disponíveis do GWT no estilo Java Swing. Você pode até criar seus widgets personalizados com muita facilidade.

13. Se você deseja criar sua interface de usuário (páginas da Web) no estilo puro html, pode usar o recurso Declarative UI do GWT. Qual sinto como uma das principais características do GWT. O que torna mais fácil para o desenvolvedor criar páginas no estilo HTML puro. Suponho que seja mais sustentável do que a codificação no estilo Swing. E o mais importante: você ainda pode ter sua lógica em Java e apenas parte da apresentação em HTML puro. (Observação: qualquer método que você usar (UI declarativa ou Estilo Swing) acabará sendo apenas HTML, mas o que faz diferença é a maneira como você codifica e mantém o código).

14. O recurso Client Bundle do GWT facilita muito o gerenciamento de outros recursos da Web, como css, imagens e outros conteúdos de texto.

    • Os recursos CSS tornam possível ter lógica condicional dentro do seu css. Você também pode acessar alguns valores dinâmicos no código Java do lado do cliente GWT.
    • Ele também cuidará de ofuscar suas aulas de css. E o mais importante, o GWT automatizou a geração de interfaces a partir dos seus arquivos CSS para usar as classes de CSS.
    • O recurso de imagem facilita ao desenvolvedor o uso de imagens em seu aplicativo de maneira muito fácil de manter. Quando digo com facilidade, quero dizer quando você deseja usar imagens no código Java GWT, em vez de usar URL codificado, você pode usar o recurso de imagem. O benefício que você obterá usando o recurso de imagem é se você deseja alterar o local ou usar alguma imagem diferente com nome diferente, basta alterá-lo em um local. O recurso mais importante do recurso de imagem é quando você o usa com o recurso CSS como sprite. Ele cuidará de criar essa imagem como uri de dados em linha ou usá-la com sprite. Eu não digo que não é possível fazê-lo com outras estruturas, o mais importante é a rapidez e facilidade com que você pode fazê-lo. O GWT facilita muito para você.
    • O recurso de dados adiciona alguma otimização para arquivos de dados como .pdf, para renomear esses arquivos com base em seu conteúdo, para torná-lo altamente armazenável em cache pelo navegador. Arquivos de dados pequenos podem ser convertidos em uri de dados em linha.
    • Utilizando o Client Bundle para outros recursos da Web e se você estruturar adequadamente o aplicativo em diferentes módulos. Pode se tornar módulos completamente reutilizáveis ​​como um todo com todos os recursos. Qual o problema dos módulos reutilizáveis? bem, se você estiver usando imagens usando URL direta em algum módulo. E se você incluir esse módulo em outro módulo e tentar usar os componentes criados nesse módulo, ainda precisará copiar essas imagens para o URL público do seu aplicativo final. O que você não precisa fazer se usar essas imagens como recursos de imagem.
    • Outra otimização que você pode obter criando pequenos módulos usando o pacote configurável do cliente para css e imagens. Onde você pode optar por incluir apenas os módulos necessários dentro dos seus módulos finais. A diferença que fará no módulo final JavaScript e outros recursos conterão apenas o conteúdo necessário e não todo o conteúdo, mesmo se você desejar usar um pequeno pedaço do módulo.

15. Widgets de célula: para apresentar a coleta de dados paginados, o GWT possui Widgets de célula. Existem widgets como CellTable, CellList, CellTree e CellBrowser.

    • CellTable é destinado a apresentar dados em formato de tabela paginada, possui um recurso onde você pode alterar o conteúdo da célula especificada no local. Ele suporta paginação no lado do cliente e no servidor, suporta classificação na coluna e também suporta a seleção de um ou vários registros e a geração de eventos para o mesmo.
    • O CellList pode ser usado para apresentar dados no formato de lista e os itens podem ser exibidos no formato personalizado. Ele também suporta a paginação do lado do cliente e do servidor e a seleção de um ou vários registros e gera eventos para a seleção. CellTree e CellBrowser podem ser usados ​​para apresentar dados em formato de árvore.

16. Comunicação com o servidor a partir do código do cliente GWT. Ele suporta várias maneiras de implementar a comunicação do servidor cliente.

    • Se você não está preocupado com o protocolo que está sendo usado para transferência de dados, ele usa o mecanismo GWT RPC. É muito fácil integrar o código do lado do cliente para transferência de dados com o servidor. Você pode definir DTOs personalizados (objeto de transferência de dados) no código do cliente, que pode ser usado no código do servidor. A implementação do servidor aceita os mesmos DTOs que o parâmetro ou valor de retorno. Todo o resto é tratado pelo trabalho de quadro GWT RPC. Até propaga exceções geradas do código do servidor para o chamador no código do cliente (desde que você precise definir essas classes de exceção no pacote de códigos do cliente. O GWT RPC internamente utiliza chamadas AJAX com seu próprio protocolo personalizado para transferência de dados.

    • Se você não quiser usar o GWT RPC, poderá fazer chamadas de servidor AJAX para buscar dados do servidor usando o Request Builder. O que também é muito mais fácil de implementar. Ele também possui um recurso interessante Request Factory. Com esse recurso, você pode expor sua camada DAO ou Serviço para ser chamada a partir do código do cliente. Para fazer isso, você precisa definir alguns conjuntos de interfaces para o seu serviço e tipos de dados personalizados. E usando essas interfaces, você pode acessar esses serviços a partir do código do cliente. Eu escrevi o maven plugin para gerar essas interfaces. Se você anotar sua camada DAO com algumas anotações necessárias, consulte ( https://github.com/pandurangpatil/gwt-mvn-helper) consulte o módulo mvn-helper-test dentro dele para uso. O Request Factory é mais direcionado para integrar-se à camada ORM como JDO ou JPA no servidor. Ele tem um suporte para chamar persistir em determinada entidade a partir do código do cliente. E o mais importante quando você chama o método persistente, ele calcula e envia apenas alterações (delta) ao servidor para salvar.

    • Se você quiser fazer uma chamada JSONP entre domínios, poderá fazer a mesma referência.