Maiores armadilhas do GWT? [fechadas]

Estou no início / meio de um projeto que escolhemos implementar usando o GWT. Alguém já encontrou grandes armadilhas no uso do GWT (e GWT-EXT) que não puderam ser superadas? Que tal da perspectiva de desempenho?

Algumas coisas que vimos / ouvimos já incluem:

• O Google não consegue indexar conteúdo
• CSS e estilo em geral parecem um pouco esquisitos

Procurando por qualquer feedback adicional sobre esses itens também. Obrigado!

Vou começar dizendo que sou um grande fã de GWT, mas sim, existem muitas armadilhas, mas a maioria, se não todas, fomos capazes de superar:

Problema: Os longos tempos de compilação, à medida que o projeto cresce, aumentam a quantidade de tempo necessária para compilá-lo. Ouvi relatos de compilações de 20 minutos, mas as minhas são em média cerca de 1 minuto.

Solução: divida seu código em módulos separados e diga ao ant para construí-lo somente quando for alterado. Além disso, durante o desenvolvimento, você pode acelerar enormemente os tempos de compilação criando apenas um navegador. Você pode fazer isso colocando isso no seu arquivo .gwt.xml:

<set-property name="user.agent" value="gecko1_8" />

Onde gecko1_8 é o Firefox 2+, ie6 é o IE etc.

Problema: o modo hospedado é muito lento (pelo menos no OS X) e não chega nem perto de corresponder às alterações 'ao vivo' que você recebe quando edita coisas como páginas JSPs ou Rails e pressiona a atualização no navegador.

Solução: você pode fornecer mais memória ao modo hospedado (geralmente recebo 512M), mas ainda assim é lento. Descobri que, quando você fica bom o suficiente com o GWT, para de usá-lo. Você faz uma grande parte das alterações, compila para apenas um navegador (geralmente 20s de compilação) e depois clica em Atualizar no seu navegador.

Atualização: Com o GWT 2.0+, isso não é mais um problema, porque você usa o novo 'Modo de Desenvolvimento'. Basicamente, significa que você pode executar o código diretamente no navegador de sua escolha, sem perda de velocidade, além de poder fazer firebug / inspecioná-lo etc.

http://code.google.com/p/google-web-toolkit/wiki/UsingOOPHM

Problema: o código GWT é java e tem uma mentalidade diferente de criar uma página HTML, o que torna mais difícil pegar um design HTML e transformá-lo em GWT

Solução: Mais uma vez, você se acostuma a isso, mas, infelizmente, converter um design HTML em um design GWT sempre será mais lento do que fazer algo como converter um design HTML em uma página JSP.

Problema: o GWT exige um pouco de atenção e ainda não é popular. Isso significa que a maioria dos desenvolvedores que ingressam na sua equipe ou mantêm seu código precisará aprender do zero

Solução: Resta ver se o GWT decolará, mas se você é uma empresa que controla quem contrata, sempre poderá escolher pessoas que conheçam o GWT ou queiram aprender.

Problema: o GWT é uma marreta, comparado a algo como jquery ou javascript simples. É preciso muito mais configuração para que isso aconteça do que apenas incluir um arquivo JS.

Solução: use bibliotecas como jquery para tarefas menores e simples, adequadas a elas. Use o GWT quando desejar criar algo verdadeiramente complexo no AJAX ou quando precisar passar seus dados para frente e para trás através do mecanismo RPC.

Problema: Às vezes, para preencher sua página do GWT, você precisa fazer uma chamada de servidor quando a página carregar pela primeira vez. Pode ser irritante para o usuário ficar sentado e assistir a um símbolo de carregamento enquanto busca os dados necessários.

Solução: no caso de uma página JSP, sua página já foi renderizada pelo servidor antes de se tornar HTML, para que você possa efetivamente fazer todas as suas chamadas GWT e carregá-las previamente na página, para um carregamento instantâneo. Veja aqui para detalhes:

Acelere o carregamento da página pré-serializando suas chamadas GWT

Eu nunca tive problemas em CSS estilizando meus widgets, prontos para uso, personalizados ou não, então não sei o que você quer dizer com isso ser uma armadilha?

Quanto ao desempenho, sempre achei que uma vez que o código GWT compilado é rápido, e as chamadas AJAX são quase sempre menores do que a atualização de uma página inteira, mas isso não é exclusivo do GWT, apesar dos pacotes RPC nativos que você obtém se usar um back-end JAVA é bastante compacto.

Trabalhamos com o gwt há quase 2 anos. Nós aprendemos muitas lições. Aqui está o que pensamos:

1. Não use bibliotecas de widgets de terceiros, especialmente o gwt-ext. Isso matará seu desempenho de depuração, desenvolvimento e tempo de execução. Se você tiver dúvidas sobre como isso acontece, entre em contato comigo diretamente.

2. Use o gwt para preencher apenas as partes dinâmicas dos seus aplicativos. Portanto, se você tiver algumas interações complexas do usuário com muitos campos. No entanto, não use os painéis que o acompanham. Leve as páginas fornecidas pelo designer de estoque existente. Esculpir as áreas que conterão os controles do seu aplicativo. Anexe esses controles à página em onModuleLoad (). Dessa forma, você pode usar as páginas padrão do seu designer e também fazer todo o estilo fora do gwt.

3. Não crie o aplicativo inteiro como uma página padrão que cria dinamicamente todas as peças. Se você fizer o que eu sugiro no item 2, isso não acontecerá de qualquer maneira. Se você criar tudo dinamicamente, reduzirá o desempenho e consumirá grandes quantidades de memória para aplicativos de médio a grande porte. Além disso, se você fizer o que estou sugerindo, o botão Voltar funcionará muito bem, assim como a indexação de mecanismos de pesquisa etc.

Os outros comentaristas também tiveram boas sugestões. A regra de ouro que eu uso é criar páginas como se você estivesse criando uma página da Web padrão. Em seguida, esculpir as peças que precisam ser dinâmicas. Substitua-os por elementos com IDs e use-os RootPanel.get( id ).add( widget )para preencher essas áreas.

Armadilhas que encontramos:

• Embora você possa obter muitas milhas usando algo como o GWT EXT, sempre que usar esse tipo de verniz fino na parte superior de uma biblioteca JavaScript, você perde a capacidade de depurar. Mais de uma vez eu bati minha cabeça na mesa porque não consigo inspecionar (dentro do meu depurador IntelliJ) o que está acontecendo na classe de tabela GWT EXT ... Tudo que você pode ver é que é um JavaScriptObject. Isso torna bastante difícil descobrir o que deu errado ...

• Não ter alguém em sua equipe que conheça CSS. Pela minha experiência, não importava que a pessoa não fosse especialista ... basta que ela tenha algum bom conhecimento de trabalho e conheça os termos certos para pesquisar no Google quando necessário.

• Depuração nos navegadores. Fique de olho no Modo Fora de Processo Hospedado [ 1 ] [ 2 ] [ 3 ], esperançosamente no GWT 1.6 ... Por enquanto, você só precisa melhorar o modo hospedado e, em seguida, use o botão "Compilar / Procurar" , onde você pode jogar com outros navegadores. Para mim, trabalhando no Windows, isso significa que posso ver meu trabalho no FireFox e usar o FireBug para ajudar a ajustar e melhorar as coisas.

• IE6. É incrível como o IE 6 diferente renderiza as coisas. Adotei a abordagem de aplicar um estilo à "viewport" mais externa de acordo com o navegador, para que eu possa ter regras CSS como:

  .my-style { /* stuff that works most everywhere */ }
  
  .msie6 .my-style { /* "override" so that styles work on IE 6 */ }

Por fim, certifique-se de usar um editor que o ajude. Eu uso o IntelliJ - ele tem muitos conhecimentos de GWT. Por exemplo, se eu tentar usar uma classe que não é tratada pela emulação do JRE, isso será informado; se eu especificar um estilo para um widget e ainda não o tiver definido, o código ficará um pouco vermelho e ondulado ... Ou, ao olhar para o CSS, ele me informará quando especifiquei atributos conflitantes em um regra única. (Ainda não tentei, mas entendo que a versão 8 tem suporte GWT ainda melhor, como manter sincronizadas as interfaces e implementações RPC "local" e "assíncrona").

O GWT 2.0, que deve sair nos próximos meses, resolve muitos dos problemas discutidos.

• Crie layouts usando uma sintaxe html / xml como
• Carregamento de script dinâmico - somente o JS essencial será baixado inicialmente. O restante será baixado conforme necessário
• Modo hospedado no navegador - Isso pode resolver os problemas de velocidade do modo hospedado discutidos, entre outros benefícios
• "Otimizações de compilador" - compilação mais rápida, espero

Vídeo de visualização do GWT 2.0 na E / S do Google

Não é "incapaz de ser superado", mas um pouco de dor por algo básico.

Data de manuseio:

O GWT usa o obsoleto, o java.util.Dateque pode levar a um comportamento inesperado ao lidar com datas no lado do cliente. java.util.Calendarnão é suportado pelo GWT. Mais informações aqui .

Exemplos de problemas relacionados:

• Erro de serialização do GWT java.util.Date
• Obter detalhes da data (dia, mês, ano) no GWT
• Suporte de fuso horário do lado do cliente no GWT

Vou acrescentar alguns pontos aos já mencionados:

• Ligação de dados / validação. O GWT não possui suporte de validação / ligação de dados pronto para uso, embora haja alguns projetos nessa área começando a surgir. Você se encontrará escrevendo muito disso:

TextField fname, faddress;
...
fname.setText (person.getName ());
faddress.setText (person.getAddress ());
...

• Carregamento lento. Como o gwt está no lado do cliente, o carregamento lento não é realmente uma opção. Você precisará projetar cuidadosamente seus RPCs e objetos de domínio para
  • envie todos os seus dados de objeto necessários
  • evite buscar ansiosamente todos os seus dados
  • Você também deve garantir que não enviará proxies / objetos não serializáveis. O hibernate4gwt pode ajudá-lo com esses pontos.
• Design de interface do usuário. É mais difícil visualizar uma interface do usuário em java (painéis, botões etc.) do que em html.
• Suporte de histórico. O GWT não é fornecido com um subsistema Histórico, nem com qualquer subsistema para URLs agradáveis ​​ou favoritos de estado. Você terá que fazer o seu próprio (embora ele tenha suporte para tokens do Histórico, o que é um começo). Isso acontece com todos os kits de ferramentas AJAX AFAIK.

IMHO, falta ao GWT uma estrutura que tenha suporte imediato para todos os problemas mencionados neste 'thread'.

No momento, estou trabalhando em um projeto que usa EXT GWT (GXT) para não ser confundido com GWT EXT. Há uma diferença: EXT GWT é aquele que é realmente produzido pela empresa que criou o ExtJS na biblioteca javascript. GWT EXT é um wrapper GWT em torno da biblioteca ExtJS. GXT é GWT nativo.

De qualquer forma, o GXT ainda é um pouco imaturo e carece de uma comunidade sólida que eu sinto que o GWT EXT possui. No entanto, o futuro está com o GXT, pois é nativo e realmente desenvolvido pela empresa que criou o ExtJS. O GWT EXT está um pouco danificado à medida que a licença é alterada na biblioteca ExtJS, retardando o desenvolvimento do GWT EXT.

No geral, acho que o GWT / GXT é uma boa solução para o desenvolvimento de um aplicativo da web. Na verdade, eu gosto bastante do modo hospedado de desenvolvimento, que torna as coisas rápidas e fáceis. Você também tem o benefício de poder depurar seu código também. Os testes de unidade com o JUnit também são bastante sólidos. Ainda não vi uma ótima estrutura de teste de unidade JavaScript que considerava madura o suficiente para testar um aplicativo corporativo.

Para mais informações sobre o GWT EXT: http://gwt-ext.com/

Para mais informações sobre EXT GWT (GXT): http://extjs.com/products/gxt/

Não há grandes armadilhas que não consegui superar com facilidade. Use o modo hospedado fortemente. Como você está usando o GWT-ext, você quase nunca precisará tocar em CSS, a menos que queira ajustar a aparência pronta para uso.

Minha recomendação é usar um widget "nativo" do GWT em uma biblioteca onde eles estão próximos dos recursos.

Indexação do mecanismo de pesquisa novamente: sim, o site não terá URLs navegáveis ​​normalmente (a menos que você esteja adicionando widgets apenas aos elementos de um site comum). Você pode fazer a funcionalidade de retroceder / encaminhar o histórico.

Eu usei o GWT e o GWT-ext juntos em um projeto há um tempo atrás. Achei a experiência bastante tranquila no desenvolvimento da Web, mas meu conselho seria o seguinte:

Não misture widgets nativos GWT com widgets EXT. É confuso como o inferno, pois geralmente os nomes são os mesmos (GWT.Button ou GWText.Button?)

Aconteceu uma coisa que realmente tornou o código mais complexo do que eu gostaria, e que eu queria um painel que fosse a) atualizável dinamicamente b) em cascata

Os painéis nativos do GWT são dinâmicos, os painéis Ext são em cascata. Solução? Um GWT.VerticalPanel envolvendo um painel GWTExt ... Caos. :)

Mas ei, isso funciona. ;)

Segundo o comentário de ykagano, a maior desvantagem é perder o V no MVC. Embora você possa separar a classe da interface do usuário verdadeira do restante do código do lado do cliente, não é possível usar facilmente uma página HTML gerada por um designer gráfico / web. Isso significa que você precisa de um desenvolvedor para traduzir HTML em java.

Obtenha um editor de interface do usuário wysiwyg, ele economizará muito tempo. Eu uso o GWTDesigner.

A maior vantagem do GWT é poder esquecer os problemas entre navegadores. Não é 100%, mas tira quase toda essa dor. Combinado com o benefício da depuração no modo hospedado (ao contrário do Firebug, que é excelente, mas não o mesmo que um depurador java), ele oferece ao desenvolvedor uma enorme vantagem na geração de aplicativos ajax complexos.

Ah, e é rápido no tempo de execução, especialmente se você usar um filtro gzip.

Um pouco fora do tópico, mas o canal #gwt no irc é muito útil, caso você tenha um problema persistente.

O GWT é bem direto e intuitivo.

Especialmente com o lançamento do UIBinder para permitir que os widgets do GWT sejam dispostos em XML e depois codificados em Java.

Portanto, se você usou outras ferramentas de design do Ajax ou Flash, ou Silverlight, etc, é muito fácil aprender o GWT.

O principal obstáculo, se não a armadilha, é o RPC da GWT. O motivo pelo qual você deseja usar o GWT é o RPC assíncrono do GWT. Caso contrário, por que não confiar apenas no css para formatar sua página?

GWT RPC é o elemento que permite ao servidor atualizar dados no servidor sem precisar atualizar a página. Esse é um requisito absoluto para páginas como monitoramento do desempenho das ações (ou a atual dívida pública e nacional dos EUA ou o número de bebês ainda não nascidos abortados em todo o mundo a cada segundo).

O GWT RPC exige algum esforço para entender, mas, dadas algumas horas, tudo deve ficar claro.

Acima disso, depois de fazer algum esforço para aprender o GWT RPC, você finalmente descobre que não pode usar JSPs como o componente de serviço do RPC, a menos que ... Eu tenho uma série de 8 partes (eu acho) no meu blog sobre como usar o JSP como o prestador de serviço GWT RPC. No entanto, como você não pediu respostas, mas apenas problemas, desistirei de anunciar meu blog.

Assim. Acredito muito que os piores obstáculos / armadilhas para o uso do GWT é descobrir como implantar corretamente o RPC assíncrono do GWT e como habilitá-lo para usar os servidores JSP.

Tivemos muita dificuldade em casar nossa base de código GWT com modelos da Web em HTML que obtivemos de um web designer (páginas HTML estáticas com IDs de div específicos que queríamos que o GWT gerenciasse). Pelo menos quando o usamos, não conseguimos integrar o GWT com partes do nosso site que não estavam codificadas no GWT. Acabamos trabalhando, mas foi um grande truque.

• A interface assíncrona que você precisa escrever para cada interface de serviço se parece com algo que poderia ter sido gerado automaticamente pelo compilador GWT.
• Os tempos de compilação se tornam longos para grandes projetos

Mas para um grande projeto Javascript, é a melhor escolha

O GWT 2.4 corrigiu muitos dos problemas mencionados acima e uma ótima biblioteca de widgets acaba de sair do Beta (Ext GWT 3.0.4, também conhecido como GXT), que foi escrito completamente em GWT, não um invólucro de uma biblioteca JS.

Dor remanescente:

• Falta de suporte ao seletor CSS3, você pode usar "literal ()" em alguns casos para contornar isso.
• Falta de suporte para CSS3 e eventos modernos do navegador, como transiçãoEnd .
• Falta de suporte à classe Java Calendar (muitos anos depois).
• Falta de suporte ao JUnit4 (5 anos e contando).
• Falta de roteiro claro e cronograma de lançamento da equipe do Google GWT.

Em relação ao GWT 2.4, use o Firefox ao depurar o GWT, muito mais rápido que o chrome. E se você estiver usando apenas o Firefox, considere colocar esta linha no seu arquivo project.gwt.xml

<set-property name="user.agent" value="gecko1_8" />

Além disso, se você estiver usando o eclipse, adicione o seguinte em argumentos -> argumentos da VM:

-Xmx512m -XX: MaxPermSize = 1024m -XX: PermSize = 1024m

Você pode dividir o servidor e o cliente e usar o seguinte em argumentos -> Argumentos do programa: -codeServerPort 9997 -startupUrl http: // nome do servidor / projeto- servidor

Além disso, para impedir a atualização do servidor em cada alteração, use o JRebel http://zeroturnaround.com/blog/how-to-rock-out-with-jrebel-and-google-web-toolkit-gwt/ E aqui está uma demonstração ao vivo http://www.youtube.com/watch?feature=player_embedded&v=4JGGFCzspaY

Uma grande armadilha é que, às vezes, você precisa atribuir explicitamente um ID ao que finalmente se torna um elemento HTML para poder usar determinados estilos CSS. Por exemplo: um GWT TabPanel fará apenas: pairar sobre tabBarItems quando a tabBar do tabPanel tiver um ID atribuído e você especificar um: hover nesse elementId.

Eu escrevi sobre algumas outras desvantagens do GWT em outros lugares, mas elas já estão cobertas pela resposta do rustyshelfs :).

Eu tenho trabalhado muito no GWT recentemente, e é isso que eu tenho que dizer:

1. O estilo CSS é complicado às vezes, use a ferramenta de desenvolvedor do IE no IE e o firebug no Firefox para descobrir o que exatamente está acontecendo e você terá uma idéia clara do que o css precisa ser alterado
2. Você pode usar truques para fazer o google indexá-lo. Um site muito famoso é http://examples.roughian.com/, verifique suas classificações no google. Um site muito menos famoso é www.salvin.in (não pude resistir a mencionar isso), eu o otimizei para palavras: home page salvin (pesquise essas três palavras no google)

Não sei muito sobre o GWT-EXT, mas também acredito que não há necessidade de incluir bibliotecas de terceiros.

Boa sorte na sua decisão :)

O GWT detecta o navegador em vez da detecção de recursos e seu aplicativo não funciona em alguns navegadores (especialmente os novos)

Aqui estão algumas referências do problema:

• google-web-toolkit Edição 2938: RFE: aprimore o provedor de propriedades user.agent para lidar com a "máscara" da string userAgent
• Iceweasel não é mais suportado? - Ajuda do Google Docs
• Implementações de GWT para todos os navegadores

Aqui estão algumas referências à Detecção de recursos:

• Detecção de navegador (e o que fazer)
• Detecção de recursos: Script de navegador de última geração
• Detecção de recursos do navegador

Extraído da comparação de estruturas JavaScript - Wikipedia

A equipe do GWT fez muitas grandes melhorias no ano passado, com o lançamento do GWT 2.7. Uma das principais fraquezas do GWT foi que a compilação leva muito tempo no GWT 2.6 e abaixo. Agora, o GWT não tem compilação incremental, que é super rápida e compila apenas as alterações.

Agora o GWT 2.7 possui ( fonte ):

• Construções incrementais agora em apenas alguns segundos
• SourceMaps mais compactos e precisos
• Suporte GSS
• JSInterop
• Excelente desempenho em JavaScript
• Tamanho menor do código

A melhor maneira de obter fatos confiáveis ​​é lembre-se de que você pode usar js no GWT a qualquer momento. Portanto, se estiver enfrentando problemas com o GWT, considere usar js. No final do dia, o GWT é js, para que você possa fazer qualquer coisa no GWT em js. De fato, a maioria dos projetos de GWT usa js. O problema é que o GWT é drasticamente mais complicado. No entanto, às vezes vale a pena a complexidade extra. pesquisa gwt . Um dos maiores problemas com o GWT sempre foi um longo tempo de compilação. Felizmente, está melhorando muito rapidamente, para que não seja um problema significativo no futuro próximo. Outra armadilha é que o GWT é dramaticamente mais complicado, porque Java é uma linguagem mais complicada que resiste aos codificadores ruins a cada passo do caminho. Além disso, a compilação adiciona uma camada. Por exemplo, js interop requer um pouco de clichê. A questão fundamental é que o GWT não foi projetado para ser simples. Ele foi desenvolvido desde o início para aplicativos da Web extremamente complicados e toda a comunidade prioriza consistentemente, desempenho, qualidade do código, arquitetura, etc., em vez de facilitar a codificação.

Vale ressaltar que o GWT 3.0 trará grandes melhorias.

Reutilizando objetos de serviço RPC.
Causa condições de corrida com sintomas que parecem com o aplicativo travado.

Armadilhas que encontrei no 1. Comportamento diferente no modo superdev. Por exemplo, Someclass.class.getName () funciona absolutamente bem no modo Superdev e retorna o nome completo da classe. No modo produtivo, isso não funciona.

2. addWidget (widget) chamará removefromparent () do widget

GWT é uma obra-prima da tecnologia. Ele une a programação de clientes e servidores, tornando-o um aplicativo coerente - a maneira como o software foi escrito antes da "camada" e a maneira como deveria ser escrito. Elimina diferentes conjuntos de habilidades, falta de comunicação entre os membros da equipe e, geralmente, toda a fase de Web Design: artística e de programação. E é o mais próximo que você chegaria do celular, por exemplo, desenvolvimento Android. De fato, o GWT foi projetado para gerar diferentes UIs nativas, não apenas HTML. Embora exija enorme disciplina para garantir essa dissociação - para manter as camadas internas agnósticas.

O primeiro erro que você deve evitar, que levou quatro anos para perceber, é usar extensões de terceiros como EXT-GWT, também conhecido como GXT e SmartGWT. É muito tentador começar a usar seus widgets bonitos de área de trabalho em vez de investir em seu próprio estilo, mas não sei dizer quantos problemas tive com o SmartGWT até finalmente me cansar. Em resumo, congela o conjunto de recursos principais do GWT no nível certo (bastante desatualizado) e depois é construído sobre ele. Lembre-se também de que a aparência cinzelada da área de trabalho parece boba hoje em dia, sem mencionar o desempenho lento, toneladas de bugs e recursos de compatibilidade - especialmente em dispositivos móveis. Você deseja permanecer o mais próximo possível dos controles nativos do navegador, isto é, listas suspensas renderizadas como elementos nativos <select>, não alguns controles personalizados.

Graças às tendências para dispositivos móveis, todo o UX está se tornando mais simples e plano, para que você não precise fazer muito para criar um aplicativo com aparência nítida. Embora se você deseja uma aparência "3D", também existem gradientes. O CSS3 facilitou tudo e o GWT envolve uma maneira elegante e orientada a objetos, diferente do CSS bruto. Portanto, não desanime olhando para os controles barebones bastante feios no GWT Showcase. A equipe do GWT intencionalmente não ofereceu nenhum estilo, porque é o trabalho do desenvolvedor.

O resto é praticamente uma programação de navegador convencional em Java fortemente tipado com belas APIs concisas. Mas é claro que nunca esquecendo que seu código é executado dentro do navegador, portanto, todas as chamadas são assíncronas, por exemplo, você não pode chamar métodos GWT-RPC em um loop (para preencher alguma lista), mas precisa encadear recursivamente se alguma vez chegar a isso situação.

Existem alguns "anti-padrões" auto-proclamados como não usar o GWT-RPC. Até agora tem sido bom para mim: há 10 anos. Simplicidade é a chave. Eu não pensaria nem um segundo em sacrificar algum desempenho marginal pela elegância e manutenção do código. além disso, não é onde seus gargalos estariam - no banco de dados. Obviamente, lembre-se da quantidade de dados que você está enviando para o cliente.

E se você não conseguir encontrar ou estilizar o gadget existente - leia um rico conjunto de elementos HTML5, sempre poderá agrupar um de terceiros. Eu fiz isso com um popular jQuery FullCalendar. Nem ciência de foguetes. Todo o resto, como o Google Maps e o Google Charts, possui invólucros semi-oficiais do GWT.

GWT é perfeito. A única razão pela qual ele não recebe amor suficiente é porque os primeiros usuários da Internet que ainda influenciam o setor não vieram da Ciência da Computação e das linguagens orientadas a objetos para apreciá-los. Eles têm background artístico (Photoshop / WordPress) ou de rede (Perl / Python).