1. O primeiro passo antes de instalar o ffmpeg, é retirar do sistema os pacotes do repositório, pois iremos instalar versões mais novas e/ou com novas configurações:

   sudo apt-get remove ffmpeg x264 libx264-dev

2. Agora vamos instalar todos os pacotes que são as dependências do FFMPEG e do codec x264 (vc precisa estar com os repositórios universe e multiverse habilitados):

   sudo apt-get install build-essential subversion git-core checkinstall yasm texi2html libfaac-dev libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev libsdl1.2-dev libtheora-dev libvorbis-dev libx11-dev libxfixes-dev libxvidcore-dev zlib1g-dev

3. Após instalar todas as dependências, vamos instalar o primeiro codec, o x264. Ele é opcional, mas vamos tentar deixar a instalação mais completa possível. Primeiro, puxe o código fonte (aqui) após o download, abra um terminal no diretório onde se encontra o arquivo  ”x264.tar.gz” execute os seguintes passos:

   tar -xzf x264.tar.gz
   cd x264
   ./configure
   make
   sudo checkinstall --pkgname=x264 --pkgversion "2:0.`grep X264_BUILD x264.h -m1 | cut -d' ' -f3`.`git rev-list HEAD | wc -l`+git`git rev-list HEAD -n 1 | head -c 7`" --backup=no --default

4. Após a instalação do x264, vamos ao FFMPEG! Primeiro puxe o código fonte (aqui) e em seguida, no diretório onde se encontra o arquivo “ffmpeg-0.6.tar.bz2″ execute os seguintes comandos:

   tar -xjf ffmpeg-0.6.tar.bz2
   cd ffmpeg-0.6
   ./configure --enable-gpl --enable-version3 --enable-nonfree --enable-postproc --enable-pthreads --enable-libfaac --enable-libmp3lame --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libtheora --enable-libvorbis --enable-libx264 --enable-libxvid --enable-x11grab
   make
   sudo make install

5. Após isso, temos o FFMPEG instalado e pronto para ser utilizado pelo OpenCV. Qualquer dúvida ou problemas, postem um comentário. Tentaremos deixar esse tutorial mais completo com o passar do tempo.

Criar plugins para o WordPress pode ser uma tarefa simples, mas algumas vezes pode ser algo que dê um certo trabalho. Na api do WordPress, as funções são membros isolados, quase sempre salvas em arquivos únicos, de nomes significativos em diretórios específicos. Não há orientação a objetos e de qualquer ponto de sua aplicação (seja um tema ou um plugin) é possível acessar funções que estejam presentes em qualquer diretório da aplicação.

Por isso o WordPress recomenda nomear funções novas (em plugins e temas) com nomes únicos, assim evita o conflito de nomes de função, já que quase sempre não há necessidade de se incluir arquivos ou definir escopos em funções. É importante também verificar se o nome do plugin que estamos criando já não existe no repositório do WordPress, pois se já existir pode haver conflitos em pesquisar um plugin ou atualizar o mesmo.

Criar plugins no WordPress é basicamente criar uma aplicação php, que se utiliza de funções do WordPress e algumas definidas pelo usuário. Um único arquivo php (de preferência com o nome do plugin), dentro de um diretório com o nome do plugin, já é o suficiente para a existência do plugin, mas é necessário ainda que esse arquivo php possua em seu cabeçalho o seguinte comentário:

/*
Plugin Name: Nome do Plugin
Plugin URI: http://website-do-plugin.com
Description: alguma descrição
Version: 0.1
Author: jose
*/

Basta apenas informar Plugin Name e Author para que o WordPress reconheça o seu plugin e o coloque na lista de plugins instalados.

Nesse arquivo php, ou em outros que forem inclusos, deverão declarar suas funções e utilizar de funções básicas do WordPress para realizarem a modificação do conteúdo que é exibido ou armazenamento e busca de dados no banco de dados do WordPress. Para que o plugin faça a modificação do conteúdo ou busca/armazenamento é necessário interceptar algumas funções básicas do WordPress, como the_content (retorna o conteudo de um post), wp_head (imprime o conteúdo da seção head de uma página), etc.

Essa interceptação e feita utilizando filtros , que podem substituir uma dessas funções básicas do WordPress pela nossa função. O código para isso e bem simples:

add_filter('the_content', 'my_content');
function my_content()
{
echo 'my content';
}
?>

A declaração acima faz com que o conteúdo de uma página ou post que seja buscado pela função the_content, seja substituído pela minha função my_content;

Uma extensa lista de filtros e ações permitem a manipulação do que será exibido e salvo na aplicação WordPress. Essa lista está na documentação do Wordpres.

Por ora o que tenho a dizer é isso. Postarei mais dicas de como fazer plugins em WordPress, mas se você não quer esperar e quer começar agora mesmo, leia a documentação oficial, pois apesar de deixar algumas coisas de fora, ajuda muito quem está começando.

http://codex.wordpress.org/Developer_Documentation

Para se tornar um líder não é somente o aprendizado de técnicas de liderança seriam suficientes para ser um bom líder, porque para isso as pessoas deste grupo tem que perceber essa característica e sentir confiança que esse futuro lídier terá a capacidade de guiar, influenciar e direcionar o grupo a se tornar uma equipe coesa para atingir os objetivos com qualidade.

Em O gerente eficaz em ação de Peter Drucker escreve que: “Os gerentes não têm sidos pagos por aquilo que sabem. Eles têm sidos pagos por fazer as coisas acontecerem.”, pode-se chegar a uma conclusão que um líder seria alguém que seja pago pelo que sabe e que possa guiar um grupo a se tornar uma equipe coesa e de alta produtividade e qualidade e que o gerente seria o profissional responsável por controlar e acompanhar para que as atividades sejam feitas.

Segue um comparativo das visões de um gerente e líder:

Para uma organização deve haver a presença de líder e gerente, pois são papéis que se completam numa empresa, onde um administra e o outro conduz, hoje em dia procura-se no mercado gerentes que sejam líderes ao mesmo tempo, que possam motivar e conduzir os grupos de forma que possam produzir mais e melhor, mas poder influenciar um grupo não é algo fácil, porque nem todos tem o carisma e a facilidade de desempenhar o papel de líder e podem acabar esbarrando na cobrança e desmotivação.

Considere agora que no seu código existe uma variável qualquer, e em uma determinada condição seja necessário saber o tipo dessa variável.

Exemplificando:

Se tipoVariavel(estado) = ‘boolean’ Então { … }

No javaScript isso acaba se tornado um problema, apesar de pequeno, mas que pode se estender se você precisar saber em outras “várias” linhas de código se uma determinada variável é uma string, um número, um objeto e por aí vai…

O objetivo deste artigo é escrever um código em javaScript (uma pequena biblioteca) para resolver estes pequenos problemas do dia a dia.

/**
 * Manipulação de Variáveis 1.0
 * @author: Felipe Lunardi Farias
 *
 * @class check
*/
var check = function(){
 
    return {
 
        /**
         *  Criamos um objeto (op) com a propriedade prototype para
         *  adicionar propriedades e/ou métodos a um determinado objeto
         */
        op : Object.prototype,
 
        /**
         * Determina se o objeto possui valor indefinido
         * @method is_undefined
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_undefined: function( o ) {
 
            try{
                return typeof o === 'undefined';
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },
 
        /**
         * Determina se é um array
         * @method is_array
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_array: function( o ){
 
            try{
                return this.op.toString.apply(o) === '[object Array]';
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },
 
        /**
         * Determina se o objeto é do tipo string
         * @method is_string
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_string: function( o ) {
 
            try{
                return typeof o === 'string';
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },
 
        /**
         * Determina se o objeto é do tipo número
         * @method is_number
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_number: function( o ) {
 
            try{
                return typeof o === 'number' && isFinite(o);
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },
 
        /**
         * Determina se o objeto é uma função
         * @method is_function
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_function: function( o ) {
 
            try{
                return this.op.toString.apply(o) === '[object Function]';
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },
 
        /**
         * Determina se o objeto é um boleano
         * @method is_boolean
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_boolean: function( o ) {
 
            try{
                return typeof o === 'boolean';
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },
 
        /**
         * Determina se o objeto possui valor nulo
         * @method is_null
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_null: function( o ) {
 
            try{
                return o === null;
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },            
 
        /**
         * Determina se o objeto é do tipo objeto
         * @method is_object
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_object: function( o ) {
 
            try{
                return typeof o === 'object';
            } catch(e){
                throw new Error( "Error: " + e );
            }
        }
    };
};

Como utilizar:

// Crie uma instância de check

check = new check();

// Variáveis com valores default (para exemplo)

var teste1 = undefined;

var teste2 = new Array(1,2,3);

var teste3 = ‘Dev’;

var teste4 = 123456;

var teste5 = function(){};

var teste6 = true;

var teste7 = null;

var teste8 = new Object;

// Testes

check.is_undefined( teste1 ) ; // retorna verdadeiro

check.is_array( teste2 ) ; // retorna verdadeiro

check.is_string( teste3 ) ; // retorna verdadeiro

check.is_number( teste4 ); // retorna verdadeiro

check.is_function( teste5 ) ;  // retorna verdadeiro

check.is_boolean( teste6 ); // retorna verdadeiro

check.is_null( teste7 ); // retorna verdadeiro

check.is_object( teste8 );

check.is_undefined( teste3 ) ; // retorna falso

check.is_array( teste7 ) ; // retorna falso

Download: Clique aqui e faça o download completo + código minify para utilizar em produção.

Se você tiver dúvidas, sugestões ou quiser adicionar funcionalidades a esta pequena biblioteca entre em contato por e-mail: felipelunardifarias@gmail.com

A usabilidade pode ser encontrada em qualquer objeto ou dispositivo que possa ser adequado para se tornar algo mais fácil de ser utilizado e mais funcional.

A usabilidade é relativa, depende do contexto de uso e do usuário. Os usuários experientes têm mais habilidades e isso pode diminuir as dificuldades enfrentadas no uso de sistemas; além disso, se o sistema é freqüentemente utilizado, não quer dizer que ele seja de fácil manuseio. Por outro lado, uma interface com uma aparência atraente, se não for rápida, pode trazer frustrações para os usuários.

O conceito de usabilidade em geral não é pensado quando um produto é usável, mas sim quando ele não é adequado ao usuário.

O conceito de usabilidade vem evoluindo e foi-se percebendo que o fato a se considerar é a análise de uso de um produto combinado com o ponto de vista do usuário a respeito do software. Acompanhando essa evolução, a norma ISO 9241-11, define a usabilidade como “a capacidade que apresenta um sistema interativo de ser operado, de maneira eficaz, eficiente e agradável, em um determinado contexto de operação, para a realização das tarefas específicas de seus usuários”.

A usabilidade desenvolve conhecimentos sobre os limites e características referentes ao desempenho do homem que estão relacionadas às interfaces e componentes do sistema.

A usabilidade é um conceito que está evoluindo, pois não tem um significado concreto; ela considera o contexto de uso de acordo com o ponto de vista do usuário.

A web fornece um exemplo acessível da importância da usabilidade, pois os usuários procuram páginas fáceis de usar, sites sem falhas, com informações claras e com boa localização para que eles não se percam nas páginas e sites. As informações devem ser apresentadas de forma que seja de fácil entendimento, caso contrário, os usuários desistem da pesquisa pois se cansam antes mesmo de ter acesso ao que realmente desejam.

A usabilidade é uma combinação de fatores que atingem as habilidades do usuário diante do sistema. Por isso ela trata da interação humano-computador, que é observada desde o desenvolvimento de software por meio de testes de usabilidade com o usuário.

Pode parecer idiota postar uma dica assim, mas se a velocidade de execução do seu programa importa então você deve otimizar as funções que fazem chamadas de sistema, como alocação de memória, no SO. Imagine por exemplo trabalhar com um vídeo, onde temos que processar 30 imagens por segundo e cada imagem é uma matriz de pixels por exemplo.

Um programa simples de alocação de uma matriz de (mxn) seria assim:

// assuma que você já leu os valores dos inteiros <strong>m</strong> e <strong>n</strong>
// ALOCAÇÃO DA MEMÓRIA
 
int **matriz = (int**) malloc( m * sizeof ( int* ) );
 
for( int i=0; i&lt;m; i++) {
matriz[i] = (int*) malloc( m * sizeof(int) );
}
 
//LIBERAÇÃO DA MEMÓRIA
for( int i=0; i&lt;m; i++) {
free(matriz[i]);
}
 
free(matriz);

Isso não é muito eficiente!

Se pudermos eliminar algumas chamadas de sistema (free e malloc) e o laço (for), ganharemos um pouco de desempenho. Para isso, que tal alocarmos apenas 2 vezes e liberamos também apenas 2 vezes?

// ALOCAÇÃO DA MEMÓRIA
 
int *buffer = (int*) malloc( m * n * sizeof( int ) );
 
int **matriz = (int**) malloc( m * sizeof( int* ) );
 
for( int i=0; i<m; i++) {
matriz[i] = &buffer[ i * m ];
}
 
//LIBERAÇÃO DA MEMÓRIA
 
free(buffer);
 
free(matriz);

Você pode achar que estamos gastando memória a mais, mas se você reparar bem, estamos usando apenas um ponteiro a mais.

Se você já possui alguma distribuição anterior Ubuntu, acesse http://ubuntuguide.org/wiki/Main_Page, nele você encontra um link para as distribuições anteriores.

no mundo de desenvolvimento de software, há várias metodologias de desenvolvimento de software como RUP, SCRUM, XP, Lean e etc…

Não vim aqui dizer qual metodologia é a melhor de ser implementada para a tua equipe de desenvolvimento, porque aplicar um modelo de desenvolvimento irá depender de como os processos são executados dentro da equipe, qual o “estilo” de trabalho, mas hoje vim dar uma dica de leitura de uma prática de Scrum e XP numa equipe de aproximadamente 40 pessoas.

Link para download da Versão do livro:

Scrum and XP from the Trenches (Inglês)
Scrum and XP from the Trenches (tradução – Português)

Segue o link onde é difundido os princípios do desenvolvimento ágil.

Manifesto Ágil (tradução – Português)
Manifesto Ágil (Inglês)

O site coolsmartphone perguntou para a HTC quando o update será feito para o HTC Hero na Europa, e resposta foi que o update para os outros HTC Hero só estarão disponíveis em Junho. Lá vamos nós esperarmos mais um adiamento.

Via CoolSmartPhone

1. Criando o diretório do plugin
Numa aplicação aplicação CakePHP qualquer crie um diretório com o nome do plugin.

../plugins/nome_do_plugin

Use de preferência um nome em minúsculo, separando as palavras por underscore. Tenha certeza que o nome do plugin seja diferente do nome de algum controlador existente na aplicação. A hierarquia de diretórios segue o mesmo padrão de uma aplicação CakePHP

2 . Criando um controlador
Para que o plugin possa ser acessado por uma url, é necessária a criação de um controlador e algumas views. Antes de criar o controlador, um controlador base deve ser criado. No diretório do plugin, crie um arquivo chamado nome_do_plugin_app_controller.php com o seguinte conteúdo:

<?php
class NomeDoPluginAppController extends AppController
{
//algumas actions e callbacks
}
 
?>

Não é necessário colocar métodos no controlador, porém você poderá definir as ações que serão utilizadas apenas pelo plugin. Opcionalmente, caso haja necessidade de se usar models, crie um model base “nome_do_plugin_app_model.php”

<?php
class NomeDoPluginAppModel extends AppModel
{
//alguns métodos
}
 
?>

3. Criando controladores e views
Para criar os controllers do seu plugin, crie um diretório “controllers” no diretório do plugin. O nome do controlador não precisa do nome do plugin como prefixo, porém tente criar um nome particularmente único. O controlador deverá estender o controlador base do plugin:

<?php
class MeuControladorController extends NomeDoPluginAppController
{
//...
}
 
?>

O resto é o que normalmente é feito para se visualizar uma action. Crie um diretório “views/meu_controlador” para inserir as views das actions correspondentes.

Para adicionar um model de um plugin em sua aplicação, é necessário chamar o model com o nome do plugin prefixado, separado por “.” (ponto). Por exemplo, para chamar o model “Pie” do plugin “Bakery” no seu controlador, escreva:

//…
var $uses = array(‘Bakery.Pie’);
//…

Para adicionar outros componentes do plugin, adicione sempre o prefixo do nome do plugin separado por ponto