TDC 2011 Florianópolis

No último final de semana, nos dias 21/08 e 22/08 tive a satisfação de poder participar do http://www.thedevelopersconference.com.br/ edição de Florianópolis.
O conceito do evento é muito interessante, o foco é em desenvolvedores, sejam eles de quais comunidades for, existe conteúdo para todos.

Este tipo de evento possibilita uma troca de experiência muito rica entre especialistas em diferentes tecnologias e no final do dia, todos crescem muito profissionalmente.

Participei representando a Microsoft nas sessões de abertura e em duas palestras sobre HTML5 e Windows Phone.

Além disso, pude acompanhar uma série de excelentes apresentações sobre diversas tecnologias, inclusive Arduino, que despertou uma paixão imediata para o mundo da eletrônica.

Confiram abaixo as apresentações. A demo de Kinect será adicionada em alguns dias, por enquanto, confiram este post https://coding4windows.wordpress.com/2011/08/03/controlando-o-powerpoint-com-kinect/

Todas as apresentações estão disponíveis para download e visualização no Skydrive https://skydrive.live.com/?cid=DE5AFE5B638592F4&id=DE5AFE5B638592F4%213404&sc=documents

image

O objetivo esta apresentação na sessão de abertura do primeiro dia, foi apresentar as opções de ferramentas, tecnologias e programas gratuito para desenvolvedores além de oferecer recursos de integração e desenvolvimento em tecnologias não Microsoft.

Visualizar
https://skydrive.live.com/view.aspx?cid=DE5AFE5B638592F4&resid=DE5AFE5B638592F4%213405

Aplicações modernas com HTML5

image

Esta apresentação é uma visão ampla sobre o que é o HTML5 e sua importância tanto para o mercado, quanto para a Microsoft e desenvolvedores. Além disso, um mergulho nos principais recurso deste novo pacote tecnológico que oferece muitas novas possiblidades para desenvolvedores em geral.

Visualizar
https://skydrive.live.com/view.aspx?cid=DE5AFE5B638592F4&resid=DE5AFE5B638592F4%213407

Tudo o que você precisa saber sobre o Windows Phone 7

image

Palestra que aborta os principais tópicos de desenvolvimento para Windows Phone 7. Estes tópicos vão desde capacidades da plataforma com Hardware, experiência de usuário até ferramentas e APIs importantes para criar aplicativos interessantes sempre pensando no consumo de bateria como prioridade.

Visualizar
https://skydrive.live.com/view.aspx?cid=DE5AFE5B638592F4&resid=DE5AFE5B638592F4%213406

O TDC é um evento que todos os desenvolvedores deveriam ir, a experiência.

Parabéns à organização e principalmente à Yara Senger e Vinicius Senger pela iniciativa e obrigado convite.
Vejam o blog post no blog da Globalcode http://blog.globalcode.com.br/2011/08/microsoft-no-tdc2011-diversidade-e.html

Obrigado pela participação de todos!

Até a próxima!

Anúncios

Controlando o PowerPoint com Kinect


Assista em: http://www.youtube.com/watch?v=5qHJ–oe8kw

Resolvi fazer uma pequena modificação em um projeto de controle de PowerPoint através do Kinect.

O projeto original pode ser encontrado no codeplex e é de autoria de Joshua Blake http://kinectpowerpoint.codeplex.com

Vocês podem ver mais detalhes da implementação neste post http://channel9.msdn.com/coding4fun/kinect/NUI-for-PowerPoint

As minhas alterações fazem com que seja possível movimentar o PowerPoint não apenas afastando os seus braços do corpo, mas sim através de um movimento que expressa mais naturalmente a intenção do usuário de deslizar a página atual.

Abaixo o meu algoritmo super simples:

private bool isTrackingRightHand = false;
private bool isTrackingLeftHand = false;

private void ProcessForwardBackGestureEx(Joint head, Joint rightHand, Joint leftHand)
{

    if (isTrackingRightHand && rightHand.Position.X < head.Position.X - 0.10)
    {
        System.Windows.Forms.SendKeys.SendWait("{Right}");
        isTrackingRightHand = false;
    }

    if (!isTrackingRightHand && rightHand.Position.X > head.Position.X + 0.50)
    {
        isTrackingRightHand = true;
    }

    isForwardGestureActive = isTrackingRightHand;

    if (isTrackingLeftHand && leftHand.Position.X > head.Position.X + 0.10)
    {
        System.Windows.Forms.SendKeys.SendWait("{Left}");
        isTrackingLeftHand = false;
    }

    if (!isTrackingLeftHand && leftHand.Position.X < head.Position.X - 0.50)
    {
        isTrackingLeftHand = true;
    }

    isBackGestureActive = isTrackingLeftHand;

            
}

O que este trecho de código faz é começar a identificar um movimento quando o usuário afasta a sua mão 50cm da linha da cabeça.
Se o usuário continuar o movimento até que sua mão cruze a linha da cabeça em 10cm ele dispara o evento de avançar (para a mão direita) e de voltar (para a mão esquerda) a apresentação.

Procurei respeitar todo o funcionamento do programa, a única modificação necessária é adicionar este método, declarar as variáveis e substituir a chamada do método ProcessForwardBackGesture por ProcessForwardBackGestureEx

Simples não? Vejam o video para sentir o efeito!

Divirtame-se!


Bubble Sort

Hoje resolvi brincar um pouco com este algortimo de ordenação tão famoso, o Bubble Sort.

A idéia deste algoritmo é fazer ir trocando os caracteres de modo que eles “flutuem” como bolhas. Os valores maiores, vão subindo à cada passagem do loop. De maneira metafórica, é como se fossem bolhas, dái o nome Bubble.

O algoritmo é bem simples e existem diversas implementações no wikipedia, para diversas linguagens http://pt.wikipedia.org/wiki/Bubble_sort

Eu resolvi brincar um pouco com C/C++ para ele. Vejam o caso mais simples, ordenação de inteiros:

#include <iostream>

using namespace std;

void print( int numbers[], int size )
{
    int i = 0;

    for( int i = 0; i < size; i++ )
    {
        cout << numbers[ i ] << " ";
    }

    cout << endl;
}

O algoritmo tradicionado do Bubble sort para uma lista de números:

void bubble()
{
    int numbers[] = { 0, 1, 4, 7, 2, 9, 3 };

    int size = sizeof( numbers ) / sizeof( int );
    int temp;
    int steps = 0;

    cout << "Unordered list: ";
    print( numbers, size );

    for( int i = 0; i < size; i++ )
    {
        for( int x = size - 1; x > i ; x-- )
        {
            steps++;

            if( numbers[ x ] < numbers[ x - 1 ])
            {
                temp = numbers[ x ];
                numbers[ x ] = numbers[ x – 1 ];
                numbers[ x - 1 ] = temp;
            }
        }
    }

    cout << "Ordered list: ";
    print( numbers, size );
    cout << "Steps: " << steps << endl;
}

O que temos aqui são dois loops que vão ao encontro um do outro para evitar passagens desnecessárias pelo array já que os menores valores já ficam posicionados ordenamente nas primeiras passagens.

O resultado é:

Unordered list: 0 1 4 7 2 9 3
Ordered list: 0 1 2 3 4 7 9
Steps: 21
Press any key to continue . . .

Agora vem um outro caso onde resolvi usar este algoritmo para ordenação: nomes.
Para deixar a brincadeira mais interessante, resolvi utilizar a minha própria implementação da strlen.

int strlen_x( char* word )
{
    int size = 0;

    if( word )
    {
        while( word[ size++ ] );
    }

    return size;
}
Uma maneira bem simples de obter o tamanho de uma string do C.
Agora uma função simples para imprimir a lista de nomes:
 
void printNames( char* names[], int size )
{
    for( int i = 0; i < size; i++ )
    {
        cout << names[ i ] << " ";
    }

    cout << endl;
}
A função de troca para reaproveitamento de código:
 
void swap( char* names[], int indexA, int indexB )
{
    char* temp = names[ indexA ];
    names[ indexA ] = names[ indexB ];
    names[ indexB ] = temp;
}
 
E a função do bubble adequado para palavras e não apenas inteiros ou caracteres:
 
void sortNames()
{
    char* names[] = { "bill", "steve", "paul", "aaron", "beth", 
"abner", "phil", "john", "mary", "felix", "carl", "tom",
"malcomn", "isabel" };

int steps = 0; int wordSize1, wordSize2; int size = 14; //número mágico cout << "Unodered names: "; printNames( names, size ); for( int i = 0; i < size; i++ ) { for( int x = size - 1; x > i ; x-- ) { if(names[ x ][ 0 ] != names[ x – 1 ][ 0 ] ) { steps++; if(names[ x ][ 0 ] < names[ x – 1 ][ 0 ] ) { steps++; swap( names, x, x - 1 ); } continue; } wordSize1 = strlen_x( names[ x - 1] ); wordSize2 = strlen_x( names[ x ] ); if( wordSize2 < wordSize1 ) { wordSize1 = wordSize2; } for( int w = 1; w < wordSize1 ; w++ ) { steps++; if(names[ x ][ w-1 ] == names[ x - 1][ w-1 ] ) { if(names[ x ][ w ] < names[ x – 1 ][ w ] ) { steps++; swap(names, x, x - 1 ); break; } } else { break; } } } } cout << "Ordered names: "; printNames( names, size ); cout << "Steps: " << steps << endl; }
O resultado é:

Unodered names: bill steve paul aaron beth abner phil john mary felix carl tom malcomn isabel
Ordered names: aaron abner beth bill carl felix isabel john malcomn mary paul phil steve tom
Steps: 146
Press any key to continue . . .

Qual é a diferença?
Ao invés de ter que se preocupar em ordenar N valores, é necessário se preocupar em ordenar N conjuntos de valores sequenciais. Essa sequência é importante para a ordenação final.

Neste caso consideramos a sequência de caracteres quando os nomes iniciam com a mesma letra, neste caso é necessária uma verificação caracter por caracter levando em consideração um caso especial de nomes que podem ter as duas primeiras letras iguais como Aaron.

Se as iniciais são diferentes, o processo é o bubble sort tradicional.

É isso aí pessoal! Divirtam-se Open-mouthed smile