Image Image Image Image Image
Scroll to Top

Topo

c

10

abr
2012

Sem Comentários

Em Blog
C#

Por Allison

C# – Calculando o CRC de strings e arquivos

Em 10, abr 2012 | Sem Comentários | Em Blog, C# | Por Allison

Fonte: José Carlos Macoratti/IMasters

O CRC – Cyclic redundancy check, ou verificação de redundância cíclica, é um código detector de erros cujo algoritmo é muito usado em protocolos de comunicação diferentes, empacotamento e desempacotamento de algoritmos para garantir a robustez dos dados.

A ideia por trás do CRC é simples – calcular um checksum original (sequência de verificação de quadros) para cada quadro de dados, baseada em seu conteúdo, e colar o checksum no final de cada mensagem. Uma vez que os dados são recebidos, é possível realizar o mesmo cálculo e comparar os resultados – se os resultados são semelhantes, a mensagem é válida.

O CRC é calculado e anexado na informação a transmitir (ou armazenar), sendo verificado após a recepção ou o acesso, para confirmar se não ocorreram alterações.

O CRC é popular por ser simples de implementar em hardware binário, simples de ser analisado matematicamente, e pela eficiência em detectar erros típicos causados por ruído em canais de transmissão.

A utilidade do CRC advém das seguintes propriedades:

  1. Como todos os bits são usados no cálculo do CRC, a mudança em apenas um bit provoca uma mudança no CRC.
  2. Mesmo mudanças pequenas nos dados levam a CRCs muito diferentes. Experiências com o CRC-32 (usando polinômios de 32 bits) mostram que é muito raro que a introdução de erros nos dados não seja detectada pelo CRC.
  3. A probabilidade de qualquer dos 232 valores possíveis para o CRC é praticamente uniforme.

Existem diferentes tipos de CRC que podem ser calculados: CRC-32, CRC-16, CRC-12, CRC-8 etc.

Para realizarmos cálculos envolvendo o CRC temos que utilizar o namespace System.Security.Cryptography e neste artigo eu vou calcular o CRC de strings e arquivos.

Vamos abrir o Visual C# 2010 Express Edition e, no menu File-> New Poject, selecione o Template Windows Forms Applicacion com o nome Calculando_CRC.

No menu Project -> Add Class, inclua uma classe com o nome CrcStream com o seguinte código:

using System.IO;

namespace Macoratti
{
/// <summary>
/// Encapsula um <see cref="System.IO.Stream" /> para calcular o checksum CRC32
/// em tempo de execução
/// </summary>
public class CrcStream : Stream
{
/// <summary>
/// Encapsula um <see cref="System.IO.Stream" />.
/// </summary>
/// <param name="stream">O stream para calcular o checksum.</param>
public CrcStream(Stream stream)
{
this.stream = stream;
}

Stream stream;

/// <summary>
/// Obtem o stream.
/// </summary>
public Stream Stream
{
get { return stream; }
}

public override bool CanRead
{
get { return stream.CanRead; }
}

public override bool CanSeek
{
get { return stream.CanSeek; }
}

public override bool CanWrite
{
get { return stream.CanWrite; }
}

public override void Flush()
{
stream.Flush();
}

public override long Length
{
get { return stream.Length; }
}

public override long Position
{
get
{
return stream.Position;
}
set
{
stream.Position = value;
}
}

public override long Seek(long offset, SeekOrigin origin)
{
return stream.Seek(offset, origin);
}

public override void SetLength(long value)
{
stream.SetLength(value);
}

public override int Read(byte[] buffer, int offset, int count)
{
count = stream.Read(buffer, offset, count);
readCrc = CalculateCrc(readCrc, buffer, offset, count);
return count;
}

public override void Write(byte[] buffer, int offset, int count)
{
stream.Write(buffer, offset, count);

writeCrc = CalculateCrc(writeCrc, buffer, offset, count);
}

uint CalculateCrc(uint crc, byte[] buffer, int offset, int count)
{
unchecked
{
for (int i = offset, end = offset + count; i < end; i++)
crc = (crc >> 8) ^ table[(crc ^ buffer[i]) & 0xFF];
}
return crc;
}

static private uint[] table = GenerateTable();

static private uint[] GenerateTable()
{
unchecked
{
uint[] table = new uint[256];

uint crc;
const uint poly = 0xEDB88320;
for (uint i = 0; i < table.Length; i++)
{
crc = i;
for (int j = 8; j > 0; j--)
{
if ((crc & 1) == 1)
crc = (crc >> 1) ^ poly;
else
crc >>= 1;
}
table[i] = crc;
}
return table;
}
}

uint readCrc = unchecked(0xFFFFFFFF);

/// <summary>
/// Obtem o checksum CRC dos dados que foram lidos pelo stream
/// </summary>
public uint ReadCrc
{
get { return unchecked(readCrc ^ 0xFFFFFFFF); }
}

uint writeCrc = unchecked(0xFFFFFFFF);

/// <summary>
/// Obtem o checksum CRC dos dados que foram escritos para o stream
/// </summary>
public uint WriteCrc
{
get { return unchecked(writeCrc ^ 0xFFFFFFFF); }
}

/// <summary>
/// Reseta a leitura e escrita dos checksums.
/// </summary>
public void ResetChecksum()
{
readCrc = unchecked(0xFFFFFFFF);
writeCrc = unchecked(0xFFFFFFFF);
}
}
}

autor: http://www.codeproject.com/Members/reinux

Agora vamos definir no formulário form1.cs uma interface bem simples, na qual iremos informar o nome do arquivo e calcular o seu CRC.

Abaixo, vemos o formulário que usa os controles TextBox e Button:

No evento Click do botão de comando – Calcula CRC -, vamos incluir o código que usa a classe CrcStream para calcular o CRC do arquivo:

using System;
using System.Windows.Forms;
using System.IO;
using Macoratti;

namespace Calculando_CRC
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

FileStream file = null;
CrcStream stream = null;

private void btnCalculaCRC_Click(object sender, EventArgs e)
{
if (txtArquivo.Text == string.Empty)
{
MessageBox.Show("Informe o nome do arquivo.");
return;
}

string arquivo = txtArquivo.Text;

//Abre um fluxo de stream e o encapsula em um CrcStream
try
{
file = new FileStream(arquivo, FileMode.Open);
stream = new CrcStream(file);
}
catch (Exception ex)
{
MessageBox.Show("Erro ao acessar o arquivo :  " + ex.Message);
return;
}

//Usa o arquivo - neste caso le o arquivo como uma string
StreamReader reader = new StreamReader(stream);
string texto = reader.ReadToEnd();

//Imprime o checksum calculado
txtCRC.Text = stream.ReadCrc.ToString("X8");
}
}
}

Executando o projeto, iremos obter para um determinado arquivo informado:

Pegue o projeto completo aqui: Calculando_CRC

Tags | , ,

19

mar
2012

Sem Comentários

Em Blog
Código

Por Allison

Otimizando o Django Views com C++

Em 19, mar 2012 | Sem Comentários | Em Blog, Código | Por Allison

Fonte: IMasters

Texto original disponível em: http://www.jeffknupp.com/blog/2012/02/15/optimizing-django-views-with-c-plus-plus/


No meu artigo anterior, esbocei o método que vai sobre o perfil de um aplicativo Django. Utilizei uma view do linkrdr como um exemplo. Ela é responsável por agregar, classificar e ordenar todos os links de feeds de um usuário (RSS, Atom, Twitter, etc). O código a partir do envio da mensagem foi uma implementação simplista e inicial do panorama. Tenho, no entanto, um algoritmo de pontuação muito mais robusto, escrito em Python, que eu planejava utilizar no site.

Você pode ter percebido a palavra “planejado” ali, né? Pois é, o algoritmo se revelou muito lento. Mais do que eu consideraria aceitável. Depois de pensar em várias mudanças arquitetônicas que poderiam ser feitas para resolver o problema, cheguei em uma solução um tanto radical para um desenvolvedor Django: eu implementei a visão em C++.

Sei que nem todo desenvolvedor Django sabe C++ – e não precisa -, mas aqueles que sabem precisam perceber que é uma ferramenta viável quando Python está muito lento. Mas, eventualmente, você pode chegar a um ponto onde não é possível realmente otimizar o seu código Python mais. Neste caso, o perfil mostra que a maioria de seu tempo é gasto em chamadas de bibliotecas Python. Depois de bater nesse ponto, ou você escreve um algoritmo ineficiente ou você tem um problema não adequado para Python.

Quando percebi que tinha atingido esse ponto com o meu código de visão, entrei em pânico. “O que mais há para fazer?”, me perguntava. Então me lembrei de um projeto de trabalho onde havia escrito alguns códigos C++ que fazem interface com o Python. De uma perspectiva técnica, não havia nada me impedindo de implementar alguns aspectos do meu app Django em C++ (além do fato de que ele é torturante para escrever quando se trata do Python). Uma vez que linkrdr é um projeto de uma só pessoa, não existem companheiros que precisam aprender o código. Sendo assim, eu sou livre para implementá-lo como eu desejar.

Configurando

Tendo escrito um código “puro” C++/Python de interoperabilidade Python antes, e não querendo ver Py_XDecRef novamente, decidi usar boost::Python. Para começar, eu me certifiquei de que tinha as bibliotecas mais recentes do Boost e uma versão atualizada de gcc para que eu pudesse usar as características C++ 11, que são de fato muito boas. Depois de construir a versão mais recente da biclioteca boost::python, eu realemnte aprendi a lidar com isso. E ela acabou sendo extremamente fácil.

O boost::python envolve uma série de tipos de dados em Python para você: “object” representa um objeto Python genérico, “lista” é uma lista, e assim por diante. Como o Python é tipado dinamicamente, não há realmente muitos lugares inteiramente dele. “Tudo é um objeto” significa que tudo é um boost::python::object e pode ser acessado desta forma.

Além de wrappers primitivo, o boost fornece um mecanismo claro e conciso para fazer classes e funções C++ visíveis para Python. Eu tinha uma classe simples no código de entrada do nome anterior do meu LinkScore. Era basicamente uma estrutura C com uma lista de objetos e um interger. O código C++ é:

using namespace boost::python;

class LinkScore
{
public:
LinkScore() {}
LinkScore(const object& link, int score) : score_(score)
{
links_.append(link);
}
list links_;
int score_;
};

Se você está pensando que meus data members deveriam ser privados, adivinhem: eu não me importo. Essa é alegria de trabalhar em código que só você vai usar. Você pede escrevê-lo e usá-lo como quiser.

Os detalhes

Enfim, o código com o qual o boost:python pode chamar o Python é:

class_<LinkScore>("LinkScore", init<object, int>())
.def_readwrite("links", &LinkScore::links_)
.def_readwrite("score", &LinkScore::score_);

Realmente, não poderia ser mais simples. A maneira de conseguir isso <Python.h> envolve a definição de uma estrutura com quarenta valores para declarar cada classe. Fiquei feliz em não ter que me preocupar com isso.

O atual código para a minha view é uma função gratuita chamada get_scores. Aqui está um breve trecho:

using namespace boost::python;
using namspace std;

class CompareObject {
public:
bool  operator()(const LinkScore& l, const LinkScore& r) { return l.score_ > r.score_; }
};

list get_scores(object links)
{
object utility = import("links.utility");
set<LinkScore, CompareObject> seen_links;
list python_seen_links;
for (int i = 0; i < len(links); ++i)
{
const object& link = links[i];
LinkScore score = LinkScore(link, score_link (link, links));
auto iter = seen_links.find(score);

if (iter != seen_links.end())
{
// Do stuff
}
else
{
// Do other stuff
}
}
// TODO: Optimize this
for (auto i = seen_links.begin(); i != seen_links.end(); ++i)
{
python_seen_links.append(*i);
}
return python_seen_links;

Se você conhece C++ e Python, é quase como ler um mix dos dois. A descrição acima, no entanto, é válida para o código C++ e é a interface que o Python usa para chamar minha biblioteca de pontuação. Para expor essa função para o Python, tudo que é necessário é def (“get_score”, get_score); dentro de um bloco BOOST_PYTHON_MODULE, que nomeia o módulo a ser importado.

Quando terminei de escrever o código C++, eu o compilei usando o gcc com a ferramenta de biuld bjam da biblicota boots; defini o meu LD_LIBRARY_PATH para captar o libboost_Python.so e liguei uma shell do manage.py (na verdade, um “shell_plus”). Usei o módulo cProfile para comparar a versão do C++ da view com a versão do Python da view. Os resultados foram satisfatórios: um aumento de oito vezes na velocidade com a versão C++.

Para acionar o código C++, eu só precisava ter certeza que o .so gerado estiva em minha PYTHON_PATH. Assim, poderia importá-lo como uma biblioteca normal do Python. Acrescentei-o ao meu views.py e meus testes unitários rodaram. Depois disso, comitei tudo e coloquei o novo código através dos seus passos no servidor de desenvolvimento web. O tempo de resposta melhorou visivelmente, com a view funcionando instantaneamente.

Wrap Up

Sei que esta não é uma opção de otimização disponível para todos, mas é uma opção interessante. O Python é uma linguagem fantástica e o Django é um framework muito bom. No geral, estou bastante contente com os resultados e como foi fácil de implementar. Me absterei de escrever mais código C++ para linkrdr, a menos que seja absolutamente necessário. É bom saber, no entanto, que a opção está lá.

Tags | , , , ,

12

mar
2012

Sem Comentários

Em Blog
Ruby

Por Allison

Entenda a tipagem em Ruby

Em 12, mar 2012 | Sem Comentários | Em Blog, Ruby | Por Allison

Fonte: Samuel Casa/IMasters

Cada linguagem de programação tem sua forma de lidar com tipos, por exemplo: C é uma linguagem fracamente tipada. O que pode ser visto nesse exemplo:

char a= 'a', b='b';
float c = a + b;

Ele que mostra que podermos somar dois chars e atribuirmos a um float (ao longo do texto o conceito de “fracamente tipada” ficará mais claro).

No entanto, Ruby é dinamicamente, implicitamente e fortemente tipada. Vejamos o que cada um destes adjetivos significa:

Dinamicamente tipada

Quer dizer que a cada interação, o tipo é verificado. Isso fica claro no seguinte exemplo:

x = 100
(1..4).each{ x = x * 100 ;  puts "#{ x.class} #{x}"  }

Que gera o resultado:

Fixnum 10000
Fixnum 1000000
Fixnum 100000000
Bignum 10000000000

Como podemos ver a variável x começa como Fixnum e conforme aumenta, passa para Bignum – sem a necessidade de uma conversão.

Essa característica gera vários pontos positivos na linguagem, tais como:

  • Diminui a verbosidade, pois não há a necessidade de fazer conversões;
  • Tende a facilitar a vida do programador pois não há a preocupação com conversões.

Mas neste contexto nem tudo são flores. Vejamos os pontos negativos:

  • A linguagem tende a ser mais lenta em tempo de execução, devido ao fato de que, a cada interação, o tipo deve ser verificado;
  • Pode confundir o programador, pois ele pode não saber exatamente com quais tipos está tratando.

Implicitamente tipada

Continuando no mesmo exemplo, quando fizemos x = 100 não precisamos declarar o tipo de x. Ou seja, não foi necessário fazer algo como: Fixnum x = 100. Isso acontece pelo fato do Ruby detectar o tipo de cada variável em tempo de execução. Uma boa analogia para este fenômeno é pensar nas variáveis como se fossem caixas fechadas e seus dados como fitas coloridas onde o interpretador abre a caixa e verifica as cores das fitas.

Novamente, os pontos positivos e negativos são muito semelhantes aos relacionados a tipagem dinâmica. Veja:

Positivos:

  • Diminui a verbosidade, pois não há a necessidade de fazer declarações.

Negativos:

  • A linguagem tende a ser mais lenta, pois o tipo é verificado em tempo de execução de acordo com a analogia das caixas e fitas;
  • Pode confundir o programador, pois ele pode não saber exatamente com quais tipos está tratando, já que não existe a declaração dos mesmos.

Fortemente tipada

Este é um conceito confuso, mas uma boa forma de explica-lo é dizer que todas as variáveis devem ter um tipo, ou seja, fazer parte de uma classe, no caso do Ruby, e que cada tipo segue a risca seu contrato. Por exemplo:

a = 100
b = "Ruby on Rails"
a + b

TypeError: String can't be coerced into Fixnum
from (irb):54:in `+'
from (irb):54

Como você notou, em Ruby não podemos somar um String com Fixnum, pois essa operação não está no contrato da classe String e Fixnum.

De fato, o assunto não acaba por aqui. Existem alguns materiais na web e em livros sobre isso. Em vista disso, e no intuito de incentivar a pesquisa, deixo algumas referencias:

Obs.: Os tipos em Ruby na verdade são classes, ou seja, não existem tipos primitivos e sim objetos que pertencem a classes. Por exemplo:

a = 1 # a pertence a classe Fixnum

Até a próxima!

Tags | , ,

18

dez
2011

Sem Comentários

Em Blog
C#
Código

Por Allison

Conhecendo o F#

Em 18, dez 2011 | Sem Comentários | Em Blog, C#, Código | Por Allison

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

Tags | , , ,

16

dez
2011

Sem Comentários

Em Blog
Python

Por Allison

Python volta a ganhar o premio de melhor linguagem de programação

Em 16, dez 2011 | Sem Comentários | Em Blog, Python | Por Allison

O Python novamente ganhou o prêmio de melhor linguagem de programação oferecido pela Linux Journal, uma das revistas de referência dedicada a sistemas operacionais, e uma das mais populares entre os programadores amadores. E essa já é a terceira vez. O Python voltar a se impor ante seu mais ardente rival, o clássico C++, que ficou 6% atrás nas pesquisas.

Para aqueles que não estão familiarizados com o assunto, o Python é uma linguagem de programação de alto nível e muito jovem, já que sua primeira versão foi lançada há 20 anos em 1991. Sua vantagem sobre os demais é que é muito fácil de usar, com uma sintaxe que se caracteriza pela sua simplicidade e limpeza. Para se ter uma idéia, o clássico “Hello World”, exemplo comum em linguagens de programação para mostrar como se imprime uma linha na tela, você pode conseguir com esta simples sentença: print “Hello World”.

Fácil, não? Atualmente se encontra em sua versão 3.2 e já tem se consolidado o suficiente para influenciar outras línguas no mundo da programação, a qual tem crescido ainda mais.

Estas foram algumas das características que deram ao Python o posto de melhor linguagem de programação, mas destacamos principalmente, a facilidade com que se pode iniciá-lo e começar a trabalhar nele. Python é sinônimo de simplicidade e potência, duas palavras que devem ir juntas e que fazem com que algo esteja em mudança no mundo da linguagem de programação graças a linguagens como está.

Fonte: Auricelio Barbosa/forumpc

Tags | , ,

11

dez
2011

Sem Comentários

Em Blog
C#
Java

Por Allison

Conhecendo o F#

Em 11, dez 2011 | Sem Comentários | Em Blog, C#, Java | Por Allison

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

Tags | , , , ,

27

nov
2011

Sem Comentários

Em Blog
Python

Por Allison

Introdução aos “decorators” do Python

Em 27, nov 2011 | Sem Comentários | Em Blog, Python | Por Allison

Este recurso incrível apareceu na linguagem quase se desculpando, e com preocupações de que poderia não ser tão útil. Eu, por minha vez, acredito que em tempo ele será visto como um dos recursos mais poderosos na linguagem. O problema é que todas as introduções à decorators que eu já vi foram bastante confusas, então vou tentar consertar isso neste artigo.

Decorators vs. decorators pattern

Primeiro, você precisa entender que a palavra “decorator” foi usada com certo receio, porque existia uma preocupação em que confundissem o decorator pattern do livro Design Patterns. Outros termos foram considerados para substituí-lo, mas “decorator” parece ser o escolhido.

Na verdade, você pode utilizar os decorators do Python para implementar um decorator pattern, mas esse é um uso muito limitado dele. Os decorators do Python, acredito, se equivalem mais aos macros.

História dos macros

O macro tem uma longa história, mas a maioria das pessoas provavelmente tiveram experiências com os macro processadores C. Os problemas com os macros C eram os seguintes: eles estavam em uma linguagem diferente da C, e o comportamento deles, às vezes, era bizarro e inconsistente com o comportamento do resto do C.

Tanto o Java, quanto o C# adicionaram anotações, que permitem que você faça algumas coisas para os elementos da linguagem. Ambos têm problemas para fazer o que você quer. Às vezes você tem que pular através de um círculo grande e complexo. Há também o fato de que esse recurso de anotações tem suas mãos atadas pela escravidão e disciplina (ou como Martin Fowler gentilmente coloca: “Direcionamento”) natural dessas linguagens.

Muitos programadores C++ (inclusive eu) notaram as habilidades geradoras de templates C++ e utilizaram esse recurso de uma maneira macro.

Muitas outras linguagens incorporaram os macros. Eu, ainda sem saber muito sobre eles, ouso a dizer que os decoradores do Python são parecidos com os macros do Lips em poder e em possibilidades.

O objetivos dos macros

Acredito que seja certo dizer que o objetivo dos marcos em uma linguagem é fornecer uma maneira de modificar os elementos da mesma. É isso que os decorators fazem no Python: eles modificam funções. É por isso que eles normalmente fornecem uma alternativa mais simples para metaclasses.

As maiores falhas da maioria das abordagens de modificações próprias das linguagens são que elas são muito restritivas e que precisam de uma linguagem diferente (posso dizer que as anotações Java compreendem uma “linguagem diferente”, ainda que com todos os problemas pelos quais você deve passar para produzir uma anotação interessante).

O Python cai na categoria de Fowler de “habilitar” linguagens, então se você quiser fazer modificações, por que criar uma linguagem diferente, ou restrita? Por que simplesmente não usar o Python? E é isso que os decorators de Python fazem.

O que você pode fazer com decorators?

Decorators permitem que você insira, ou modifique o código em funções, ou classes. Parece um pouco como Aspect-Oriented Programming (AOP) em Java, não? Exceto que é muito mais simples e poderoso. Por exemplo, suponha que você gostaria de fazer algo nos pontos de entrada e saída de uma função (como executar algum tipo de segurança, rota, bloqueio, etc – todos os argumentos padrões para AOP). Com decorators, fica assim:

@entryExit
def func1():
   print "inside func1()"

@entryExit
def func2():
   print "inside func2()"

O @ indica a aplicação do decorator.

Decorators de funções

O decorator de uma função é aplicado a uma definição de função ao ser colocado na linha antes da que começa a definição da função. Por exemplo:

@myDecorator
def aFunction():
   print "inside aFunction"

Quando o compilador passa por este código, a aFunction() é compilada e o objeto da função resultante é passado para o código myDecorator, que faz algo para produzir um objeto do tipo função, que é, então, substituído pelo original aFunction().

Com o que o código myDecorator se parece? Bom, a maior parte dos exemplos introdutórios o mostra como uma função, mas eu achei mais fácil começar a compreender os decorators usando classes como mecanismos de decoração, ao invés de funções. Além disso, é mais poderoso.

O único lado ruim de um objeto retornado por um decorator é que ele pode ser usado como uma função – o que basicamente significa que ele deve ser chamável. Assim, quaisquer classes que usarmos como descoradores devem implementar __call__.

O que um decorator faz? Bem, ele pode fazer qualquer coisa, mas normalmente você espera que o código da função original seja usado em algum ponto. Isso não é necessário, no entanto:

class myDecorator(object):

   def __init__(self, f):
      print "inside myDecorator.__init__()"
      f() # Prove that function definition has completed

   def __call__(self):
      print "inside myDecorator.__call__()"

@myDecorator
def aFunction():
   print "inside aFunction()"

print "Finished decorating aFunction()"

aFunction()

Quando você rodar esse código, o verá assim:

inside myDecorator.__init__()
inside aFunction()
Finished decorating aFunction()
inside myDecorator.__call__()

Note que o construtor para myDecorator é executado no ponto da decoração da função. Como podemos chamar f() dento de __init__(), isso mostra que a criação de f() está completa antes do decorator ser chamado. Note, também, que o construtor do decorator recebe o objeto da função sendo decorado. Normalmente, você irá capturar o objeto da função no construtor e depois utilizá-lo no método __call__() (o fato de que decoração e chamado são duas fases claras quando se utiliza classes, é o motivo pelo qual eu argumento que esse é o modo mais fácil e mais poderoso).

Quando aFunction() é chamada depois de ter sido decorada, temos um comportamento completamente diferente; o método myDecorator.__call__() é chamado, ao invés do código original. Isso acontece porque o ato da decoração substitui o objeto da função original com o resutlado da decoração – no nosso caso, o objeto myDecorator substitui aFunction. De fato, antes dos decorators serem adicionados, você tinha que fazer algo muito menos elegante para alcançar a mesma coisa:

def foo(): pass
foo = staticmethod(foo)

Com a adição do operador de decoração @, agora você tem o mesmo resultado dizendo:

@staticmethod
def foo(): pass

Esse é o motivo pelo qual as pessoas argumentam contra os decorators, porque o @ é apenas uma sintaxe simplificada, que significa “passar um objeto de função, através de outra função, e atribuir o resultado à função original”.

Acredito que a razão pela qual os decorators sentem tanto o impacto é porque essa maneira mais fácil, também conhecida como “syntactic sugar“, muda o modo como você pensa programação. Certamente, ele traz a ideia de “aplicar código a outro código”(por exemplo, macros) no pensamento dominante ao formalizá-lo como um construtor de linguagem.

Levemente mais útil

Agora, vamos voltar e implementar o primeiro exemplo. Aqui, vamos fazer a coisa mais comum e de fato utilizar o código nas funções decoradoras:

class entryExit(object):

   def __init__(self, f):
      self.f = f

   def __call__(self):
      print "Entering", self.f.__name__
      self.f()
      print "Exited", self.f.__name__

@entryExit
def func1():
   print "inside func1()"

@entryExit
def func2():
   print "inside func2()"

func1()
func2()

A saída é:

Entering func1
inside func1()
Exited func1
Entering func2
inside func2()
Exited func2

Você pode ver que as funções decoradoras agora tem as declarações das linha “Entering” e “Exited” em volta do chamado.

O construtor armazena o argumento, que é o objeto da função. No chamado, usamos o atributo da função __name__ para exibir o nome da função, e então chamá-la.

Usando funções como decorators

A única restrição no resultado de um decorator é que ele é chamável, então ele pode substituir propriamente a função decoradora. Nos exemplos acima, eu substitui a função original com um objeto de classe que tem um método __call__(). Mas um objeto de função também é chamável, então podemos reescrever o exemplo anterior usando uma função, ao invés de uma classe, assim:

def entryExit(f):
   def new_f():
      print "Entering", f.__name__
      f()
      print "Exited", f.__name__
   return new_f

@entryExit
def func1():
   print "inside func1()"

@entryExit
def func2():
   print "inside func2()"

func1()
func2()
print func1.__name__

A new_f() é definida dentro do corpo de entryExit(), então ela é criada e retornada quando a entryExit() é chamada. Note que new_f() é um encerramento, porque ela captura o valor real de f.

Uma vez que a new_f() tenha sido definida, ela é retornada a partir de entryExit(), de modo que o mecanismo do decorator possa determinar o resultado como uma função decoradora.

O output da linha print func1.__name__ é new_f, porque a função new_f foi substituída pela função original durante a decoração. Se isso for um problema, você pode mudar o nome da função antes de retorná-la:

def entryExit(f):
   def new_f():
      print "Entering", f.__name__
      f()
      print "Exited", f.__name__
   new_f.__name__ = f.__name__
   return new_f

A informação que você consegue obter dinamicamente sobre as funções, e as modificações que você consegue fazer nelas são bastante poderosas no Python.

Mais exemplos

Agora que você sabe o básico, você pode dar uma olhada em mais exemplos de decorators aqui. Observe o número de exemplos que usam classes, ao invés de funções como decorators.

Neste artigo eu intencionalmente evitei lidar com os argumentos da função decoradora, mas farei isso em um próximo. Arguardem!

***

Texto original disponível em: http://www.artima.com/weblogs/viewpost.jsp?thread=240808

Fonte: IMasters

Tags | , , ,

24

nov
2011

Sem Comentários

Em Blog

Por Allison

Desenvolvedores do GNOME criam o Boxes, uma nova integração para virtualização

Em 24, nov 2011 | Sem Comentários | Em Blog | Por Allison

Com o aumento do uso de máquinas virtuais e de conexões remotas, os desenvolvedores do GNOME estão trabalhando em uma nova integração para o ambiente desktop. Chamada de Boxes, a novidade oferece um único ambiente para criar executar espaços virtuais que podem vir de imagens locais, máquinas virtuais remotas ou sessões remotas do protocolo SPICE.

Os desenvolvedores vêm trabalhando em uma implementação baseada na linguagem de programação Vala, e melhorando as bibliotecas de fundação libvirt e spice-gtk, que são escritas em C. Eles anunciaram o primeiro release e já demonstraram as capacidades do aplicativo.

O desenvolvedor Zeeshan Ali Khattak explicou que, embora os desenvolvedores já utilizem o virt-manager e já tenham sanado as necessidades em nível empresarial de um administrador de sistema, havia a necessidade de uma virtualização e de uma aplicação de conexão remota para o usuário final. E essa necessidade é atendida com o Boxes.

O projeto ainda está em estágios iniciais e, por isso, há vários problemas, sendo o maior deles a falta de suporte para disquetes, quando a virtualização é feita no Qemu. Entretanto, com a nova interface de usuário, os usuários já são capazes de criar e de executar máquinas virtuais ou conexões de sistemas remotos sem esforço.

Para quem quiser contribuir com o projeto, os desenvolvedores estão procurando ajuda para trabalhar na interface de usuário e para aprimorar as bibliotecas libosinfo e libvirt-glib, nas quais o projeto é baseado.

Fonte: IMasters

Tags | , , , ,

23

nov
2011

Sem Comentários

Em Blog
C#
Código

Por Allison

Token e Sessão Corrente com C#.NET

Em 23, nov 2011 | Sem Comentários | Em Blog, C#, Código | Por Allison

Hoje vou falar um pouco e mostrar via código como pegar o número do token ou sessão corrente do usuário que está navegando em seu sistema ou site. Lembro que esse código serve para qualquer tipo de aplicativo.

Usado: Visual Studio .NET 2010, Linguagem C#.NET, Plataforma ASP.NET.

O que vou falar é simples de fazer, porém, quase ninguém sabe que existe esse tipo de informação disponível no framework .NET.

Geralmente, esse tipo de informação é utilizada em sistema de comércio eletrônico que guarda as informações do usuário relacionando a um número qualquer, que pode ser um token ou sessão corrente.

O primeiro passo é importar uma classe dentro da classe principal do sistema.

using System.Security.Principal;

Para pegar o token corrente, coloque o código:

WindowsIdentity.GetCurrent().Token.ToString();

O código acima busca um número do token que pode ser gerado a cada acesso. Para manter o mesmo código é bom pegar o valor e gerar em uma sessão ou token.

Para pegar a sessão corrente, coloque o código:

Session.SessionID.ToString();

Para testar, você pode mandar escrever os valores na tela com o Response.Write.

protected void Page_Load(object sender, EventArgs e)
{
Response.Write(WindowsIdentity.GetCurrent().Token.ToString());
Response.Write("<Br><br>"+Session.SessionID.ToString());
}

No meu teste, foi impresso na tela os seguintes dados.

1316 - Token
ts3iammnrqpdrvxcjgjwrss2 - Sessao

Note que o token é um número com 4 dígitos e a sessão é composta de números e letras. Dependendo do que está precisando um ou outro pode ser de grande valia.

É isso. Espero que tenha gostado e qualquer dúvida pode entrar em contato pelo site.

Fonte: Maurício Junior/IMasters

Tags | , , ,

23

nov
2011

Sem Comentários

Em Blog
Dados

Por Allison

Além de MySQL – Ramificando o banco de dados popular

Em 23, nov 2011 | Sem Comentários | Em Blog, Dados | Por Allison

Embora MySQL seja um dos programas mais populares, muitos desenvolvedores sentiram necessidade de ramificá-lo em outros projetos, cada um oferecendo sua própria especialidade. Essa necessidade, junto com o medo de que a Oracle irá desacelerar o crescimento do produto principal, levou à criação de muitos subprojetos e ramificações de interesse para desenvolvedores.

Introdução

MySQL é um dos programas de software livre mais populares da história. É o backbone de banco de dados de milhares de websites e pode-se dizer que detém o crédito (junto com Linux®) pelo crescimento explosivo da Internet nos últimos 10 anos.

Então, se o MySQL é tão importante, por que está aumentando o número de ramificações de alto perfil do produto MySQL principal? Como MySQL é software livre e gratuito, desenvolvedores sempre puderam pegar o código, modificá-lo conforme a necessidade e distribuir por conta própria. Por muito tempo, não havia nenhuma ramificação do MySQL em que um desenvolvedor confiasse em seu próprio ambiente de produção. No entanto, isso está mudando rapidamente. Várias ramificações estão recebendo muita atenção.

Este artigo irá discutir três ramificações populares do MySQL que estão atraindo atenção: Drizzle, MariaDB e Percona Server, incluindo o mecanismo XtraDB. Este artigo irá discutir brevemente os motivos para cada ramificação e suas metas e se o seu uso em seu ambiente de produção. Quando terminar de ler este artigo, você deve e star apto a responder à pergunta “Esses produtos de ramificação do MySQL são uma boa solução para o meu ambiente?”.

Por que ramificar?

Por que o MySQL precisa ser ramificado? Essa é uma pergunta legítima. Milhares de websites dependem dele e parece ser uma solução boa para muitas pessoas. No entanto, como acontece com frequência, o que é bom para muitas pessoas não é bom para todas as pessoas. Alguns desenvolvedores são incentivados a melhorar as coisas para suas próprias necessidades. O que poderia ser melhor do que transformar uma solução ótima numa solução perfeita?

Vamos examinar em melhores detalhes o que essas ramificações queriam mudar. Algumas ramificações acharam que o MySQL estava se tornando muito inchado e estava oferecendo muitos recursos que nunca iam interessar aos usuários, sacrificando simplicidade e desempenho. Se as pessoas estavam perfeitamente felizes com o MySQL 4, simplificado, por que deveriam lidar com a complexidade que foi incluída no MySQL 5? Para essa ramificação, uma ramificação do MySQL seria mais simples e mais rápida — oferecer menos recursos, mas torná-los extremamente rápidos, tendo em mente um público alto, nesse caso websites de alta disponibilidade.

Para outras ramificações, MySQL não estava oferecendo novos recursos suficientes ou os estava incluindo muito devagar. Eles talvez achassem que o MySQL não estava acompanhando seus mercados alvos de websites de alta disponibilidade executando em processadores com vários núcleos com muita RAM. Como sabem as pessoas familiarizadas com MySQL, ele oferece dois diferentes mecanismos de armazenamento — MyISAM e InnoDB. Essa ramificação achava que nenhum dos dois mecanismos de armazenamento oferecia exatamente o que eles queriam, por isso criaram um novo mecanismo perfeitamente adequado para seus objetivos.

Além disso, algumas ramificações têm como objetivo ser uma substituição de “entrada” (“drop in”) para o MySQL, na qual é possível simplesmente entrar na ramificação e não precisar escrever uma linha de código. A ramificação usa o mesmo código e interfaces que o MySQL, o que torna a transição o mais fácil possível. Outra ramificação afirma não ser compatível com MySQL e exige alterações no código. Cada ramificação também é muito diferente no nível de maturidade, com algumas afirmando estar prontas para produção, e outras afirmam estar longe desse objetivo no momento.

Por fim, há incerteza sobre como será o destino do MySQL com a Oracle. A Oracle comprou a Sun, que comprou MySQL, e agora a Oracle controla o produto MySQL, e lidera o desenvolvimento da comunidade na produção de novos produtos concluídos. Como a Oracle já tem um banco de dados comercial, há a preocupação de que a empresa pode não colocar recursos suficientes no MySQL para mantê-lo na ponta. Portanto, muitas ramificações também são resultado do medo subjacente de que o MySQL, o banco de dados grátis e de software livre líder, pode receber menos recursos, ciclos de release mais lentos e suporte mais caro.

XtraDB

XtraDB não é um produto independente, mas ainda é considerado uma ramificação de MySQL. XtraDB é, na verdade, um mecanismo de armazenamento para bancos de dados baseados em MySQL. Seria considerado um mecanismo de armazenamento adicional além do padrão MyISAM e InnoDB que já são parte do MySQL. MySQL 4 e 5 é instalado com cada tabela usando o mecanismo de armazenamento padrão MyISAM. InnoDB também é uma opção relativamente nova para mecanismo de armazenamento, e administradores e desenvolvedores de banco de dados podem escolher os tipos de mecanismo por tabela quando configuram o banco de dados. A principal diferença entre esses dois mecanismos de armazenamento é que MyISAM não oferece suporte transacional, mas InnoDB oferece. Outras diferenças são pequenas diferenças de desempenho, com InnoDB oferecendo pequenas melhorias de desempenho em relação a MyISAM, e mais confiabilidade e segurança ao lidar com perda de dados em potencial. Como InnoDB parece ser o mecanismo de armazenamento mais adequado para melhorias futuras, MySQL alterou o mecanismo padrão para InnoDB em vez de MyISAM a partir do release 5.5.

Construindo sobre essas vantagens, o mecanismo de armazenamento InnoDB foi ramificado em um novo mecanismo chamado XtraDB. Qual é a idade desse mecanismo de armazenamento? Ele foi lançado pela primeira vez há menos de 3 anos pela Percona. Portanto, é relativamente nova. Foi projetado especificamente para lidar com websites de alta disponibilidade modernos executando em servidores modernos. Foi projetado para executar em servidores com uma dúzia ou mais de núcleos e muita RAM (32 GB e mais). Esses são o tipo de servidores que qualquer empresa pode comprar de uma empresa de gerenciamento de servidores, e, portanto, um banco de dados deve ser projetado para aproveitá-los ao máximo.

A ramificação XtraDB tinha outro objetivo — ser uma substituição simples de entrada para o mecanismo de armazenamento InnoDB, de modo que usuários poderiam simplesmente alternar seu mecanismo de armazenamento sem ter que alterar o código do aplicativo subjacente. XtraDB tinha que ter compatibilidade retroativa com o InnoDB, além de fornecer todos os novos recursos e melhorias que eles queriam incluir. Eles atingiram esse objetivo.

Qual é a velocidade do XtraDB? Um teste de desempenho que eu encontrei diz que ele oferece 2.7x mais transações por minuto que o mecanismo InnoDB integrado no MySQL 5.1 (consulte Recursos). Certamente não é algo que pode ser ignorado, especialmente considerando que pode ser usado imediatamente.

Percona

XtraDB oferece ótimas melhorias sobre mecanismos de armazenamento MySQL integrados, mas não é um produto independente, e não é algo que se possa colocar em uma instalação MySQL existente. Portanto, se você quiser usar esse novo mecanismo de armazenamento, é preciso usar um produto que o ofereça.

Percona Server é esse produto, lançado pela Percona, empresa líder em consultoria de MySQL. É um produto de banco de dados independente que oferece aos usuários a capacidade de retirar sua instalação do MySQL e colocar o produto Percona Server, e assim obter a vantagem do mecanismo de armazenamento XtraDB. Afirma ser totalmente compatível com MySQL, portanto em teoria nenhum código precisaria ser alterado no software. Isso é, certamente, uma enorme vantagem. É ótimo para controle de qualidade quando você está procurando por uma melhoria de desempenho rápida. Portanto, um bom motivo para considerar Percona Server é aproveitar o mecanismo XtraDB com o menor número de alterações possível no código principal.

Além disso, eles são os autores originais do mecanismo de armazenamento XtraDB. A Percona lançou o código como software livre, de modo que ele pode ser encontrado em outros produtos, mas os criadores originais do mecanismo são as mesmas pessoas que criaram este produto. Usem essas informações como quiser.

Aqui estão as afirmações feitas para o Percona Server, retiradas do website deles:

  • Escalabilidade: lida com mais transações; faz ajuste de escala em servidores eficientes
  • Desempenho: Percona Server com XtraDB é extremamente rápido
  • Confiabilidade: resiliência a corrupção, replicação com segurança contra quebra
  • Gerenciamento: backup on-line, importação/exportação de tabela on-line
  • Diagnóstico: perfil e instrumentação avançados
  • Flexibilidade: tamanho de página variável, gerenciamento de buffer pool melhorado

A afirmação final da equipe do Percona é que o produto é o “mais próximo dos releases oficiais MySQL Enterprise da Oracle”, assim se diferenciando de outras ramificações que alteraram o código MySQL principal subjacente. Um ponto negativo do Percona Server é que eles gerenciam o código por si mesmos e não aceitam contribuições de desenvolvedores externos sem revisá-la antes, o que garante que eles controlem os recursos colocados no produto.

MariaDB

Outro produto que oferece o mecanismo de armazenamento XtraDB é o produto MariaDB. É muito semelhante ao produto Percona, mas oferece mais alterações no código subjacente para tentar obter ainda mais melhorias de desempenho em relação ao MySQL padrão. Utiliza o mecanismo XtraDB diretamente da Percona, portanto não á diferenças subjacentes nos mecanismos de armazenamento que cada um emprega, já que usam exatamente o mesmo.

Além disso, MariaDB oferece os mecanismos de armazenamento padrão oferecidos pelo MySQL, MyISAM e InnoDB. Portanto, na prática, pode ser considerado um superconjunto de MySQL, oferecendo tudo que o MySQL oferece e mais. Também afirma ser uma substituição de entrada para o MySQL, portanto pode ser instalado com o conhecimento de que não serão necessárias alterações no código subjacente ao passar o MySQL para o MariaDB.

Por fim, e talvez o mais importante, o criador chefe do MariaDB é Monty Widenius, o criador original do MySQL. Monty formou uma empresa para gerenciar o desenvolvimento do MariaDB, chamada Monty Program, que contrata desenvolvedores para criar e melhorar o produto MariaDB. Isso pode ser algo bom e ruim: é bom porque eles lideram os recursos e correções de erros no Maria, mas pode causar problemas porque a empresa não está focada em receita, mas sim em produto. Empresas que não geram receita não duram para sempre.

Drizzle

O último produto que iremos examinar é o Drizzle. Ao contrário dos outros dois produtos finalizados que examinamos, o Drizzle apresenta grande diferença em relação ao MySQL e até mesmo afirmam que o produto não é uma substituição simples para o MySQL. Eles estão tentando fazer mais mudanças importantes no MySQL e tem como objetivo fornecer uma ótima solução para o problema da alta disponibilidade, mesmo que isso signifique alterar aspectos do MySQL com os quais estamos acostumados.

No FAQ da empresa, a leitura das questões reforça os objetivos subjacentes. Eles não estavam satisfeitos com as alterações feitas no núcleo do MySQL após o release 4.1, afirmando que muitos desenvolvedores não queriam aquela sobrecarga adicional. Eles admitem que seu produto não é sequer um banco de dados de relação compatível com SQL. Isso é realmente diferente do MySQL.

Então, com uma mudança tão drástica em relação ao MySQL familiar, por que deveríamos considerar esse produto? Exatamente por esses motivos — é uma grande reescrita dos mecanismos do MySQL, com os recursos que foram considerados não ideais removidos, e com grande parte do código sendo reescrita para ser otimizada, chegando a ponto de trocarem C por C++ no código. E não acaba aí: esse produto tem um mercado alvo específico em mente com seu design — servidores com vários núcleos e muita RAM, máquinas de 64 bits executando Linux, servidores usados em computação em nuvem, servidores hospedando websites, servidores obtendo dezenas de milhares de ocorrências por minuto. É um mercado bem específico. É específico demais? Lembre-se do quanto esse tipo de empresa gasta com seus bancos de dados atualmente — se ela pode instalar Drizzle em vez de MySQL e cortar os custos com servidor pela metade, isso é muito dinheiro!

Então todos deveriam estar usando Drizzle, certo? Espere, pois, como eles destacam repetidamente, não é compatível com MySQL. Portanto, se você tem uma plataforma MySQL existente, haveria muitas alterações a serem feitas no código para fazer com que ele funcione corretamente no seu ambiente.

Embora exija mais trabalho para executar e não pareça ser tão rápido e fácil de usar como Percona ou MariaDB, eu incluo Drizzle porque, embora ele possa não ser sua escolha hoje, em alguns anos será provavelmente a escolha de algumas pessoas. Como o objetivo deste artigo é informar sobre as ferramentas que você usará no futuro, essa é uma boa oportunidade de mostrar esse produto. Muitos especialistas de DB líderes acham que o Drizzle será a escolha de instalações de alta disponibilidade em cinco anos.

Drizzle é 100% software livre e recebe contribuições abertamente de desenvolvedores. Não há uma empresa subjacente financiando o desenvolvimento, como no MariaDB, e não é fechado para contribuições de fora, como Percona. Está em uma boa posição para crescimento e novos recursos, que ele pode precisar, dado seu escopo de reescrever grande parte do MySQL.

Gráfico de comparação

Aqui está um resumo dos três produtos de ramificação MySQL mencionados neste artigo.

Produto Preços Objetivo Recurso Principal Pronto para Produção?
Percona Server Grátis Fornece um wrapper para mecanismo de armazenamento XtraDB e ferramentas de análise adicionais XtraDB Sim
MariaDB Grátis Estendeu MySQL para incluir XtraDB e outras melhorias de desempenho XtraDB Sim
Drizzle Grátis Oferece grandes melhorias de escalabilidade e desempenho em relação ao MySQL Alta disponibilidade Sim

Conclusão

Este artigo discutiu três novas ramificações do produto MySQL que intencionam resolver alguns problemas identificados com o MySQL. Os três são grátis e são produtos de software livre. É preciso pesar as vantagens e desvantagens de usá-los em relação ao que o MySQL já oferece. Eu acredito que, para quase todos que leem este artigo, MySQL será ainda a escolha preferencial para suas necessidades de bancos de dados. Eu duvido que muitos leitores deste artigo sejam proprietários de websites que recebem 1.000.000 de ocorrências por hora. Quero destacar isso novamente — MySQL ainda é um produto incrível que é um banco de dados perfeitamente adequado para a maioria dos casos de uso.

No entanto, para vocês que acham que seu site requer mais alta disponibilidade, escalabilidade e desempenho do que o MySQL pode oferecer atualmente, um desses três produtos pode ser a solução que vocês procuram. No futuro, se você acha que seu site irá se tornar uma ideia de um bilhão de dólares, deve-se considerar começar com um desses três produtos e assim resolver esses tipos de problemas antes mesmo que eles comecem.

Por fim, o motivo principal dessas ramificações do MySQL é alterar alguns recursos subjacentes do MySQL, sendo que os autores acharam que não podiam esperar que o MySQL fizesse isso. Além disso, o espectro da Oracle ronda sobre o futuro do MySQL, e muitos desenvolvedores, incluindo o desenvolvedor original do MySQL, estão preocupados sobre o futuro do produto e se a Oracle irá mostrar a devoção ao produto que um banco de dados de ponta exige. Na minha opinião, todas essas preocupações são válidas, e, por esse motivo, você deve manter esses três produtos em mente enquanto caminhamos para o futuro.

Recursos

Aprender

Obter produtos e tecnologias

  • Como você está interessado no desenvolvimento de banco de dados, talvez queira experimentar o produto gratuito IBM DB2 Express-C.
  • Experimente outro software IBM sem custo. Faça o download de uma versão de avaliação, faça login em uma versão de avaliação on-line, trabalhe com o produto em um ambiente de simulação ou acesse-o por meio da nuvem. Escolha dentre mais de 100 versões de avaliação de produtos IBM.

Fonte: Michael Abernethy/IBM

Tags | , , , , , ,

17

nov
2011

4 Comentários

Em Blog

Por Allison

Fedora Linux 16 em detalhes: foco em cloud computing

Em 17, nov 2011 | 4 Comentários | Em Blog | Por Allison

A comunidade Fedora lançou a versão 16 da popular distribuição do Linux. Entre as principais novidades, estão o suporte ao Kernel 3.1, Gnome 3.2 e KDE Plasma 4.7, além de várias melhorias em relação ambientes de nuvem e virtualização.

Embora seja tradicionalmente voltada para desenvolvedores de projetos open source, oferecendo as últimas atualizações (potencialmente instáveis) destes projetos, a distribuição Fedora vem também sendo reconhecida como uma boa distribuição para usuários domésticos e corporativos. A nova versão foi dedicada pela comunidade a Dennis Ritche, um dos criadores da Linguagem C e do Unix.

Recursos para nuvem

Vários recursos de cloud computing estão embutidos no novo Fedora, com destaque para:

  • Aeolus Conductor – Interface web para gerenciamento de ambientes de nuvem de vários fornecedores, públicos e privados, por exemplo Amazon EC2, Rackspace, VMWare VSphere e Eucalyptus.
  • OpenStack e Condor Cloud – Duas opções que fornecem infraestrutura completa para criação nuvens privativas.
  • HekaFS – Antigo GlusterFS, é um sistema de arquivos de cluster com recursos de multitenancy para nuvem e criptografia OpenSSL.
  • pacemaker-cloud – Extensão do pacemaker (para do Red Hat Cluster Suite) para gerenciar disponibilidade e fail-over de aplicações e recursos em nuvem.
  • Matahari – Coleção de APIs e agentes para monitoramento e gerenciamento de sistemas.

Virtualização e mudanças para o administrador de sistemas

O Fedora é a base para o desenvolvimento do RHEL (Red Hat Enterprise Linux) e suas distribuição derivadas, como o CentOS. Assim o administrador de sistemas corporativo (também conhecido como sysadmin) tem no Fedora uma prévia do que virá em versões futuras destas distribuições; por exemplo:

  • Capacidade de inspecionar o conteúdo de arquivos em imagens de VM (read-only), e o conteúdo do Windows Registry armazenado nestas imagens.
  • Suporte a Dom0 do Xen (parte do kernel 3.1), de modo que não é mais necessário usar um kernel modificado com o Xen Server da Cytrix, Oracle VM e outros produtos baseados no Xen. O Dom0 é o domínio que realiza todas as operações de entrada e saída, para os demais domínios (VMs); ou seja, é ele quem fornece os drivers para o hypervisor.
  • Mudanças no processo boot, que agora usa Grub2, permite particionamento utilizando GPT em lugar do antigo MBR do MS-DOS (fim dos limites de tamanho das partições!) e suporta o Trusted Boot da Intel, quando disponível no hardware. O antigo subsistema HAL para detecção de novo hardware foi descontinuado, sendo substituído pelo udev e serviços relacionados.
  • Chrony, novo servidor NTP mais tolerante a relógios imprecisos de PCs e sistemas que passam longo tempo desconectados da internet, como notebooks e VMs que ficam suspensas frequentemente.
  • Ike (Shrew Soft VPN Client), novo cliente VPN que facilita o uso do IPsec.

Também há suporte ao compartilhamento de dispositivos USB 2.0 do host com máquinas virtuais KVM. Isso, somado ao suporte a SPICE, torna o Fedora Linux uma plataforma melhorada para virtualização de desktop. Um dispositivo USB também pode ser compartilhado com outras máquinas em rede.

Novidades para o desenvolvedor

O Fedora Linux traz recursos importantes para o desenvolvedor corporativo. É a distribuição do Linux com suporte mais abrangente ao Eclipse e outros recursos para desenvolvimento Java, PHP, Python e Ruby.

Entre as novidades do Fedora 16 para desenvolvedores, podemos destacar:

  • BE (Bugs Everywhere) – Um bug tracker integrado a sistemas de controle de versões distribuídos, para simplificar a gerência e o rastreamento de mudanças.
  • btparser – Ferramenta para análise de backtraces do gdb.
  • D2 – Nova linguagem que tenta reunir as vantagens de Java e C++.
  • WSO2 – Framework de Web Services SOA e WS-* para C++.

O OpenJDK 7 também é oferecido, mas apenas como Technology Preview. O Eclipse, o Tomcat e outras aplicações Java continuam sendo compiladas com o Open JDK 6. O motivo é a falta de um TCK (kit oficial de testes de compatibilidade/aderência) para o Java 7, de modo que empresas que usam o Fedora em produção podem preferir usar os downloads (proprietários) da Oracle. (Também foram descobertas diversas pequenas incompatibilidades entre bibliotecas Java populares e o Java 7, que não puderam ser resolvidas a tempo para o lançamento do Fedora 16.)

Novidades para usuários finais

Para usuários finais, a grande novidade é a inclusão do Gnome 3.2, que continua despertando reações ame-ou-odeie pela sua nova interface com desktop limpo e suporte a tablets. Um destaque é o gerenciamento integrado de contas de serviços internet (Google, Facebook, Jabber etc.) e de serviços de armazenamento em nuvem.

Entre as novas aplicações inclusas no Fedora 16, podemos citar:

  • Routino – Navegação via OpenStreetMaps.
  • WriteType – Ajuda crianças a escrever corretamente, com predição de palavras, autocorreção e suporte a voz para leitura.
  • Ease – Software de apresentações baseado no Cutter, integrado ao Gnome 3 e com interface otimizada para tablets.

Obtendo e instalando o Fedora 16

É possível baixar imagens ISO para mídias live em CD ou pendrive, ou então baixar um DVD (.iso) contendo os principais pacotes para servidores e desenvolvimento. É possível também usar uma mídia para instalação a partir da internet. Além disso, já estão disponíveis imagens prontas para nuvens Amazon.

Quem já tem o Fedora 15 ou versões anteriores, pode fazer uma atualização diretamente pelo gerenciador de atualizações gráfico da distribuição, ou pela ferramenta preupgrade.

É importante lembrar que o Fedora não inclui softwares proprietários, como alguns drivers para placas Wi-Fi e vídeo NVidia, ou codecs para MP3. Mas estes são facilmente instalados usando o EasyLife (que em breve estará atualizado para o Fedora 16), ou então o repositório RPM Fusion (já atualizado). Usuários habituados ao Debian e Ubuntu podem consultar este Guia de Transição do Ubuntu para Fedora.

Fonte: Fernando Lozano/InfoQ

Tags | , , , , , , , , , , , , , ,

07

nov
2011

Sem Comentários

Em Blog

Por Allison

Node v0.6.0 é lançado

Em 07, nov 2011 | Sem Comentários | Em Blog | Por Allison

A equipe de desenvolvimento do Node anunciou o terceiro branch estável do Node v0.6. Segundo os desenvolvedores, eles congelarão JavaScript, C++ e interfaces binárias para todos os releases v0.6.

As maiores diferenças entre as versões v0.4 e v0 são: suporte nativo para Windows usando I/O Completion Ports para sockets; equilíbrio de carregamento integrado entre múltiplos processos; melhor suporte para IPC entre instâncias do Node; melhor linha de comando do debugger; ligação integrada ao zib para compressão; e atualização do v8 3.1 para 3.6.

Para dar suporte ao Windows, os desenvolvedores retrabalharam grande parte da arquitetura principal. Havia o receio de que isso prejudicasse a performance em sistemas UNIX, mas esse não foi o caso.

Na última versão do Node, a v0.4, os desenvolvedores só conseguiram rodar o Node no Windows com Cygwin. Entretanto, eles conseguiram importantes melhorias ao focar nas APIs nativas.

Por enquanto, usuários não têm acesso a um bom caminho para construírem módulos de aplicativos em Visual Studio – isso será feito em releases futuros.

Para aqueles que atualizarem suas bases de código da v0.4 para v0.6, há uma documentação disponível que mostra a maioria dos problemas com os quais eles terão que lidar. Apesar da longa lista de mudanças, a maior parte da API permaneceu intocável.

Além disso, os desenvolvedores informaram que o ciclo de liberação de versões do Node será bem apertado agora. Eles esperam liberar uma nova versão estável em janeiro e desejam sincronizar a liberação de releases com a do Chrome e a do V8, que é de 6 semanas.

Mais detalhes sobre as mudanças da v0.5.12 para a v0.6.0 e benchmarks podem ser encontrados aqui. O download do Node v0.6.0 pode ser feito através deste link e sua documentação está disponível aqui.

Fonte: IMasters

Tags | , , , , , ,