Rodrigo Strauss :: Blog

Talvez você ache interessante ver a lista com todos os posts ou minha lista com os melhores posts.

Sétimo Encontro de Programadores C++

O grupo C & C++ Brasil (ccppbrasil) tem o imenso orgulho em anunciar (agora oficialmente) o nosso sétimo encontro. Detalhes:

• Sétimo Encontro de Programadores C & C++
• dia 14 de agosto de 2010, sábado
• em São Paulo, SP. Rua Teixeira da Silva, 647 - Paraíso
• As palestras de qualidade de sempre
• O ótimo chopp/tubaína/networking de sempre após o evento
• Mais detalhes na página do grupo

Em 22/07/2010 17:09 - Comentários (1)

Mais Tio

Aos que foram à palestra e lançamento do Tio no nosqlbr, algumas coisas que eu esqueci de falar:

• O Tio funciona com 3 campos: key, value e metadata. Esses campos podem ter o tipo string, int, double e raw (blob).
• As chaves dos maps só podem ser strings. Mas você pode acessar por índice numérico para ler o n-ésimo item do map
• Todo container tem suporte à propriedades. Por exemplo, você pode criar uma propriedade "schema" em um container para saber como serializar ou desserializar o que está no campo value
• Para fazer um upsert, é só fazer algo como "my_map['rodrigo'] = 'strauss'"
• Eu quebrei o build do Linux... Quem for testar hoje, tem que compilar em Release e usar somente os containers em memória (volatile/list, volatile/list, etc). Corrijo isso essa semana :-)

Quase tudo que eu falei está na documentação do projeto. Quem tiver mais dúvidas, o melhor canal para perguntar são as duas listas de discussão (inglês e português).

A apresentação está em http://docs.google.com/present/view?id=dg9kbfzn_73m4c7qvc6

Em 15/05/2010 18:29 - Comentários (0)

Apresentação do Tio dia 15 de maio no nosqlbr

Esse sábado acontecerá o primeiro evento brasileiro sobre nosql, organizado pelo @porcelli do OpenSpotlight. Eu farei a palestra "Tio: um nosql Made in Brasil". Tio? Ãh?

Eu ando parindo um nosql já faz mais de um ano, depois de passar mais de um ano pensando no conceito. Aproveitando esse evento e a modinha do nosql, acho que agora é a hora de publicar os fontes e divulgar. Os fontes e a documentação estão em http://code.google.com/p/tio (apesar da insistência do @porcelli para que eu colocasse no github :-))

Para o pessoal de C++, o Tio nada mais é do que containers STL em um servidor remoto, mas tudo construído sobre um base publish/subscribe. Olha como fica simples construir alguns softwares server side com esse conceito:

• Servidor de filas: criar uma lista, o producer manda as coisas fazendo push_back na lista e o consumer usa pop_front. Ou o commando wnp_next, que facilitar a contrução de clusters computacionais.
• Servidor de chat: criar uma lista de mensagem para cada usuário. O usuário assina as modificações da própria lista e quem quiser mandar uma mensagem pra ele faz um push_back na lista. Você pode criar um map com os IDs dos usuários, onde o valor é o nome da lista de mensagens. Se você assinar esse mapa, ainda será notificado automagicamente sobre todos os usuários criados ou apagados

Minha idéia é: todo software server mantém estado e notifica clientes das modificações nesses estados. Eu faço isso bastante usando C++, e é sempre isso. Um monte de containers STL para controlar o estado da aplicação, e código para enviar notificações via TCP para os interessados. O Tio faz quase todo esse serviço sozinho. Muitos protótipos de aplicação podem ser feito com zero linhas de código server.

Os fontes e a documentação estão lá no site do projeto Tio. Para compilar no Windows, tem um projeto do Visual Studio 2008 (não testei no Express, mas deve funcionar). No Linux, você vai precisa do CMake ("cmake . && make" faz o serviço). Você vai precisar do Boost devidamente instalado, compilado e configurado, o Tio é feito usando Boost Asio. O fonte é bem simples e direto, deve ser um bom ponto de aprendizado para quem está estudando Boost Asio.

Criei duas listas de discussão: uma em inglês, e uma em português. Note que o site do Tio é todo em inglês (e os comentários do Wiki devem ser em inglês). Está nos planos ter documentação em português também. Mas eu sou um só :-)

Nos fontes você vai achar um client para C++ e um client Python. Por falta de tempo, o client Python está mais refinado do que o client C++. Em C++ tudo é feito usando algo como

shared_ptr<TioContainer>

container->PushBack(TIONULL, "abcdef")

container["rodrigostrauss"] = "messages/rodrigostrauss"

Para maiores explicações e o chopp/happyhour/networking de sempre, nos encontramos no evento de nosql esse sábado. Traga suas perguntas e comparações com outros nosql.

Em 11/05/2010 10:11 - Comentários (1)

Vou fazer uma palestra sobre Python na Campus Party

• Título: Seja dinâmico com Python
• Descrição: Vou falar sobre quase todas as gambiarras e coisas maravilhosas que um programador pode fazer com os recursos "dinâmicos" do Python. Criar membros e métodos em runtime, usar o reflection mais simples do planeta, responder por métodos que não existem na hora em que são chamados. Métodos __MAGICOS__ e seus correlatos. Como transformar um registro de um banco de dados em um objeto (quase um ORM) com duas linhas de código (ou três). E as piadas quase-engraçadas de sempre
• Data e hora: 26 de janeiro (terça-feira), 09:00hs da matina. Para quem vai acampar lá é uma boa maneira de começar a semana :-)
• Links: Campus Party, agenda do evento, meu twitter

Além disso, devo ficar lá o dia inteiro. Essa palestra está sendo organizada pelo GruPy-SP, o Grupo de Usuários Python do Estado de São Paulo.

Em 22/01/2010 15:59 - Comentários (1)

Lendo e medindo o tempo em C e C++: função time()

Bom, chega de teoria e encheção de lingüiça e vamos para o código de uma vez por todas. A função mais conhecida para pegar a data e hora é a função time() da C runtime, que retorna quantidade de segundos desde o "Unix Epoch", que é meia noite (00:00:00) de 1 de Janeiro de 1970.

Características da função time():

• Retorna a quantidade de segundos desde 1 de Janeiro de 1970. Ou seja, a sua precisão máxima é de um segundo. Ou seja, não serve para medir performance. (ou seja, vou explicar mais sobre isso depois)
• O horário retornado é GMT, para pegar o horário local é necessário fazer manualmente o cálculo para ajuste de fuso horário. Para usar o horário local é necessário usar a função get_timezone (ou _tzset no Visual C++) para ler a diferença do fuso que você usará para fazer o cálculo depois
• Como o retorno da função é um número inteiro, é muito fácil fazer contas com ele. Para avançar a data em dois dias, por exemplo, é só somar [60 * 60 * 24 * 2].
• Durante o inicio dos tempos do unix o retorno era do tipo int de 32 bits. Fazendo uma conta simples com os limites de um inteiro, vemos que o limite de medição é algum dia no ano de 2038, criando uma nova e repaginada versão do bug do milênio. Nas versões mais atuais dessa função o retorno é um int64, o que empurra o limite para uma data bem longínqua, quando provavelmente não haverá mais programadores vivos no universo.
• Por ser uma função da C runtime, está disponível em qualquer compilador C e C++ (qualquer == qualquer compilador não-exótico para plataformas não-exóticas). É provavelmente a função mais multiplataforma de todas que eu vou mostrar

Como um trecho de código vale mais do que 0xFFFFFFFFFFFFFFFF palavras, here we go:

#include <stdio.h>
#include <tchar.h>
#include <time.h>
#include <iostream>
#include <iomanip>
#include <string>

using namespace std;

void print_time(time_t t)
{
  tm* formatted_time;

  //
  // essa função "quebra" essa quantidade de segundos e dia, mês, ano, etc
  //
  formatted_time = gmtime(&t);

  //
  // isso vai mostrar algo como "2009/12/07 14:42:57"
  // note que é necessário somar 1900 na data para pegar o ano corrente
  //
  cout << setfill('0') << 
    setw(4) << formatted_time->tm_year+1900 << "/" <<
    setw(2) << formatted_time->tm_mon+1 << "/" <<
    setw(2) << formatted_time->tm_mday << " " <<
    setw(2) << formatted_time->tm_hour << ":" << 
    setw(2) << formatted_time->tm_min << ":" << 
    setw(2) << formatted_time->tm_sec << endl;
}


int main()
{
  time_t t;

  //
  // pega o número de segundos desde 1970
  //
  t = time(NULL);

  //
  // mostra na tela, formatado
  //
  print_time(t);

  //
  // pega o fuso horário da máquina para pegar o horário local
  // ao invés de GMT. 
  //
  long timezone;

  _tzset(); // carrega as configurações de fuso

  _get_timezone(&timezone); // lê a diferença do fuso

  cout << timezone << endl;

  //
  // ajusta o horário pelo fuso
  //
  t -= timezone;

  print_time(t);

  //
  // avança da data em 2 dias
  //
  t += 48 * 60 * 60;

  //
  // mostra novamente
  //
  print_time(t);

  return 0;
}

Esse código foi feito no Visual C++ (Windows). Existem pequenas diferenças nos nomes das funções no Linux, mas o conceito é o mesmo. Consulte sua documentação preferida para detalhes específicos.

Em 16/12/2009 16:09 - Comentários (1)