Postado por Jon Arild Tørresdal, traduzido por André Pantalião em 12 Mai 2009 05:06 PM

Muitas discussões dos desenvolvedores sobre se devem usar ou aprender a ASP.NET MVC tem sido recorrente em blogs, Twitter e fóruns nas últimas semanas.  As opiniões variam de não recomendar até ao ponto de que todos os desenvolvedores deveriam aprender. InfoQ tentou resumir um pouco da recente atividade em relação a este tópico.

Rob Conerey (funcionário da Microsoft no time de ASP.NET MVC e criador do SubSonic) explica porque desenvolvedores deveriam aprender ASP.NET MVC, depois de observar questões levantadas na comunidade.

Em sua introdução ele começa descrevendo WebForms como “A Grande Mentira”:

WebForms é uma mentira. Sua abstração embrulhada em decepção coberta com molho de mentira servido em um prato cheio de diversão é um truque bem pensado. Nada que você faz com WebForms tem a ver com Web – você deixa ele fazer o trabalho para você.

Isto, amigos, é algo importante (pelo menos para mim): Você está trabalhando em uma mentira. A web não é ‘stateful’ e trabalha com esta coisa chamada HTML enviada através de fios usando outra coisa chamada HTTP – você precisa sabê-los, amá-los e senti-los nas suas veias.

Rob lista 7 razões para usar ASP.NET MVC ou em suas próprias palavras – 7 Razões Para Parar de Me Chamar De Idiota:

1. Testabilidade
2. Controle sobre HTML
3. Extensibilidade
4. Faz você pensar
5. …Diferentemente: Javascript não enche o saco
6. Aprendendo novos conceitos
7. É engraçado

E conclui que:

Ponto principal: Eu estou me divertindo novamente ao programar web e acho que é muito motivador, pelo menos para mim e para meus gatos. Ainda uma comparação, com certeza, mas acredito que um pouco mais direto. Você não tem nenhum motivo para não aprender MVC ” mas vou permitir que possa ter uma razão ou duas para você continuar com WebForms.”

Joe Brinkman (desenvolvedor em tempo integral no DotNetNuke) rapidamente seguiu com uma resposta, criticando Rob por não escolher “UMA BOA razão para aprender MVC”, e lista sua própria:

1. Vai te expor a uma arquitetura diferente
2. Você será forçado a se tornar intimamente faimilar com HTML e HTTP
3. MVC promove testes unitários
4. MVC o fará ver o quanto você ganha por lidar com WebForms

Joe conclui dizendo:

Então em resumo, você deve realmente conferir MVC.  Mas não pelas razões que Rob enumerou.  Você deve explorar MVC porque ao final você pode ter aprendido algo que o fará um programador web melhor, não importa que plataforma você escolha.

Rob e Joe basicamente concordam no mesmo, que desenvolvedores ASP.NET devem aprender ASP.NET MVC, mas discordam no porquê dos argumentos.Karl Seguin no entanto tem uma diferente opinião e pergunta “se ASP.NET é uma solução crua“?:

Ser capaz de escrever sistemas complexos de uma maneira limpa é um bom começo, mas dado onde o desenvolvimento web geralmente se encontra, e outras plataformas em específico, ASP.NET MVC larga muito atrás (Perl sendo a única que eu consigo pensar que é pior).

Há uma pequena questão que uma grande parte do problema é que este é realmente um stack VC – não há pensamento, suporte e ferramentas para o Modelo. Quando você compara as milhares de linhas que você vai acabar escrevendo para seu repositório/dal/linq/nhiberate para outros stacks MVC (que normalmente somente requerem que seus modelos herdem de uma classe), você já está em uma séria desvantagem de produtividade. Mas o real impacto é na verdade muito pior – você perde qualquer coesão de propósito através dos controllers e views. Não há maneira de gerar labels HTML de propriedades modelo, ou validação no lado do cliente.

…

Existem algumas boas notícias, e que toda esta “infraestrutura” é reutilizada, que fazem projetos como S#arp Architecture possíveis. No entanto, eu ainda estou cético que estes projetos possam realmente ter sucesso contra frameworks melhor integrados.

Jeremy D. Miller (um dos criadores do FubuMVC) lista alguns prós e contras:

CONTRAS:

“o framework MVC não é eficiente a não ser que você planeje arregaçar as mangas e produzir uma infraestrutura específica para seu projeto para preencher no “M”, atingir melhor testabilidade, sincronização de tela mais fácil, e HTML helpers mais produtivos”

…

PRÓS:

É muito fácil e direto para pegar o framework MVC pelos chifres e customizar para seu benefício.

Jeremy conclui dizendo:

Eu fico com a afirmação que o ASP.Net MVC framework, no fim das contas, é uma melhor maneira de construir aplicações web que a “abstração embrulhada em decepção coberta com molho de mentira servido em um prato cheio de diversão e um truque bem pensado,”  mas neste ponto é provavelmente uma ferramenta restrita para amigos que sejam do tipo “early adopters”

Jeffrey Palermo (atualmente escrevendo o livro “ASP.NET MVC in action”) declara que “Você não deve usar ASP.NET MVC se…”:

• Você não está muito confortável com polimorfismo
• Você não deseja escrever no topo de um framework
• Você utiliza controles de terceiros para muito da interface de usuário
• Você é contra utilizar bibliotecas open-source

Mas continua com:

O framework ASP.NET MVC é um framework facilitador.  Não é um framework que “pega na sua mão”.   Não é um framework “ASP.NET 101” .  Você tem controle total sobre tudo.  Padrões de interface de usuário no espaço da Web não são tão padronizados para que nós possamos abandonar controles para usar frameworks que trabalham de uma maneira “padrão”.   Acesso a dados alcançou este ponto onde nós sabemos que precisamos Criar, Ler, Atualizar e Apagar, cascateando persistência, lazy loading, etc.   Existe muitos mapeadores objeto-relacional (ORM) que suportam as operações comuns, e muitos desenvolvedores estão satisfeitos desistindo do controle completo sobre o acesso a dados devido a forma parecida que os ORMs líderes trabalham (Hibernate/NHibernate).

Existem é claro muitos outros que expressaram as suas opiniões, mas InfoQ acha que as acima resumem muitos dos argumentos a favor e contra de aprender/usar ASP.NET MVC.

Fonte: InfoQ

Postado por Jonathan Allen, traduzido por Felipe V. Rigo em 04 Mai 2009 11:44 AM

No PDC 2008, a Microsoft prometeu paridade entre as linguagens Visual Basic e C#. O que isso significa para o .NET 4 foi enumerado durante o keynote Lang.NET(marca de 18 minutos). Brevemente, isso é o que você pode esperar pra ver.

Novas funcionalidades para ambas as linguagens

• Interoperabilidade com Dynamic Languages (linguagens dinâmicas)
• Coo/contra-variação
• publicação de PIA não necessária

Novo para o VB 10, já disponível no C#

• Auto-implementação de propriedades
• Inicializadores de Coleções
• Declarações lambda

Novo para o C# 4, já disponível para o VB

• Parâmetros Nominados/Opcionais
• Suporte a Latebinding
• Omissão do “ref” em chamadas COM

Infelizmente, duas funcionalidades chaves não fazem parte da lista. O C# 4 não irá embarcar Literais XML e o VB não terá iteradores.

Sem mencionar algumas funcionalidades menores, mas assim mesmo necessárias como permitir estruturas em parâmetros opcionais. A inabilidade de declarar um opcional, inteiro anulável em uma função faz com que fazer um mapeamento 1-para-1 com stored procedures impossível. Isso foi demonstrado para o VB entre sessões no PDC.

Fonte: InfoQ

Essa é uma das respostas do Márcio Tierno no grupo UML-FATEC, sobre a eterna discussão sobre qual a melhor plataforma de desenvolvimento: Java ou .NET.

Sei que esse assunto de quem é melhor Java x .NET é quase como discutir sobre religião. Mas o problema sobre produtividade no desenvolvimento de software é uma questão de foco, ou melhor, o problema não é tecnológico e sim estratégico.

“Um pouco de números para tentar dar um pouco de prumo a essa discussão:

1 – 80% dos negócios do mundo rodam em cima de programas COBOL. Nem Java nem .NET vão decidir o futuro da humanidade, portanto.

2 – Nunca vi um sistema que não pudesse ser implementado em qualquer linguagem que seja. Portanto, a discussão Java x .NET não se decide na esfera técnica.

3 – Produtividade – não é criando grids para acesso direto a tabelas que se mede produtividade, mas sim no tempo total que leva para uma idéia sair da cabeça do usuário de negócios até se transformar em um sistema rodando no ambiente de produção, testado, aprovado e homologado. Numa “competição” Java x .NET, é certo que ambas as tecnologias chegariam empatadas “na margem de erro” caso se considerasse todo o ciclo de vida de um sistema.

4- Ainda em produtividade, só de 15% a 20% do tempo é gasto efetivamente em implementação. O grosso do esforço é gasto em levantamento de requisitos e testes.

Por falar em produtividade, só 30% do tempo do programador é gasto em desenvolvimento de fato, em média. O resto é perdido em debugging ou reescrevendo requisitos que foram mal-entendidos (e mal-explicados, por conseguinte). Pare e pense na sua rotina diária e veja se vc discorda desses números.

Assim, 20% X 30% = 60% do tempo total de um projeto em desenvolvimento REAL. Supondo que uma das duas tecnologias fosse 50% MAIS PRODUTIVA do que a outra (e nenhuma delas o é), o impacto final seria de 3% sobre o tempo total do projeto. Quase indetectável.

Assim, o desafio proposto perde a validade em si. Até porque ninguém vai sair “convertido” de um evento desses. Agora, um desafio de ponta a ponta, num prazo de algumas semanas, por exemplo, esse sim teria valia. Mas já não seria mais um desafio Java x .NET, mas, talvez, um desafio MDA x AMD (tipo Together) x Agile (S. Ambler), por exemplo.

4 – Decisões estratégicas – Há uns 20 anos, mais ou menos , o Natural/ADABAS ganhou um grande mercado do COBOL, porque era muuuito mais produtivo e fácil de mexer. Hoje quem tem Natural/ADABAS quer morrer, porque a Software AG está cobrando os tubos (zilhões de dólares) pela renovação das licenças e a tecnologia é “imigrável”. Paralelo com .NET, proprietário como Natural/ADABAS. Erro estratégico.

Outro exemplo: há 30 anos, C prometia ser o que Java promete hoje. Se alguém algum dia teve um sistema de negócios escrito em C, então deve ter uma boa história de migração urgente para contar. Paralelo com Java, “assembleísta” como C. Outro erro estratégico.

Então, amigos, tecnologicamente falando, Java e .NET se equivalem.

Não consigo imaginar um sistema corporativo (que é o que interessa, afinal) que possa ser feito em um, mas não no outro. Ou que saia muito mais rápido em um do que no outro.

Portanto, o cerne da questão é estratégico, não tecnológico.

E todos os xiitas são gentilmente deixados de lado nessas discussões.

De minha parte, entre Java e .NET, fico com arquitetura de software, MDA e Governança de TI.

Na guerra entre as partes, prefiro vender a munição.

Márcio Tierno (mtierno.rm): é atualmente responsável por toda a divisão de testes funcionais da Inmetrics. Atua na área há 16 anos, tendo trabalhado em empresas como Compuware do Brasil, IBM, Rational Software, BCP Telecomunicações, entre outras. Cursou Ciência da Computação na Unicamp, é certificado ITIL Foundations e Rational Requirements Mngt. Marcio já prestou consultoria e ministrou dezenas de treinamentos em Ger. de Projetos, Requisitos e demais disciplinas de desenvolvimento para empresas como Serpro, Xerox, BankBoston, Banco Itaú, Banco Votorantim, Cargill, Porto Seguro e outras de grande porte, no Brasil e no exterior.

Por: André Dourado

Existem duas formas de desenvolver relatórios master-detail utilizando o Reportviewer. A primeira opção é utilizar subreports. A segunda, que oferece melhor performance, é utilizar aninhamento de regiões.

Neste tutorial será mostrado como utilizar o Reportviewer para criação de relatórios master-detail através do uso de subreports.

Fontes: RelatorioTeste.zip (57K)

1.Crie um projeto chamado RelatorioTeste;

2.Crie para este exemplo, classes de manipulação dos dados. Por serem apenas classes para efeito didático, não se preocupe com acessos a banco. São classes apenas para prover dados para o relatório. Para este exemplo definiremos classes que representam Clientes e os Contatos desses Clientes.

Cliente.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RelatorioTeste
{
    public class Cliente
    {
        public Int32 clienteId { get; set; }
        public String clienteNome { get; set; }
 
        public Cliente()
        {
        }
    }
}


ClienteDAO.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RelatorioTeste
{
    class ClienteDAO
    {
        public List getAll()
        {
            List listaCliente = new List();
 
            Cliente cliente1 = new Cliente();
            cliente1.clienteId = 1;
            cliente1.clienteNome = "Empresa Xyz S.A.";
            listaCliente.Add(cliente1);
 
            Cliente cliente2 = new Cliente();
            cliente2.clienteId = 2;
            cliente2.clienteNome = "Empresa Klz Ltda.";
            listaCliente.Add(cliente2);
 
            return listaCliente;
        }
    }
}


Contato.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RelatorioTeste
{
    class Contato
    {
        public Int32 contatoId { get; set; }
        public String contatoNome { get; set; }
        public Int32 clienteId { get; set; }
 
        public Contato()
        {
        }
    }
}


ContatoDAO.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RelatorioTeste
{
    class ContatoDAO
    {
        public List getByCodigo(Int32 clienteId)
        {
            List listaContato = new List();
 
            switch (clienteId)
            {
                case 1:
                    Contato contato1 = new Contato();
                    contato1.contatoId = 1;
                    contato1.contatoNome = "Fulano de Tal da Empresa 1";
                    contato1.clienteId = 1;
                    listaContato.Add(contato1);
 
                    Contato contato2 = new Contato();
                    contato2.contatoId = 2;
                    contato2.contatoNome = "Ciclano de Tal da Empresa 1";
                    contato2.clienteId = 1;
                    listaContato.Add(contato2);
 
                    Contato contato3 = new Contato();
                    contato3.contatoId = 3;
                    contato3.contatoNome = "Antitese de Tal da Empresa 1";
                    contato3.clienteId = 1;
                    listaContato.Add(contato3);
 
                    break;
 
                case 2:
                    Contato contato4 = new Contato();
                    contato4.contatoId = 4;
                    contato4.contatoNome = "Fulano de Tal da Empresa 2";
                    contato4.clienteId = 2;
                    listaContato.Add(contato4);
 
                    Contato contato5 = new Contato();
                    contato5.contatoId = 5;
                    contato5.contatoNome = "Ciclano de Tal da Empresa 2";
                    contato5.clienteId = 2;
                    listaContato.Add(contato5);
 
                    Contato contato6 = new Contato();
                    contato6.contatoId = 6;
                    contato6.contatoNome = "Antitese de Tal da Empresa 2";
                    contato6.clienteId = 2;
                    listaContato.Add(contato6);
 
                    Contato contato7 = new Contato();
                    contato7.contatoId = 7;
                    contato7.contatoNome = "Prognostico de Tal da Empresa 2";
                    contato7.clienteId = 2;
                    listaContato.Add(contato7);
 
                    break;
            }
 
            return listaContato;
        }
    }
}


3.Adicione os DataSources ao projeto

1. Utilizando o menu do VS: “Data > Add New Data Source…”;
2. Escolha o tipo “Object” e clique em Next;
3. Selecione na árvore de objetos do projeto o objeto “Cliente” e clique em “Finish”;
4. Repita o passo 3, selecionando agora o objeto “Contato”;

4.Crie o relatório “master”:

1. Na janela “Solution Explorer” clique com o botão da direita do mouse sobre o projeto “RelatorioTeste”;
2. Selecione as opções “Add” e depois “New Item…”. Selecione o template “Report” e clique sobre o botão “Add”. O nome desse primeiro report deverá receber o nome “Report1.rdlc”;
3. Na janela “Solution Explorer” dê duplo clique sobre o objeto “Report1.rdlc”;
4. Na janela “ToolBox”, na divisão “Reporting Items” clique sobre o componente “List” e arraste até o “Report1”;
5. Na janela “ToolBox”, na divisão “Reporting Items” clique sobre o componente “Textbox” e arraste para o interior do “List”;
6. Na janela “Data Sources” selecione a propriedade “clienteId” do datasource “Cliente” e arraste para o interior do TextBox criado no passo 4;
7. Repita os passos 4 e 5 para a propriedade “clienteNome”;
8. Na janela “ToolBox”, na divisão “Reporting Items” clique sobre o componente “Subreport” e arraste para o interior do “List”;

5.Crie o relatório “detail”:

1. Na janela “Solution Explorer” clique com o botão da direita do mouse sobre o projeto “RelatorioTeste”. Selecione as opções “Add” e depois “New Item…”. Selecione o template “Report” e clique sobre o botão “Add”. O nome desse primeiro report deverá receber o nome “Report2.rdlc”;
2. Na janela “Solution Explorer” dê duplo clique sobre o objeto “Report2.rdlc”;
3. Na janela “ToolBox”, na divisão “Reporting Items” clique sobre o componente “List” e arraste até o “Report2”;
4. Na janela “ToolBox”, na divisão “Reporting Items” clique sobre o componente “Textbox” e arraste para o interior do “List”;
5. Na janela “Data Sources” selecione a propriedade “contatoId” do datasource “Contato” e arraste para o interior do TextBox criado no passo 4;
6. Repita os passos 4 e 5 para a propriedade “contatoNome”;

6.Utilize o formulário “Form1” para armazenar o componente ReportViewer:

1. Na janela “Solution Explorer” dê duplo clique sobre o objeto “Form1”;
2. Na janela “ToolBox”, na divisão “Reporting” clique sobre o componente “MicrosoftReportViewer” e arraste até o “Form1”
3. Selecione qual o relatório será exibido pelo ReportViewer. Selecione “RelatorioTeste.Report1″, conforme a tela a seguir:

1. Na janela “Solution Explorer” dê duplo clique sobre o objeto “Report2.rdlc”;
2. No menu do VS selecione a opção: “Report > Report Parameters…”;
3. Na tela de definição de Parâmetros clique sobre o botão “Add” e defina o parâmetro “parCodigoCliente”, conforme a tela a seguir. Ao final clique no botão “Ok”;

1. Na janela “Solution Explorer” dê duplo clique sobre o objeto “Report1.rdlc”;
2. Clique com o botão da direita do mouse sobre o componente “Subreport”. Selecione a opção “Properties”. Na aba “General” selecione no campo “Subreport:” o report “Report2″;

1. Selecione a aba “Parameters”;
2. Selecione nos campos as opções de forma que fiquem como a tela a seguir:

1. Na janela “Solution Explorer” dê duplo clique sobre o objeto “Form1.cs”;
2. No formulário dê duplo clique sobre o título do Formulário, ou selecione nos eventos do form o evento “Load”;
3. Insira no evento “Form1_Load” o seguinte código:

private void Form1_Load(object sender, EventArgs e)
{
    reportViewer1.LocalReport.SubreportProcessing += new SubreportProcessingEventHandler(LocalReport_SubreportProcessing);
 
    ClienteDAO clienteDAO = new ClienteDAO();
    List listaCliente = new List();
    listaCliente = clienteDAO.getAll();
 
    ClienteBindingSource.DataSource = listaCliente;
 
    reportViewer1.RefreshReport();
}
 
void LocalReport_SubreportProcessing(object sender, SubreportProcessingEventArgs e)
{
    int codigoCliente = Int32.Parse(e.Parameters["parCodigoCliente"].Values[0]);
 
    ContatoDAO contatoDAO = new ContatoDAO();
    List listaContato = new List();
    listaContato = contatoDAO.getByCodigo(codigoCliente);
 
    e.DataSources.Add(new ReportDataSource("RelatorioTeste_Contato", listaContato));
}
 
Na linha: e.DataSources.Add(new ReportDataSource(“RelatorioTeste_Contato”, listaContato)), “RelatorioTeste_Contato” corresponde ao namespace (RelatorioTeste) onde o objeto (Contato) está armazenado. Sendo que o objeto (Contato), que pode ser um POCO/VO/TO/DTO (não defendendo nenhuma pattern em especial, apenas para efeito didático), contém as definições das propriedades utilizadas no subreport.

11.Execute o projeto. O resultado obtido deve ser semelhante a esse:

Estive nas últimas semanas, envolvido com a emissão de Nota Fiscal Eletrônica. Depois de todos os consumos de webservices, certificados digitais, chegamos ao problema da impressão da DANFE, mais especificamente em relação ao código de barras padrão Code128C.

Muitos componentes são oferecidos a um preço de “oportunidade”. Depois de muito procurar, achei alguns links que acho que podem interessar.

Gerador de Código de Barras com fontes em C#: http://www.codeproject.com/KB/GDI-plus/GenCode128.aspx

True Type Fonts para Code128: http://www.fpress.com/revista/Num9905/fuentes.zip

Espero que ajude a alguém.

Vídeo da palestra sobre DDD apresentada pelo Giovanni Bassi do grupo “.NET Architects” no terceiro encontro do grupo em 13/12/2008.

Após a apresentação houve um debate com todos os presentes por cerca de uma hora.

Fonte: ITea – TI e Chá?

Postado por Abel Avram, traduzido por Felipe Rodrigues em 17 Fev 2009 06:00 AM

O ASP.NET MVC está usando o T4 (Text Template Transformation Toolkit) para gerar código por trás das cenas quando um Controler ou uma View é adicionada ao projeto. O T4 é um gerador de texto totalmente customizado baseado em templates.

Uma das funcionalidades do ASP.NET MVC anunciada por Scott Cuthrie é usar o T4 para geração de código. O código é gerado pela engine do T4 a partir de um template de texto. Isso quer dizer que pode-se criar ou editar o template tendo controle completo sobre o código resultante.

Um template T4 parece muito com qualquer outro Web Form, combinando blocos de texto simples com lógica de controle. Abhishek Mishra deu um exemplo detalhado de como editar um.

Não há suporte inteligente para edição de templates T4 no Visual Studio, mas a Clarius Consulting oferece um T4 Editor Community Edition integrado com o VS e fornecendo syntax highlighting. Ele também oferece uma versão Pro que oferece verdadeiro suporte intellisense e edição do gerador de código T4 suportando hosts T4 customizados(WSSF, ASP.NET MVC), integração com o Server Explorer, Drag & Drop de arquivos XML e XSD, API de DB amigável para inspecionar metadados e outros.

O T4 pode ser usado para automatizar a geração de arquivos de texto de qualquer tipo e propósito. Scott Hanselman deu tal exemplo usando um template para gerar código LINQ to SQL. Scott recomenda o uso do T4 para qualquer tarefa repetitiva de geração de texto, não apenas relacionadas ao .NET: “Se você está fazendo algo duas vezes ou mais, manualmente, em sua empresa, gere isso.”

A InfoQ internacional oferece uma introdução técnica ao T4 incluindo links para a documentação no MSDN e posts úteis.

Fonte: InfoQ

Até agora o engine de geração de código do Mono era baseado em uma árvore de representação intermediária (IR) do código. A versão 2.2 possue uma nova engine baseada em uma IR linear, que traz melhorias significativas de velocidade e tamanho de código.

A IR baseada em árvore anterior tornava "difícil melhorar a geração de código e extender o engine JIT de maneira significativa", de acordo com Miguel de Icaza. O novo IR linear ajuda a "melhorar a visibilidade do uso do alocador de registro, assim ele pode fazer melhores escolhas quando produzindo código".

O trabalho na IR linear começou no final de 2005. O trabalho evoluiu mas o time do Mono não queria incluir a nova engine no 2.0 por causa da quatidade de trabalho envolvido. Agora, que a versão 2.2 foi liberada, o Mono tem uma nova engine.

O efeito mais importante da mudança é mostrado pelos resultados de benchmark:

Velocidade: O engine beneficiará código computacionalmente intensivo, normalmente entre 10% e 30% de aumento de performance, with alguns casos chegando a 50% mais rápido.

Tamanho do código: a nova engine gera código menor, tipicamente 12% a 20% menor.

Aqueles interessados nos detalhes da nova engine podem encontrá-los no website do Mono. Os Release Notes para a versão 2.2 mencionam as seguintes melhorias: performance aumentada, suporte para compilação antecipada, suporte para monitoramente através de PerformanceCounters, anexar código ao vivo, suporte a SIMD e outros.

Fonte: InfoQ

Scott Guthrie anunciou hoje que o ASP.NET MVC 1.0 Release Candidate, está disponível para download. Este release é o último release público, antes do release final 1.0 planejado para Fevereiro.