Image Image Image Image Image
Scroll to Top

Topo

Open Source

SWX Labs 06 – Python

Em 17, fev 2014 | Sem Comentários | Em Blog, Código, Destaques, Open Source, Python, SWX Labs | Por Mike Lopes

capa01

No SWX Labs 06 Mike, Vinicius e Tássio conversam com Rodrigo Amaral sobre Python.

Como surgiu a linguagem, qual sua evolução, diferenciais, onde ela é aplicada e como funciona a comunidade que divulga e dá suporte a uma das linguagens de programação que mais cresce e se credencia a ser o Java do futuro.

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

Temas abordados

  • História do Python
  • Particularidades da Sintaxe
  • Ferramentas e aplicações
  • Mercado de trabalho
  • Comunidade e eventos sobre Python

Links

2º GDG Aracaju: Aplicações web com Python e Google App Engine

gdg-aju-python

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

Tags | , , ,

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

 

Tags | , , , ,

Criando uma aplicação com o qooxdoo

Em 09, jul 2012 | Sem Comentários | Em Código, JavaScript, Open Source | Por eloi

O qooxdoo é um framework javascript universal usado para criar aplicações interativas, aplicativos para dispositivos móveis, aplicações web single-page, entre outros.

Irei repassar aqui um tutorial da própria qooxdoo para criar uma pequena aplicação web single-page contendo um cliente do twitter onde o usuário possa ler tweets públicos e poder postar tweets também.

No tutorial estarei utilizando o windows 7.

Primeiro passo é baixar o python para poder usar a poderosa ferramenta de gerar aplicações.

Link: http://www.activestate.com/activepython/downloads

Agora é só baixar a SDK do qooxdoo.

Link: http://downloads.sourceforge.net/qooxdoo/qooxdoo-2.0.1-sdk.zip

Instale o python, após a instalação extraia a sdk e coloque em uma pasta de sua preferência, aqui coloquei em C:\qooxdoo-2.0.1-sdk. Antes de começarmos a criar nossa aplicação vamos colocar o python na lista de variáveis de ambiente do windows.

Abra o cmd e digite o comando set PATH=C:\Python27; %PATH% sem aspas, onde C:\Python27 é o diretório de instalação do python.

Para criar uma aplicação é muito simples basta rodar o script create-application.py localizado em tool/bin na pasta da SDK, ainda no cmd digite: C:\qooxdoo-2.0.1-sdk\tool\bin\create-application.py –name=twitter

Isto irá criar uma aplicação chamada twitter contendo toda a estrutura de diretórios e configurações necessárias para o funcionamento da mesma, agora basta executar o comando cd twitter e entrar na pasta da aplicação agora digitando o comando generate.py para gerar os scripts de sua aplicação.

Depois de gerar os scripts, crie na pasta source/class/twitter um arquivo chamado MainWindow.js e dentro deste arquivo escreva o seguinte código.

qx.Class.define("twitter.MainWindow",
{
  extend : qx.ui.window.Window,

    construct : function()
    {
      this.base(arguments, "twitter");
    }
});

O que acabamos de fazer com esse código foi definir uma classe chamada “twitter.MainWindow” que extende da classe Window do qooxdo, o construtor da classe sobrescreve o construtor da super-classe  passando como parâmetro o título da janela, no caso “twitter”. Salve este arquivo  e abra o Application.js e abaixo do bloco de comentário coloque o seguinte código.

var main = new twitter.MainWindow();
main.open();

Nós apenas instânciamos nossa classe MainWindow e executamos o método open. Antes de testarmos nossa aplicação no navegador devemos gerar mais uma vez os scripts, já que estamos utilizando a classe Window do qooxdoo como dependência, então execute mais uma vez o comando generate.py no cmd e abra o arquivo index.html para visulaizar a aplicação no navegador. Você deve ver algo parecido com isto:

Vamos agora fazer algumas alterações na interface gráfica da nossa janela, ainda no Application.js acrescente este código:

main.moveTo(50, 30);

movemos nossa janela para uma nova localização. Voltando agora para o arquivo MainWindow.js coloque o seguinte código no construtor da janela:

//Esconder os botões da janela
this.setShowClose(false);
this.setShowMaximize(false);
this.setShowMinimize(false);

// ajustar o tamanho da janela
this.setWidth(250);
this.setHeight(300);

Atualize a página e veja as mudanças. Abaixo coloque o seguinte código:

// add o layout
var layout = new qx.ui.layout.Grid(0, 0);
this.setLayout(layout);

// toolbar
var toolbar = new qx.ui.toolbar.ToolBar();
this.add(toolbar, {row: 0, column: 0, colSpan: 2});

// lista
var list = new qx.ui.form.List();
this.add(list, {row: 1, column: 0, colSpan: 2});

this.setContentPadding(0);
layout.setRowFlex(1, 1);
layout.setColumnFlex(0, 1);

// Botão recarregar
var reloadButton = new qx.ui.toolbar.Button("Recarregar");
toolbar.add(reloadButton);

// textarea
var textarea = new qx.ui.form.TextArea();
this.add(textarea, {row: 2, column: 0});

// Botão postar
var postButton = new qx.ui.form.Button("Postar");
this.add(postButton, {row: 2, column: 1});

reloadButton.setToolTipText("Recarregar os tweets.");
textarea.setPlaceholder("Digite sua mensagem aqui...");
postButton.setToolTipText("´");

Na linha 2 criamos um layout do tipo grid e setamos ele em nossa janela, na linha 6 criamos uma toolbar e adicionamos ela a nossa janela já preparada para receber os componentes e ajusta-los em forma de grade, mesma coisa com a lista da linha 10. Na linha 13 setamos o padding da janela no valor 0, já as linhas 14 e 15 servem para deixar a lista flexível. Na linha 18 é adicionado um botão na toolbar para recarregar os tweets e nas linhas seguintes são adicionados um textarea e outro botão à janela, nas linhas finais são dados alguns toques para finalizar a nossa janela como mostrar pra que serve o botão quando o mouse fica sobre ele.

No final do construtor acrescente este código:

event : 
 {
	"reload" : "qx.event.type.Event",
	"post"   : "qx.event.type.Data"
 }

E abaixo de postButton.setToolTipText(“Poste esta mensagem no twitter.”); coloque:

reloadButton.addListener("execute", function() {
	this.fireEvent("reload");
}, this);
postButton.addListener("execute", function() {
	this.fireDataEvent("post", textarea.getValue());
}, this);

Até agora nosso arquivo MainWindow.js está assim:

qx.Class.define("twitter.MainWindow",
{
  extend : qx.ui.window.Window,

  construct : function()
  {
    this.base(arguments, "twitter", "twitter/t_small-c.png");

    // hide the window buttons
    this.setShowClose(false);
    this.setShowMaximize(false);
    this.setShowMinimize(false);

    // adjust size
    this.setWidth(250);
    this.setHeight(300);

    // add the layout
    var layout = new qx.ui.layout.Grid(0, 0);
    layout.setRowFlex(1, 1);
    layout.setColumnFlex(0, 1);
    this.setLayout(layout);
    this.setContentPadding(0);

    // toolbar
    var toolbar = new qx.ui.toolbar.ToolBar();
    this.add(toolbar, {row: 0, column: 0, colSpan: 2});

    // reload button
    var reloadButton = new qx.ui.toolbar.Button("Reload");
    toolbar.add(reloadButton);
    reloadButton.setToolTipText("Reload the tweets.");
    reloadButton.addListener("execute", function() {
      this.fireEvent("reload");
    }, this);

    // list
    var list = new qx.ui.form.List();
    this.add(list, {row: 1, column: 0, colSpan: 2});

    // textarea
    var textarea = new qx.ui.form.TextArea();
    this.add(textarea, {row: 2, column: 0});
    textarea.setPlaceholder("Enter your message here...");
    textarea.addListener("input", function(e) {
      var value = e.getData();
      postButton.setEnabled(value.length < 140 && value.length > 0);
    }, this);

    // post button
    var postButton = new qx.ui.form.Button("Post");
    this.add(postButton, {row: 2, column: 1});
    postButton.setToolTipText("Post this message on twitter.");
    postButton.addListener("execute", function() {
      this.fireDataEvent("post", textarea.getValue());
    }, this);
    postButton.setWidth(60);
    postButton.setEnabled(false);
  },

  events :
  {
    "reload" : "qx.event.type.Event",
    "post" : "qx.event.type.Data"
  }
});

Vamos agora para nosso arquivo Application.js e escrever este código:

main.addListener("reload", function() {
	this.debug("reload");
}, this);

main.addListener("post", function(e) {
	this.debug("post: " + e.getData());
}, this);

Até agora nosso arquivo Application.js está desta forma:

/* ************************************************************************

Copyright:

License:

Authors:

************************************************************************ */

/* ************************************************************************

#asset(twitter/*)

************************************************************************ */

/**
* This is the main application class of your custom application "twitter"
*/
qx.Class.define("twitter.Application",
{
  extend : qx.application.Standalone,

  /*
*****************************************************************************
MEMBERS
*****************************************************************************
*/

  members :
  {
    /**
* This method contains the initial application code and gets called
* during startup of the application
*
* @lint ignoreDeprecated(alert)
*/
    main : function()
    {
      // Call super class
      this.base(arguments);

      // Enable logging in debug variant
      if (qx.core.Environment.get("qx.debug"))
      {
        // support native logging capabilities, e.g. Firebug for Firefox
        qx.log.appender.Native;
        // support additional cross-browser console. Press F7 to toggle visibility
        qx.log.appender.Console;
      }

      /*
-------------------------------------------------------------------------
Below is your actual application code...
-------------------------------------------------------------------------
*/

      var main = new twitter.MainWindow();
      main.moveTo(50, 30);
      main.open();

      main.addListener("reload", function() {
        this.debug("reload");
      }, this);

      main.addListener("post", function(e) {
        this.debug("post: " + e.getData());
      }, this);
    }
  }
});

Gere mais uma vez os scripts e veja como está a aplicação, ela deve está parecida com esta imagem:

Agora vamos dar início a interação com o twitter, crie outro arquivo na mesma pasta que Application.js e MainWindow.js chamado de TwitterService e inicialmente escreva o seguinte código:

qx.Class.define("twitter.TwitterService",
{
  extend : qx.core.Object,
  members :
  {
  }
});

Diferente da classe MainWindow, esta não precisa extender de uma classe complexa como a Window, ela extende da classe Object que é uma classe simples. Acrescente este código antes de members:

properties : {
    tweets : {
      nullable: true,
      event: "changeTweets"
    }
  },

  events : {
    "postOk" : "qx.event.type.Event"
  },

E dentro de members o seguinte código:

__store : null,

    fetchTweets : function() {
      if (this.__store == null) {
        var url = "http://api.twitter.com/1/statuses/public_timeline.json";
        this.__store = new qx.data.store.Jsonp(url, null, "callback");
        this.__store.bind("model", this, "tweets");
      } else {
        this.__store.reload();
      }
    },

    post : function(message)
      window.open("http://twitter.com/?status=" + encodeURIComponent(message));
    }
  }

Aqui em cima criamos uma propriedade chamada tweets, que pode ser nulo e possui um evento chamado “changeTweets“. Criamos também um evento chamdo “postOk” do tipo “qx.event.type.Event” além dos membros, um atributo privado chamado “__store” (dois “__” fazem com que o atributo torne-se privado) e dois métodos o fetchTweets e o post, fetchTweets responsável pela captura de tweets públicos do twitter e post por postar o conteúdo no twitter.

Vamos voltar agora ao nosso arquivo Application.js e criar uma instância da nossa classe TwitterService e digite o seguinte código:

var service = new twitter.TwitterService();

E troque este trecho de código:

main.addListener("reload", function() {
	this.debug("reload");
}, this);

Por esse:

main.addListener("reload", function() {
  service.fetchTweets();
}, this);

E este:

main.addListener("post", function(e) {
	this.debug("post: " + e.getData());
}, this);

Por este:

main.addListener("post", function(e) {
        service.post(e.getData());
}, this);

Vamos agora para o arquivo MainWindow.js e criar um acessor para a lista, então troque onde tem var list = new qx.ui.form.List();por:

this.__list = new qx.ui.form.List();

E onde estiver list trocar por this.__list, faça o mesmo para textarea. Ainda no mesmo arquivo abaixo de events crie dois membros o __list e o __textarea ficando assim:

events :
  {
    "reload" : "qx.event.type.Event",
    "post" : "qx.event.type.Data"
  },

  members : {
    __list : null,
    __textarea : null,

Ainda dentro de members crie duas funções a getList e a clearPostMessage com o seguinte conteúdo:

getList : function() {
      return this.__list;
    },

    clearPostMessage : function() {
      this.__textarea.setValue(null);
    }

O nosso arquivo MainWindow agora está assim:

qx.Class.define("twitter.MainWindow",
{
  extend : qx.ui.window.Window,

  construct : function()
  {
    this.base(arguments, "twitter", "twitter/t_small-c.png");

    // hide the window buttons
    this.setShowClose(false);
    this.setShowMaximize(false);
    this.setShowMinimize(false);

    // adjust size
    this.setWidth(250);
    this.setHeight(300);

    // add the layout
    var layout = new qx.ui.layout.Grid(0, 0);
    layout.setRowFlex(1, 1);
    layout.setColumnFlex(0, 1);
    this.setLayout(layout);
    this.setContentPadding(0);

    // toolbar
    var toolbar = new qx.ui.toolbar.ToolBar();
    this.add(toolbar, {row: 0, column: 0, colSpan: 2});

    // reload button
    var reloadButton = new qx.ui.toolbar.Button("Reload");
    toolbar.add(reloadButton);
    reloadButton.setToolTipText("Reload the tweets.");
    reloadButton.addListener("execute", function() {
      this.fireEvent("reload");
    }, this);

    // list
    this.__list = new qx.ui.form.List();
    this.add(this.__list, {row: 1, column: 0, colSpan: 2});

    // textarea
    this.__textarea = new qx.ui.form.TextArea();
    this.add(this.__textarea, {row: 2, column: 0});
    this.__textarea.setPlaceholder("Enter your message here...");
    this.__textarea.addListener("input", function(e) {
      var value = e.getData();
      postButton.setEnabled(value.length < 140 && value.length > 0);
    }, this);

    // post button
    var postButton = new qx.ui.form.Button("Post");
    this.add(postButton, {row: 2, column: 1});
    postButton.setToolTipText("Post this message on twitter.");
    postButton.addListener("execute", function() {
      this.fireDataEvent("post", this.__textarea.getValue());
    }, this);
    postButton.setWidth(60);
    postButton.setEnabled(false);
  },

  events :
  {
    "reload" : "qx.event.type.Event",
    "post" : "qx.event.type.Data"
  },

  members : {
    __list : null,
    __textarea : null,

    getList : function() {
      return this.__list;
    },

    clearPostMessage : function() {
      this.__textarea.setValue(null);
    }
  }
});

Vamos voltar agora para o Application.js e criar um controle para nossa lista com o seguinte código:

var controller = new qx.data.controller.List(null, main.getList());
      controller.setLabelPath("text");
      controller.setIconPath("user.profile_image_url");
      controller.setDelegate({
        configureItem : function(item) {
          item.getChildControl("icon").setWidth(48);
          item.getChildControl("icon").setHeight(48);
          item.getChildControl("icon").setScale(true);
          item.setRich(true);
        }
      });

Agora vamos chamar o método bind para vincular o controle com o modelo vindo do twitter e chamar os tweets quando iniciar a aplicação:

service.bind("tweets", controller, "model");
service.fetchTweets();

Gere novamente os scripts e recarregue a página e teste nosso aplicativo funcionando.

Na hora de postar você será redirecionado para o site do twitter para autenticação, pois é muito complicado fazer a autenticação pelo aplicativo, pois o twitter só usa o OAuth para autenticar os usuários. Para baixar o projeto clique aqui.

Fonte: qooxdoo Docs

 

28

jan
2012

Sem Comentários

Em Blog
Open Source

Por Allison

jSlater, framework de painel JavaScript, agora é open source

Em 28, jan 2012 | Sem Comentários | Em Blog, Open Source | Por Allison

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.

Tags | , , ,

11

dez
2011

Sem Comentários

Em Blog
Open Source

Por Allison

HP decide transformar o webOS em uma plataforma open source

Em 11, dez 2011 | Sem Comentários | Em Blog, Open Source | Por Allison

Depois de muita indecisão, a HP bateu o martelo em relação ao futuro do webOS: ele será oferecido à comunidade open source. A empresa ainda estará envolvida com a plataforma para ajudar os desenvolvedores e auxiliar na governança para o webOS.

Em um press release, Meg Whitman, CEO da HP, afirmou que o webOS é a única plataforma concebida do zero para dispositivos móveis, conectada à nuvem e escalável. “Ao tomar essa decisão, a HP permite que a criatividade da comunidade open source avance para uma nova gerações de apps e de dispositivos”, acrescentou.

A HP gastou US$ 1.2 bilhões para adquirir a Palm e os recursos do webOS em abril de 2010, mas o investimento não valeu a pena. Levou mais de um ano para a empresa esquematizar e construir o tablet HP TouchPad com webOS, que nunca foi considerado um sucesso. Pelo menos não até o seu preço ser drasticamente reduzido a US$ 99, quando a HP decidiu deixar o setor.

Com o sistema operacional se tornando open source, pode haver um estímulo no mercado para a fabricação de telefones e tablets com ele, já que não será necessária uma taxa de licenciamento. Isso é parecido com o Android, mas o desafio para o webOS é o ecossistema. O Android se tornou a plataforma mais usada em smartphones até o momento, e os desenvolvedores estão construindo apps para ele, assim como para dispositivos com iOS. Nesse sentido, o ecossistema do webOS não é tão forte quanto os dos seus concorrentes.

Com informações de GigaOm

Fonte: IMasters

Tags | , , , ,

IcedTea, Harmony, IKVM e mais: altos e baixos do Java Open Source

Em 06, dez 2011 | Sem Comentários | Em Arquitetura, Blog, Java, Open Source | Por Allison

Este artigo traz um panorama de projetos open source relacionados com o coração da plataforma Java, e em que tem havido extremos de altos e baixos. Em outubro, o IcedTea liberou sua versão 2.0, baseada no OpenJDK 7, que já está disponível como o Java 7 oficial do Fedora e do Ubuntu Linux; em novembro a Apache anunciou que o Harmony estava sendo rebaixado para o “sótão” da Fundação. São dois exemplos (e dois extremos) de projetos trazendo novidades que poderão afetar o futuro da tecnologia Java, mesmo sem o apoio de gigantes como Oracle e IBM.

IcedTea

Quando a Sun liberou em 2007 os fontes da sua JVM e sua biblioteca de classes, criando o projeto OpenJDK, atual implementação de referência do Java 7, o resultado não era imediatamente usável pela comunidade open source, pois alguns componentes licenciados de terceiros não puderam ser abertos naquele momento. Exemplos de APIs que não foram incluídas no código inicial do OpenJDK são as de gerência de fontes tipográficas e de interação com dispositivos de som. Sem falar de complementos indispensáveis para algumas aplicações, como o plugin web para Applets e o Java Web Start, que embora sejam parte do produto da Sun e Oracle há tempos, cobrem funcionalidades não-padronizadas como parte do Java SE.

Para remediar esses problemas, a comunidade open source criou, com patrocínio da Red Hat, o projeto IcedTea. O objetivo era substituir os componentes proprietários necessários para compilação e execução do OpenJDK, pelos equivalentes em outros projetos open source, especialmente o projeto GNU Classpath.

Na verdade, já havia conversas entre membros importantes da comunidade open source e da Sun bem antes do lançamento do OpenJDK, e não foi acidente a opção da Sun pela licença GPL, em vez das licenças usadas no Glassfish e no extinto Open Solaris. O objetivo era permitir a mistura de código com o ecossistema do GNU Classpath, baseado na GPL.

Já há alguns anos, as distribuições do Linux incluem binários certificados do IcedTea, mas que são distribuídos usando o nome OpenJDK como parte de um acordo com a Sun para acesso ao TCK, o kit de testes de compatibilidade do Java.

Algumas distribuições ofereciam como alternativa o Java proprietário da Sun, empacotado nos repositórios “não-livres”, usando a licença DLJ (Operating System Distribution License for Java). Mas a DLJ foi descontinuada pela Oracle com a liberação do Java 7, não apenas para o novo Java mas também para as versões anteriores. Por isso o IcedTea se tornou o único Java certificado a ser fornecido como parte dos sistemas Fedora, Ubuntu e Debian, além de se tornar também o preferencial para uso em distribuições comerciais com RHEL e SuSE.

O escopo do projeto IcedTea aumentou desde a sua criação. Ele implementou melhorias sobre o OpenJDK, para melhor compatibilidade com o Linux, por exemplo o suporte ao PulseAudio para multimídia; e evoluiu para uso de JVMs alternativas, como a JamVM, entrando no lugar do HotSpot do OpenJDK original.

Ampliando o alcance do OpenJDK

A maior contribuição do IcedTea para o OpenJDK provavelmente foi os projetos Zero e Shark. O Zero é um interpretador genérico de alta performance, que torna o OpenJDK viável em várias plataformas embarcadas, em que o custo de memória e bateria de um compilador JIT seria proibitivo.

Já o Shark utiliza a infraestrutura do LLVM para criar um compilador JIT portável para múltiplas arquiteturas de CPU, evitando a necessidade de se escrever um novo JIT para cada arquitetura de processador. Graças a estes projetos o OpenJDK vem se tornando a implementação do Java preferencial em algumas CPUs populares em plataformas voltadas para a computação embarcadas, como ARM e MIPS.

Note que o IcedTea não é um fork do OpenJDK. Alguns dos seus contribuidores estão no Community Board do OpenJDK e vários dos patches do projeto migraram para o OpenJDK e se tornaram parte do Java 7 oficial.

Outra contribuição importante do IcedTea é um processo de compilação mais simples para o OpenJDK, reduzindo a barreira de entrada para potenciais contribuidores. O projeto OpenJDK não fornece binários para nenhuma plataforma, somente fontes. O JDK fornecido pela Oracle à partir dos fontes do OpenJDK usa uma licença proprietária. Mas, graças ao processo simplificado do IcedTea hoje é possível baixar, sob uma licença open source, binários para Windows no site do Open SCG, que é o mesmo grupo responsável pelo porte nativo do PostgreSQL para Windows.

A certificação do Java SE é realizada sobre binários, não sobre fontes, e os binários do IcedTea inclusos no Ubuntu, Fedora e derivados (como RHEL e CentOS) são certificados desde 2009. Mas os binários do OpenJDK 7/IcedTea 2 inclusos nas distribuições do Linux não são certificados ainda, e nem os fornecidos pelo OpenSCG para Windows. Ambas as comunidades estão trabalhando no processo, e estão em busca de patrocinadores.

Ainda há espaço para outras JVMs open source?

A criação do projeto OpenJDK diminuiu o incentivo a continuidade de vários projetos de JVMs open source. O SableVM foi uma das vítimas. O desenvolvimento do GNU Classpath, que fornecia a biblioteca de classes do Java SE para a maioria destes projetos, ficou congelado no Java SE 5, e o venerável Kaffe apenas recentemente voltou a ter atividade, sendo transferido para o Github.

Poderia ser argumentado que não há mais necessidade de outros projetos de JVMs open source, uma vez que a Sun abriu sua implementação, e ainda mais agora que a Oracle oficializou o OpenJDK como a implementação de referência (RI) para o Java 7. A competição trazida por estes projetos foi benéfica porque estimulou a evolução e a abertura do JDK pela Sun, mas qual seu papel no futuro do Java?

Na época o Classpath estava chegando perto do 100% do Java SE 5 e se tornaria certificável. Com dois Javas open source plenamente funcionais (GCJ+Classpath e Apache Harmony) ficaria complicado manter restrições ao TCK do Java SE, e mais importante, o fluxo de caixa originado pelo licensiamento do JDK da Sun para fabricantes de plataformas móveis e embarcadas. A criação do OpenJDK sob licença GPL permitiu unir esforços à comunidade open source, sem abrir o TCK para projetos externos.

Por outro lado, sem projetos open source independentes, deixa-se de explorar alternativas de design para a JVM, que poderiam atender a nichos específicos ou se tornarem importantes em plataformas futuras. O fato de smartphones e tablets atuais em sua maioria ignorarem a plataforma Java SE (e também a Java ME) mostra que essas alternativas podem estar fazendo falta.

Por exemplo, o GCJ, que é parte da suite de compiladores GCC, tem a opção de gerar código nativo (que não necessita de uma JVM para executar). Era uma opção interessante para aplicações desktop e sistemas embarcados, tanto que foi utilizado pelo RHEL e pela comunidade Fedora para suportar o Eclipse e o Tomcat, antes da criação do OpenJDK. Sem falar na ampla cobertura de arquiteturas de CPU e SOs do GCC, muito superior à suportada pelo Java “oficial” na época.

As releases recentes do GCC continuam suportando o GCJ, e ele continua sendo incluído nas principais distribuições do Linux; mas, infelizmente não parece haver planos para atualizar seu suporte à linguagem Java, nem para completar o GNU Classpath ou atualizá-lo para além do Java 5.

JVMs alternativas ao OpenJDK

O OpenJDK, no entanto, não parece ter diminuído o ritmo do JikesRVM, que tem o diferencial de ser escrito quase que inteiramente em Java. Infelizmente ele não tem a pretenção de ser uma JVM para “uso real”, seu objetivo é ser uma plataforma de testes para novos algoritmos internos à JVM para projetos acadêmicos.

Dois dos projetos baseados no GNU Claspath, o JamVM e o Cacao continuam vivos. Eles colaboram com o projeto IcedTea e hoje podem utilizar a biblioteca de classes do OpenJDK em lugar do GNU Classpath, voltando assim a acompanhar a evolução da plataforma oficial. Apesar de os seus releases mais recentes terem mais de um ano, existe grande atividade nos repositórios de código do JamVM e do Cacao, e espera-se para breve novos releases que finalmente atualizarão suas respectivas JVMs para compatibilidade com as novas versões do Java.

Ambos o JamVM e o Cacao são focados em plataformas embarcadas, explorando diferentes designs para componentes da JVM, como o coletor de lixo, o interpretador de bytecodes e o compilador JIT. A comunidade do JamVM afirma, por exemplo, que é possível gerar um executável da sua JVM ocupando menos de 100 Kb.


Java no .NET

Outro projeto de JVM open source que continua vivo e pode ser interessante para alguns nichos é o IKVM, que roda dentro do CLR do .NET ou do Mono, e permite convivência “sem costuras” entre código escrito em Java e código escrito em C#, VB.Net ou outras linguagens que rodam sob o CLR.

O IKVM também permite empacotar aplicações Java como assemblies nativas do .NET. O projeto ganhou certa popularidade entre desenvolvedores que gostariam de continuar tendo acesso a bibliotecas Java em um projeto .NET. É também o projeto mais atualizado em relação aos padrões do Java, pois já oferece um release candidate com suporte ao Java 7.

Com o fim do Harmony, como fica o Android?

A DalvikVM, que é a base das aplicações Android, é baseada na biblioteca de classes do Java SE fornecida como parte do Apache Harmony. Originalmente este projeto tinha apoio da IBM, que contribuiu com a maior parte do código para a biblioteca de classes, mas quando a IBM decidiu focar seus esforços no OpenJDK, o Harmony ficou “órfão”. O projeto Harmony foi oficialmente descontinuado pela Apache Software Foundation em novembro deste ano. Ao contrário do que muitos esperavam, o Google não assumiu o projeto, mantendo o desenvolvimento do Dalvik como um fork separado, provavelmente devido ao processo aberto pela Oracle por violação de patentes.

O Dalvik não é exatamente uma JVM, pois roda seu próprio bytecode, e usa uma arquitetura interna bem diferente da usada no OpenJDK, embora semelhante ao JamVM e ao CacaoVM. O desenvolvimento das aplicações para o Dalvik é feito na linguagem Java, e os bytecodes Java são convertidos em bytecodes Dalvik. Está disponível apenas um subconjunto da API do Java SE, embora maior do que o incluso no Java ME, mas o Dalvilk não traz nada do Java oficial para celulares, sendo incompatível com MIDP ou CDC. Recursos que seriam parte do Java ME são fornecidos por APIs proprietárias para o Android, ou por acesso a serviços do Google.

A omissão do Google quanto ao Harmony dá margem a dúvidas sobre qual será o futuro do “Java” no Android:

  • O Google vai continuar evoluindo o Dalvik usando ideias do Java, de modo similar feito pela Microsoft com o .NET?
  • Ou será o HTML 5 quem poderá provocar um futuro abandono do DalvikVM e Java no Android?

Qualquer que seja o futuro do Dalvilk, ele representa uma linha que poderia ter sido incorporada ao Java oficial e que garantiria a popularidade do Java na computação móvel. A disputa entre Google e Oracle não atende aos interesses da comunidade Java, e a recente ênfase no HTML 5 mostra bem como o mercado ainda carece de uma solução para desenvolvimento interoperável entre smartphones e tablets de diferentes fornecedores.

Serviços nativos do Linux

O exemplo do Dalvik mostra que, apesar da necessidade de funcionalidades independentes de plataforma, há também necessidade de se incorporar suporte a recursos nativos. O Java 7 já foi uma evolução nessa direção, com a nova API de filesystem do NIO2 e se pode argumentar que o Eclipse deve grande parte do seu sucesso ao toolkit gráfico SWT, também baseado no acesso a recursos nativos de Windows, Unix e Mac.

Novamente vemos que a comunidade open source traz novidades neste sentido, dentro do ramo da computação embarcada. Por exemplo, o BUG System e o OpenEmbedded fazem uso de APIs Java para acesso ao desktop Gnome e o D-Bus – efetivamente colocando o Java em pé de igualdade com o código nativo, no acesso aos recursos do SO e Desktop do Linux.

Em vez de criar todo um “universo paralelo”, como feito pelo Android, estes projetos buscam maximizar a utilidade de recursos já conhecidos dos desenvolvedores em plataformas embarcadas, e abrem espaço para a plataforma Java como “linguagem de sistema” para o Linux, viabilizando o desenvolvimento de aplicações de gerência de hardware sem recorrer diretamente a código nativo.

Conclusões

Podemos ver que, apesar do foco de grandes empresas no projeto OpenJDK, ainda há vários outros projetos open source com potencial de contribuir para a evolução da plataforma, especialmente em nichos ainda negligenciados pela plataforma oficial, como o de dispositivos embarcados. Vale a pena acompanhar o amadurecimento destes projetos, pois de um deles pode sair o diferencial competitivo para os produtos da sua empresa, ou surgirem evoluções importantes para a plataforma oficial do Java.

Fonte: Fernando Lozano/InfoQ

Tags | , , , , , , , ,

23

nov
2011

Sem Comentários

Em Blog
Open Source
PHP

Por Allison

PHPSP incentiva desenvolvedores a contribuírem com open source

Em 23, nov 2011 | Sem Comentários | Em Blog, Open Source, PHP | Por Allison

O PHPSP, Grupo de Desenvolvedores PHP de São Paulo, quer aumentar a contribuição de desenvolvedores com projetos open source em PHP. Para isso, a organização criou o “Sou PHPSP”, que tem como objetivo atacar algumas “desculpas” de desenvolvedores que não contribuem e incentivar novos contribuidores.

Para os desenvolvedores que justificam não contribuir com “Não sei como, ou por onde começar” e “Não sou bom o bastante”, o grupo reuniu uma lista de projetos parceiros e material sobre como contribuir e quais contribuições são bem-vindas, além de disponibilizar responsáveis dentro do projeto para tirar dúvidas e afins.Também serão realizados eventos no modelo Hackathons, levando contribuidores “veteranos” para ajudar iniciantes a fazer o seu primeiro patch.

Além disso, o PHPSP vai premiar aqueles que decidirem ajudar o open source. Cada contribuição feita a um projeto pode ser cadastrada no sistema “#SouPHPSP” e ela representará uma chance de concorrer a diversos prêmios oferecidos pelos parceiros do PHPSP. Entre os prêmios estão Xbox, iPad, hospedagem, cursos, livros e camisas. Em breve, a organização iniciará uma segunda etapa da iniciativa com desafios-relâmpago.

Os interessados em contribuir precisam acessar o site http://sou.phpsp.org.br. Em seguida, basta escolher um projeto ou sugerir um novo, fazer a contribuição e cadastrá-la no sistema. São válidas quaisquer contribuições em projetos relacionados ao PHP.

Fonte: IMaster

Tags | , ,