Arquivo da tag: framework

SWX Labs 02 -Framework Chef

capa01

No SWX Labs 02 vamos falar sobre o Framework Chef.

O Chef é um framework open source mantido pela Opscode que fornece uma API e um conjunto de ferramentas para auxiliar administradores de sistemas e desenvolvedores a construir e gerenciar infraestruturas de larga escala. O chef é baseado no pressuposto de que a infraestrutura pode ser representada como código e, portanto, pode se tornar testável, versionável e replicável .

Temas abordados no programa:

  • Definição de framework e nuvem
  • Origens e aplicação do Chef
  • Elementos básicos do Chef
  • Fontes de pesquisa e curva de aprendizado
  • Projeto 14 Bis: Exemplo de aplicação do Chef

Links:

Assine o feed do nosso podcast e não perca nenhum episódio: http://feeds.feedburner.com/SWXLabs

Se preferir, também estamos no Itunes Store

Gostou? Não gostou? Erramos algo? Sua opinião é muito importante para nós, por isso deixe seu comentário ou envie email para mike@swx.com.br

Ouça o podcast clicando no play, se preferir faça o download

 

Atualização para Ruby 1.9.3 corrige problema de segurança no RubyGems

Fonte:IMasters

Com informações de The H

A equipe de desenvolvimento do Ruby publicou uma atualização para a série 1.9.3, chamada de 1.9.3-p194, da sua linguagem de programação para corrigir uma vulnerabilidade encontrada no framework de gerenciamento de pacote RubyGems.

O problema causava falha na verificação do servidor SSL para repositórios remotos. Ele foi corrigido ao desaprovar redirecionamentos de conexões https para http, ao habilitar a verificação de certificados do servidor SSL em uma versão atualizada do RubyGems, a 1.8.23. Mais detalhes podem ser encontrados aqui.

Mais informações sobre a atualização, incluindo uma lista de correções de bugs, podem ser encontradas no anúncio oficial de lançamento e no change log. O Ruby 1.9.3-p194 está disponível para download no site do projeto.

jQuery Mobile 1.1.0 é anunciado

Fonte: IMasters

A equipe de desenvolvimento do jQuery Mobile anunciou a versão 1.1.0 do framework web.

Entre as melhorias, os destaques são correção para barras de ferramentas, mudança na transição de páginas animadas e no carregador Ajax, formulário de design de elemento refinado e configuração de funcionalidade, e documentação aprimorada.

Para tornar a atualização da versão 1.0 para a 1.1 suave, os desenvolvedores lançaram a ferramenta ThemeRoller Mobile que suporta ambas as versões e torna fácil a migração de temas da 1.0 para a 1.1.

Além disso, a nova versão traz suporte para jQuery 1.7.1, para o módulo AMD.

A lista de novas funcionalidades e de correções de bugs é extensa, e pode ser vista em detalhes no anúncio de lançamento.

O jQuery Mobile 1.1.0 está disponível para download aqui.

Microsoft abre código de ASP.NET Web API e ASP.NET Web Pages

Fonte: IMasters

Com informações de The H

A Microsoft abriu o código da ASP.NET Web API e da ASP.NET Web Pages sob a licença Apache 2.0. A Web API e a Web Pages, também conhecida como Razor, encontraram um novo lar na plataforma de hospedagem CodePlex da Microsoft.

Agora, desenvolvedores que não são da Microsoft podem contribuir com pacotes e com código nos utilitários de desenvolvimento web – entretanto, isso ainda será avaliado pelos desenvolvedores da Microsoft.

De acordo com Scott Guthrie, vice-presidente da divisão de desenvolvimento da Microsoft, a empresa tomou um caminho semelhante com o Windows Azure SDK e afirma ter sido uma experiência positiva. A iniciativa não muda o status das três ferramentas como sendo totalmente suportadas pelos projetos da Microsoft.

A ASP.NET Web API é um framework para escrever aplicações RESTful usando a plataforma .NET, que teve sua origem na Windows Communication Foundation. A Razor/ASP.NET Web Pages é uma linguagem de template baseada em C# que pode ser usada para combinar código de servidor com HTML para criar páginas geradas dinamicamente.

LESS CSS: Início, Meio e Fim – Conceitos iniciais

Fonte: Fabrício Sanchez!

A internet evolui diariamente, isso é um fato. Tal evolução demanda cada vez mais recursos (tanto para quem utiliza aplicações e serviços web, quanto para quem os implementa).

No sentido de incrementar produtividade e adicionar melhores práticas ao processo de desenvolvimento de aplicações para a internet, a comunidade técnica de desenvolvedores ao redor do mundo constantemente implementa, disponibiliza e mantém novos recursos ativos. Alguns exemplos são:

  • PDF Sharp: um complemento para processar programaticamente arquivos PDF.
  • JSON .NET: um framework de alta performance para o trabalho com JSON.
  • MVC Contribut: framework escrito para desenvolvedores que desejam testar elementos de UI em suas aplicações MVC.

Nesta série apresentaremos os conceitos fundamentais relacionados a um novo framework escrito nos padrões mencionados anteriormente, isto é, desenvolvido e mantido pela comunidade técnica que tem por objetivo permitir a escrita de código CSS de forma otimizada: LESS CSS.

Observação: esta série não ensinará CSS. Aqui, partimos do princípio de que os conceitos relacionados a esta linguagem já são conhecidos por você e nos concentramos apenas em apresentar uma nova forma de trabalhar com eles.

O que é LESS CSS?

LESS é um termo da lingua inglesa que designa “menos – menor quantidade”. A framework alvo de nosso estudo nesta série tem este nome (LESS CSS) não por acaso. LESS CSS é uma framework escrita com o ojetivo de otimizar a escrita de códigos na linguagem CSS, fato este que necessariamente implica na diminuição da quantidade de código escrito. Menos código escrito significa mais performance na renderização das páginas, o que implica em maior velocidade na exibição da informação para o usuário final.

Além das características recém mencionadas, há um aspecto proporcionado por esta framework que é determinante para sua adoção: o desenvolvedor pode escrever códigos mais limpos e elegantes, conforme veremos com a evolução da série.

CSS dinâmico?

Se existe uma palavra que chama atenção de qualquer desenvolvedor que inicia seus estudos em uma linguagem, framework, whatever, está palavra é “dinamismo”. De forma geral, bons devs buscam encontrar melhores formas de escrever seus códigos e, tecnologias que apresentam aspectos dinâmicos, sempre se apresentam como opções interessantes.

Conforme apresenta a imagem do início deste texto, LESS CSS apresenta uma forma dinâmica de escrever folhas de estilos (It’s the dynamic stylesheet language). O “dinamismo” é proporcionado por recursos como: variáveis, mixins, operações, funções, etc. (falaremos individualmente sobre cada recurso nos próximos posts).

Onde funciona?

Uma característica interessante do LESS CSS é que este funciona tanto do lado do cliente quanto do lado do servidor (neste último utilizando Node.js e Rhino). Assim, podemos “escolher” o ambiente para renderização do código LESS. Em post futuro, falaremos especificamente sobre como utilizar em ambos os cenários.

Criando o mind set

Agora que os conceitos estão “saltando a vista”, basta realizarmos uma análise simples em no modelo tradicional de escrita de códigos CSS para obtermos uma auto-justificação do LESS. Assim, considere o código apresentado pela Listagem 1.

#BoxTexto { color: #000; background: #EFEFEF; }
#BoxTexto a { text-decoration: underline; }
#BoxTexto p { font-family: Arial; }
#BoxTexto x {...} #BoxTexto y {...}
#BoxTexto z {...}

Listagem 1. Forma tradicional de escrever código CSS

O problema é evidente, certo? Para que possamos utilizar o mecanismo de herança, precisamos reecrever o mesmo código seis vezes. Em um tempo onde produtividade é fator chave no processo de desenvolvimento de software, este tipo de notação tende a cada vez mais, cair em desuso.

Em contra partida, observe o código apresentado pela Listagem 2.

#BoxTexto {
color: #000;
background: #EFEFEF;
a { text-decoration: underline; }
p { font-family: Arial; }
}

Listagem 2. CSS reduzido

Bem melhor não? Esta é a proposta do framework LESS. O mesmo código escrito de forma mais elegante e inteligente resultando no mesmo aspecto visual entretanto, com mais performance.

jSlater, framework de painel JavaScript, agora é open source

Com informações de The H

Fonte: IMasters

Rasmus Berg Palm liberou seu framework de painel jSlate como uma licença GPLv3 open source. O jSlate permite que usuários criem painéis que recuperam seus dados a partir de qualquer serviço web acessível e que criem visualizações de painéis baseados nos gráficos interativos JavaScript Highcharts JS e em documentos orientados a dados.

De acordo com Berg Palm, a iniciativa tem suas raízes no projeto Nomnom, que foi criado para agregar e para visualizar dados sobre o festival Roskilde, no qual ele é voluntário como parte de um grupo de desenvolvedores e administradores de sistema. O Nomnom era muito parecido com o jSlate, mas usava CouchDB como um backend e requeria que dados fossem armazenados de uma maneira facilmente visualizável.

O desenvolvedor queria criar algo que trabalhasse como um “blank slate”, capaz de trabalhar com o armazenamento já existente das pessoas ou sistemas BI.

Berg Palm afirmou que deixou de fora desse primeiro release algumas funcionalidades. Ele acrescentou que espera que o jSlate, agora open source, conte com a contribuição de usuários.

Conhecendo o F#

Como você sabe, existem algumas linguagens OOP por aí. Você provavelmente conhece VB.Net, C# e Java, mas eu vou falar de uma relativamente nova.

Gostaria de falar um pouco sobre F#.

Similar ao C# e ao VB.Net, o F# também é direcionado para o Framework .Net e também é orientado a objeto.

A principal diferença no F# não é sua sintaxe única, mas sim o novo ponto de vista e o estado de espírito que traz para a programação orientada a objeto.

O F# usa inferência de tipos – o que significa que o programador não precisa se preocupar com a declaração de tipo e pode apenas utilizar a palavra reservada “let” (que é similar a “var”). A declaração do tipo de dados será deduzida pelo compilador durante a compilação (o F# também permite a declaração explícita de tipos de dados).

Depois dessa pequena introdução ao F# (bem pequena), gostaria de começar a parte prática. E este artigo será sobre Listas no F#.

Vamos fazer um pequeno experimento:

Crie uma lista de ints no C#

List<int> newList = new List<int>();

Adicione os seguintes valores a essa lista:

newList.Add(5);
newList.Add(2);
newList.Add(-3);
newList.Add(1);

Agora por favor tente classificá-la usando valor absoluto.

Você provavelmente descobrirá que se você tentou fazer isso, você usou a funcionalidade da programação.

No F#, é quase o mesmo, e fica o mais fácil possível, uma vez que você chega neste ponto:

[5; 2; -3; 1] |> List.sortBy(fun intElem -> abs intElem)

Vamos testar nossas habilidades no C# mais uma vez mapeando a lista de ints (cada número será aumentado em 3).

Mais uma vez, a maioria de vocês que se saiu bem usando LINQ ou outra programação funcional que o C# permite, é assim que funcional no F#:

[5; 2; -3; 1] |> List.map(fun x-> x * x * x)

Outro teste para o poder do nosso C# (ou Java) será tentar filtrar essa lista para ints que retornam 0 quando divididas por 2. No F#, é fácil assim:

[5; 2; -3; 1] |> List.filter(fun x -> x % 2 = 0)

Esses foram apenas alguns exemplos sobre o F# e sua usabilidade. Espero que ajude você a compreender a sintaxe, e mais importante – que ajude você a pensar em programação funcional.

Falando nisso, como podemos esquecer o imortal primeiro programa: “Hello World!” ?

printfn "Hello World!"

Texto original disponível em http://www.devaffair.com/2011/01/first-steps-in-f-sharp.html

Fonte: IMasters

JSON + Spring

É possível trabalhar com JSON e Spring. Você pode produzir dados em formato JSON dos controllers do framework, facilitando a manipulação da informação na página.

Mas como fazer isso?

Para isso, utilizamos a lib json-lib-ext-spring. Existem outras alternativas (biblioteca/lib), mas particularmente achei esse mais fácil e menos trabalhosa. Não esqueça de fazer o download da Json-lib e suas dependências.

Após o donwload e adição no buildPath do projeto, apenas é preciso fazer algumas pequenas modificações:

A primeira é acrescentar um arquivo chamado views.xml ao diretório do WEB-INF com o seguinte conteúdo:

O segundo é adicionar o conteúdo seguinte ao arquivo de configuração do Spring:

Lembre-se de setar uma ordem se você estiver utilizando algum outro view resolver.

Com essas alterações efetuadas, basta utilizar “jsonView” como o viewname e o model será convertido para json quando voltar para o cliente:

Fonte: Loiane Groner

O desenvolvimento ágil funciona em projetos de hardware?

Vários profissionais de TI tem trazido à tona recentemente a questão da aplicação das práticas ágeis no desenvolvimento de hardware. Nil Johnson escreveu um artigo na Electronic Engineering Times (EETimes): Desenvolvimento ágil de hardware – sem sentido ou necessidade?

Ele colocou a questão:

Deve haver um debate quando se trata de aplicar o Agile no desenvolvimento de hardware? Deveriam os valores e princípios que guiam as equipes ágeis de software também guiar os times que desenvolvem para sistema operacional (System on Chip teams) ; ou as diferenças entre estas duas disciplinas seria muito grande?

Ele continua com uma discussão sobre os valores do Manifesto Ágil e como estes valores formam a base da abordagem ágil no desenvolvimento de software. Ele coloca a questão – Poderia o mesmo funcionar para o desenvolvimento de hardware? – e comenta:

Para qualquer um que vê o desenvolvimento de hardware como um processo criativo, é difícil negar que os valores do manifesto são diretamente aplicados. Mas apenas considerar um conjunto de valores não é suficiente. De certo modo, valores abstratos precisam se traduzir na prática. Felizmente, times de software têm criado práticas que abordam os valores ágeis e muitas delas podem ser aplicadas diretamente também no desenvolvimento de hardware.

Ele reconhece as diferenças entre as abordagens do desenvolvimento de software e de hardware encorajando os times de hardware a abraçarem as práticas ágeis. Ele usa a prática do continuous delivery (entrega contínua) como um exemplo:

Uma prática de destaque é aquela de implantação rápida e contínua aos clientes. Para muitos times ágeis de software, implantação contínua é absolutamente crítico para o sucesso. Infelizmente, sua aplicabilidade no desenvolvimento de hardware – ou a falta dela – tende a ser usado para desacreditar o Agile totalmente. Para desenvolvimento ASIC em particular, implantação contínua não é realista; mas uma prática não ser realista não deve ser motivo de descrédito do conjunto de práticas. Nenhum time ágil de software realiza todas as práticas ao pé da letra; logo não se pode esperar o mesmo de um time de desenvolvimento de hardware.

Ele conclui com um pedido de mudança no foco das organizações de hardware:

Mudanças acontecem no desenvolvimento de hardware. Independentemente se são mudanças nas especificações, na rotatividade de funcionários, na dinânica do time ou novas tecnologias. Não há como evitar isso. As equipes que deixarem de lado os conceitos de Dilbert e as políticas internas para uma forma mais apurada e uma visão mais humana do desenvolvimento de hardware, retratada pelo manifesto, vai fazer desta mudança uma vantagem. Aos times que não se abrirem a esta mudança, irá restar o exercício fútil de tentar encaixar o “quadrado” dos tradicionais processos bem definidos no “buraco redondo” que é o desenvolvimento de hardware atual.

Larry Maccherone escreveu recentemente algo similar sobre as As 10 questões principais sobre quando usar Agile em projetos de hardware.

Ele elenca uma lista de questões e respostas a fim de auxiliar nas decisões sobre a aplicação de abordagens ágeis em projetos de hardware:

  1. As práticas e processos ágeis são efetivos na condução de projetos que não são de software (firmware, eletrônicos, mecânicos, etc.)?
  2. Quais ajustes são necessários no framework de processo Scrum para funcionar bem para estes projetos?
  3. Quais ajustes são necessários em nossas expectativas sobre funcionalidades comerciais mínimas, design emergente e definição de Scrum?
  4. Quais ajustes em nossas expectativas são necessárias acerca de histórias?
  5. Como fica a questão de priorizar histórias estritamente pelo valor gerado ao usuário final?
  6. Deveriam as histórias de usuário ser nossa única ferramenta de gerenciamento de requisitos?
  7. Se histórias de usuário não são nem requisitos oficiais do Scrum, então porque não devemos usar somente nossas práticas tradicionais de requisitos?
  8. O que fazer quando precisamos enviar um protótipo ao fornecedor e não é possível ser feito dentro de uma iteração?
  9. O que fazer com dependências e analise do caminho crítico?
  10. Talvez não precisemos da analise contínua do caminho crítico, mas ainda temos especialistas que não são dedicados permanentemente ao time. Como lidar com isso?

Para cada questão que ele lista uma resposta curta é dada seguida de uma discussão de abordagens práticas para resolver as potenciais incompatibilidades e como endereçá-las.

As práticas ágeis poderiam ser usadas no desenvolvimento de hardware? Quais mudanças seriam necessárias fazê-las funcionar neste contexto?

H4Android – primeiro contato com o framework

Desenvolvi um framework para orm no Android (é eu sei já existem alguns muito bons por sinal, so que no meus projetos eu buscava soluções o menos intrusivas possível e terminei chegando à conclusão de que era melhor eu desenvolver minha propria solução.).

Com o h4Android você não precisa extender suas classes de nenhuma interface, nem seguir “receita de bolo”, você simplemente cria suas classes no estilo POJO e usa as anotações.

Vamos ao tutorial:

Objetivo

Neste tutorial tenho o intuito de apresentar o usuário a uma simples utilização do framework para criar uma base de forma dinâmica baseado no modelo mapeado, bem como um pequeno exemplo de persistência baseado num objeto pertencente à uma classe mapeada.

Crie um novo projeto Android no Eclipseb

  • Informe o nome do projeto como testh4a.
  • Informe a versão que deseja utilizar Android 2.2.
  • Informe o nome do pacote br.org.h4a.test, neste ponto você já pode finalizar a criação do projeto;

Acesse a página do projeto no em http://code.google.com/p/h4android/, vá na aba Downloads e baixe o arquivo h4android_2_2-0.0.0.1.jar. Salve numa pasta de sua preferência.

De posse da biblioteca h4android_2_2 selecione seu projeto clique no botão direito do mouse e selecione a opção propriedades, selecione a opção Java Build Path, na aba Libraries clique em Add External JARs… localize a biblioteca h4android_2_2, em seguida clique no botão OK.

Bem neste ponto sua aplicação já está apta a utilizar o framework. Vamos lá então:

Crie um pacote qualquer no seu projeto para inserir as classes que devem ser mapeadas como entidade no banco de dados, eu criei um pacote com o seguinte nome br.org.h4a.test.model.

Dentro deste pacote vamos uma classe para utilizar no nosso exemplo. Crie a classe Contato com o seguinte conteúdo

package br.org.h4a.test.model;

public class Contato {

    private Integer id;
    private Integer version;
    private String nome;
    private String telefone;
    private String celular;
    private String email;

}

Assim que concluirmos o mapeamento desta classe não esqueça de criar os métodos get e set de cada atributo.

Vamos ao mapeamento então:

package br.org.h4a.test.model;

@Entity
@Table("TBL_CONTATO_")
public class Contato {

    @Id
    private Integer id;
    @Version
    private Integer version;
    @Column(name = "_NOME", length = 50, allowNulls = false, typeColumn = TypeColumn.VARCHAR)
    private String nome;
    @Column(name = "_TELEFONE", length = 14, allowNulls = false, typeColumn = TypeColumn.VARCHAR)
    private String telefone;
    @Column(name = "_CELULAR", length = 14, typeColumn = TypeColumn.VARCHAR)
    private String celular;
    @Column(name = "_EMAIL")
    private String email;

}

A explicação detalhada de cada anotação esta no documento na página do projeto.

Bem, agora basta criar os métodos get e set dos atributos.

Agora vamos por o h4Android para funcionar, iremos fazer uma chamada simples para inserir um objeto do tipo Contato.

Abra a classe Testh4aActivity esta é a activity principal da aplicação (aliás a única!!). Logo após a linha que contem o código setContentView, vamos começar os testes do framework.

Digite as seguintes linhas:

        //**********************************************************************
        PersistenceManagerA22 pm = null;
        List<String> classes = new ArrayList<String>();
        classes.add("br.org.h4a.test.model.Contato");
        try {
            pm = new PersistenceManagerA22(
            /*contexto para conexão*/         this,
            /*nome para a base de dados*/     "base_da_aplicacao_testh4a.db",
            /*versao da base de dados*/       1000,
            /*lista string com as entidades*/ classes ,
            /*modo de conexão do android*/    Context.MODE_PRIVATE,
            /*modo de conexao do framework*/  ModelBeavior.RENEW,
            /*habilita o log do framework*/   1
                                          );
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        //**********************************************************************

Bem a partir deste ponto podemos simplesmente criar um objeto do tipo Contato setar algumas informações e usar o método insert do PersistenceManagerA22 pm.

Inclua em seguida o seguinte trecho de código:

        Contato contato = new Contato();
        contato.setVersion(1000);
        contato.setNome("Carlos Timoshenko");
        contato.setTelefone("85 0000 0000");
        contato.setEmail("carlostimoshenkorodrigueslopes@gmail.com");

        // Neste ponto quando o framework tentar inserir o objeto contato, será
        // detectado que a base ainda nao existe e h4android ira gerar o ddl da
        // base e gerar a mesma do "zero".
        // Como o log esta ativado poderemos ver o feedback do framework criando
        // as tabelas e inserindo um objeto do tipo Contato
        pm.insert(contato);
        pm.close();

Bem agora é só por a aplicação para rodar e acompanhar o LogCat no Eclipse mostrando as mensagens do h4Android.

Quando você por sua aplicação para rodar o h4android tentará persistir um objeto do tipo Contato, como a base de dados não existe então o framework gera o DDL do seu banco e cria para você, além de inserir o objeto de forma transparente.

Você pode copiar esta banco de dados SQLite que foi criado no emulador para o seu pc e acessar diretamente pelo console usando o cliente do próprio SQLite o sqlite3 e dar um “select * from TBL_CONTATO_;” para confirmar o objeto inserido.

Bem espero que esta ferramenta lhes seja útil, adianto que a mesma se encontra em uso pois atende ao basico de um crud, porém ja estou desenvolvendo novas funcionalidades. Coloco-em à disposição para eventuais dúvidas.

Boa tarde.

Fonte: Timoshenko/PortalAndroid

JQuery 1.7

A última versão do framework JavaScript jQuery, versão 1.7, trás a maneira fácil para desenvolvimento com JavaScript. O uso da nova API é recomendada, porém os antigos métodos continuarão funcionando por um período mínimo.

Foi aprimorado o desempenho na manipulação de eventos delegados; esta mudança é baseada no exame do código cruzado do Code Search da Google e através de observação de como os seletores são usados. Onde foi otimizado os eventos delegados na metade do tempo em comparação ao jQuery 1.6.4.

Outras mudanças considerável foi um desempenho melhor para o HTML5 para os browsers IE6, IE7 e IE8, animações com comportamento mais intuitivo, suporte a API Asynchronus Module Definition (AMD API), melhorias ao jQuery.Deferred e a adição da função jQuery.isNumeric().

Os desenvolvedores também removeram as propriedades event.layerX e event.layerY e os metódos não documentados jQuery.isNaN() e jQuery.event.proxy().

Download no link abaixo:

Fonte: Alex/Bitmasters

Google abre código do framework de teste unitário para Javascript

No blog do Google sobre open source, a empresa anunciou o lançamento do JS Test – o framework de teste unitário para javascript que é usado internamente – como um projeto open source. Os testes são executados na engine V8 do Google, o mesmo mecanismo open source usado no navegador do Google Chrome. No desenvolvimento do JS Test, os criadores do framework foram inspirados pelo googletest, um framework open source para escrever testes unitários em C++.

Aaron Jacobs, engenheiro do Google, diz que o JS Test tem uma inicialização e um tempo de execução muito rápidos e que não precisa de um navegador para ser executado. É possível usar um executor de testes em um navegador e ele pode simplesmente ser atualizado quando ocorram mudanças no código do JavaScript. O JS Test também contém um framework embutido para testes isolados de objetos de teste. Seu estilo e sua semântica também são baseadas no googletest.

O site do projeto aponta que a ferramenta não pode ser facilmente usada para testar códigos com funções DOM (Document Object Model), que limita o uso do JS Test para aplicações de web clássicas. Mas a ferramenta parece funcionar bem para códigos que não dependem do DOM e para funções específicas de navegadores, como o window e o document. Por enquanto, ele pode ser usado no servidor e no console de aplicações baseadas no framework server-side Node.js.

A versão mais recente do JS Test é a 1.0.4, e está hospedada no Google Code.

Fonte originalmente publicada em: TheH

Fonte: IMaster