Todos os posts de Allison

Falha crítica de segurança é encontrada no PHP

Fonte: IMasters

Por Paulo Graveheart

Uma falha recente encontrada no PHP e liberada para o público por engano pode deixar qualquer página no servidor aberta para inserção de código malicioso. A vulnerabilidade, que afeta apenas servidores rodando o PHP em modo CGI, foi descoberta por um time de hackers durante uma competição.

A essência da falha é que hoje é possível chamar parâmetros do PHP direto pela URL. Por exemplo, ao acessar o endereço http://localhost/index.php?-s, o servidor executaria o PHP com o parâmetro -s, que exibe o código-fonte do arquivo, e não o HTML gerado por ele. Só isso já seria problema suficiente (afinal, é comum inserir dados como senhas do banco de dados no código fonte), mas o time que descobriu a falha também percebeu que ela também permite inserir código malicioso no arquivo e executá-lo.

Descobertas desse tipo normalmente são enviadas para os desenvolvedores que primeiro resolvem o problema e lançam uma atualização para só então os veículos anunciarem a falha e a correção, mas por uma falha humana o bug foi acidentalmente enviado como “público” no sistema de bugs do PHP.

Embora o time de desenvolvedores já tenha liberado uma correção, há informações de que elas não resolvem totalmente o problema. O ideal é usar o PHP de outra forma que não em modo CGI (em modo FastCGI essa falha não acontece) ou incluir uma regra para que o Apache bloqueie URLs com “-” no arquivo .htaccess, evitando assim o uso de parâmetros do PHP. A regra é esta abaixo:

 
RewriteCond %{QUERY_STRING} ^(%2d|-)[^=]+$ [NC]
RewriteRule ^(.*) $1? [L]

Uma nova atualização deve sair em breve, já com uma correção mais eficiente. Até lá, todo cuidado é pouco.

Como adicionar scroll infinito a um template WordPress

Fonte: Paulo Faustino/IMasters

Para quem trabalha com desenvolvimento de temas WordPress, introduzir constantemente novas funcionalidades é primordial – não só para tornar seus templates mais atrativos, mas acima de tudo, mais funcionais. O scroll infinito é uma forma muito popular de carregar conteúdo de forma dinâmica no seu site, sendo necessário apenas que o usuário faça scroll na tela, para o conteúdo ir carregando e aparecendo de forma dinâmica.

Sites populares, como o Twitter e Facebook usam esta funcionalidade há um bom tempo e ela pode ser facilmente adaptada para um template WordPress, dependendo logicamente das suas necessidades. Nem todos os tipos de sites e blogs se encaixam bem em um scroll infinito, portanto, ao usar a funcionalidade, tenha isso em mente. Para colocar o scroll infinito no seu WordPress, siga os passos deste artigo, baseado no código dos colegas do wptheming.

Para quem trabalha com desenvolvimento de temas WordPress, introduzir constantemente novas funcionalidades é primordial – não só para tornar seus templates mais atrativos, mas acima de tudo, mais funcionais. O scroll infinito é uma forma muito popular de carregar conteúdo de forma dinâmica no seu site, sendo necessário apenas que o usuário faça scroll na tela, para o conteúdo ir carregando e aparecendo de forma dinâmica.

Sites populares, como o Twitter e Facebook usam esta funcionalidade há um bom tempo e ela pode ser facilmente adaptada para um template WordPress, dependendo logicamente das suas necessidades. Nem todos os tipos de sites e blogs se encaixam bem em um scroll infinito, portanto, ao usar a funcionalidade, tenha isso em mente. Para colocar o scroll infinito no seu WordPress, siga os passos deste artigo, baseado no código dos colegas do wptheming.

Baixe o JavaScript

Faça o download de uma cópia do arquivo “jquery.infinitescroll.min.js”, que está no repositório do GitHub, e coloque-o na pasta de scripts ou arquivos JavaScript do seu template WordPress. Se não tem uma pasta “scripts” ou “js” no seu template, você poderá criar uma apenas para organizar todos os arquivos e funcionalidades do seu tema.

Se desejar, pode ainda escolher uma das imagens para o efeito de loading do script. Veja aqui. Carregue a imagem para a pasta “imagens” do seu template.

Carregar o script

Vai ser necessário registar e carregar o script para dentro do arquivo functions.php do seu template. Copie e cole o seguinte código para dentro do arquivo functions.php do seu tema. Se o seu tema não tiver um arquivo com esse nome, deverá criar um e colar o seguinte código:

/**
* Load javascripts used by the theme
*/
function custom_theme_js(){
wp_register_script( 'infinite_scroll',  get_template_directory_uri() . '/js/jquery.infinitescroll.min.js', array('jquery'),null,true );
if( ! is_singular() ) {
wp_enqueue_script('infinite_scroll');
}
}
add_action('wp_enqueue_scripts', 'custom_theme_js');.

Inicializar o script

No código seguinte, estão listados diferentes parâmetros usados no template. Provavelmente, você precisará alterar alguns deles para se ajustarem corretamente ao seu template. Veja:

  • img: O caminho para o URL da imagem de loading;
  • nextSelector: Selector do link “artigos antigos”;
  • navSelector: Selector dos links de navegação anterior/próximo;
  • itemSelector: Selector para posts. Poderá ser .hentry, .post, .etc;
  • contentSelector: Contém divs para os seus posts.
/**
* Infinite Scroll
*/
function custom_infinite_scroll_js() {
if( ! is_singular() ) { ?>
<script>
var infinite_scroll = {
loading: {
img: "<?php echo get_template_directory_uri(); ?>/images/ajax-loader.gif",
msgText: "<?php _e( 'Loading the next set of posts...', 'custom' ); ?>",
finishedMsg: "<?php _e( 'All posts loaded.', 'custom' ); ?>"
},
"nextSelector":"#nav-below .nav-previous a",
"navSelector":"#nav-below",
"itemSelector":"article",
"contentSelector":"#content"
};
jQuery( infinite_scroll.contentSelector ).infinitescroll( infinite_scroll );
</script>
<?php
}
}
add_action( 'wp_footer', 'custom_infinite_scroll_js',100 );

Nota: Não esqueça de traduzir as mensagens de carregamento para a língua desejada.

Testar o script

Ao carregar o conteúdo da homepage ou de uma categoria, o scroll infinito deverá estar funcionando. Caso não esteja, verifique se o script não está carregando corretamente, ou se por ventura está dando algum erro de JavaScript. Verifique também se os seletores estão todos funcionando corretamente.

Se você fizer scroll diversas vezes, é provável que a determinada altura comece a dar erros 404, pelo que você deverá aplicar o seguinte patch ao arquivo functions.php:

/**
* If we go beyond the last page and request a page that doesn't exist,
* force WordPress to return a 404.
* See http://core.trac.wordpress.org/ticket/15770
*/
function custom_paged_404_fix( ) {
global $wp_query;
if ( is_404() || !is_paged() || 0 != count( $wp_query->posts ) )
return;
$wp_query->set_404();
status_header( 404 );
nocache_headers();
}
add_action( 'wp', 'quimby_paged_404_fix' );

É isso, pessoal! Até mais.

Red Hat abre o código do OpenShift

Fonte: IMasters

Com informações de The H

A Red Hat anunciou que abriu o código da Platform-as-a-Service (PaaS) OpenShift. A versão pública do produto, que recebeu o nome OpenShift Origin, pode ser baixada como um live CD baseado no Fedora, que pode ser utilizado para configurar uma instância do OpenShift em uma máquina usando o VirtualBox.

Anunciado há pouco menos de um ano, o OpenShift é baseado na tecnologia da Makara, uma empresa que a Red Hat adquiriu em 2010. A plataforma usa vários aplicativos de código aberto no background e, com o anúncio, a Red Hat abriu o código da interface do usuário e dos componentes que colocam tudo isso junto. A pilha do software do OpenShift é escrita em Ruby e usa YAML para definir os conteiners para aplicativos hospedados na plataforma.

Há várias edições diferentes do OpenShift, que abrangem desde a versão Express, que roda aplicativos escritos em PHP, Ruby e Python, até a versão Flex, que executa aplicativos mais complexos em Java e PHP e os liga ao middleware JBoss da Red Hat. A versão mais completa do OpenShift Power pode rodar qualquer aplicativo que compila no Red Hat Enterprise Linux (RHEL) 4 ou superior. O OpenShift possui opções que unem esses aplicativos em vários bancos de dados, como MySQL, PostgreSQL e MongoDB. Para fazer o deploy na plataforma, os desenvolvedores podem usar Git para colocar seu código na nuvem, e o OpenShift vai lidar com escalonamento e com gerenciamento num segundo plano.

A Red Hat declarou que planeja desenvolver o OpenShift de uma forma parecida com a distribuição Fedora, com o OpenShift Origin sendo o projeto upstream de seu próprio produto comercial. Nessa linha, a empresa está oferecendo facilidades para rastreamento de bugs, hospedagem de projeto e outros suportes para o OpenShift público, como já faz com o Fedora.

O código do projeto OpenShift Origin está disponível no GitHub sob a licença Apache 2.

Cinco motivos para você escolher o WordPress

Fonte: Criarsites

Este é um guest post escrito por André Luis que escreve no blog PC Web.

Todas as pessoas quando vão criar o seu primeiro blog ficam com aquela dúvida: Qual plataforma eu vou escolher para o meu blog? Essa escolha de plataforma tem que ser bastante pensada, pois se no futuro você quiser fazer uma migração para uma outra plataforma, será um pouco trabalhoso, e dependendo do caso, você perderá algumas informações importantes, como os uploads de imagem, alguns comentários, tags e várias outras coisas que se perdem em uma migração de uma plataforma para outra, por exemplo, do Joomla para WordPress.

Pois bem, como a maioria do pessoal aqui já perceberam, eu sou um fanático pela plataforma WordPress, eu aconselho ela a todos os blogueiros por causa de alguns fatores que a tornam simples de se usar. É ele que eu utilizo em meu blog PC Web e no meu recente blog de imagens o Imagens Top e também é utilizado aqui no Criar Sites. Veja agora cinco fatores que ajudarão você a escolher a plataforma WordPress para o seu blog.

É um script Open Source (Código Aberto)

Olha que maravilha, você ter um script de blog em código aberto, isso fará com que você seja “praticamente” o dono desse script, pois você tem a total liberdade para editar ele completamente e adequá-lo ao seu gosto. Você tem a liberdade de executar o programa, para qualquer finalidade. Você tem acesso ao código-fonte, a liberdade de estudar como o programa funciona e a liberdade de alterá-lo para ele fazer o que você desejar. Você tem a liberdade de redistribuir cópias do programa original para ajudar ao seu próximo.

Você tem a liberdade de distribuir cópias de suas versões modificadas para os outros. Ao fazer isso você pode dar a comunidade toda a oportunidade de se beneficiar de suas alterações. Você não gostou de alguma coisa que veio como padrão? Então que tal editar? Você tem liberdade com o WordPress, edite-o, modifique-o, adapte-o ao seu gosto! Nada o impede de fazer mudanças nele! Nada!

Não se impressione em saber que alguns portais gigantescos espalhados pela internet foram criados utilizando o WordPress.

Possui um grande número de temas grátis

Sem dúvidas o WordPress é uma das plataformas que possui o maior número de temas grátis, devido ao seu alto grau de facilidade na edição do código fonte, tornando assim a edição do layout do blog muito mais simples de se fazer. Para você que não sabe o que é um tema, nada mais é do que a “aparência do blog”.

O WordPress possui em seu painel de controle uma busca por temas, ao qual você informará apenas o “tipo de tema” que você quer e automaticamente ele mostra os milhares de resultados de temas sobre esse tipo escolhido, e o melhor de tudo, você não precisará nem ao menos baixar, por que os temas escolhidos no painel de controle do WordPress serão automaticamente instalados em seu blog, em apenas alguns cliques.

E o que mais impressiona, é que a comunidade WordPress é constituída de pessoas legais, ao qual sempre postam ou vendem a preços muito baixos os mais variados temas. E olha que só aparece temas bonitos. A equipe que desenvolveu o WordPress pensou exatamente em todas as pessoas, pois até mesmo aqueles que estão começando agora na área de blogs, conseguem com facilidade modificar todo o código fonte do script.

Possui um grande número de plugins

Da mesma forma que os temas, no painel do WordPress possui uma busca por plugin grátis. Para você que não sabe o que é um plugin, de uma forma resumida, são alterações ou complementos que surgem de uma necessidade por parte do criador em seu blog. Existem vários tipos de plugin (que são modificações) criados e disponibilizados no próprio servidor do WordPress (o que eu falei sobre ser fácil de editar?). E os mesmos podem ser instalados em apenas alguns cliques, utilizando o próprio painel do WordPress. Da mesma forma que os temas, você não precisará baixar absolutamente nada, uma vez que o sistema é todo automático.

Possui um dos mais fáceis painel de Administração

Sem dúvidas o painel de Administração do WordPress é o mais fácil de utilizar e fazer alterações, uma vez que o mesmo deixa tudo muito claro sobre todas as configurações disponíveis no painel. E se algo der errado? Não se preocupe que você fará apenas a configuração reversa a que você fez que tudo voltará ao normal. Depois de ter visto os painéis de Administração dos mais famosos sistemas de blogs, o do WordPress (na minhã opinião) foi o mais fácil de ser configurado. Qualquer pessoa que nunca instalou um blog na vida, conseguirá facilmente instalar e configurar o WordPress tranquilamente. Basta apenas saber ler 🙂

Controle de usuários

Nunca vi em toda minha vida um painel de controle de usuários cadastrados mais simples e eficaz. Pois o mesmo possui apenas as informações necessárias que devemos saber sobre os nossos usuários cadastrados. Apenas 5 ou 6 informações sobre cada usuário já é o suficiente para termos uma noção sobre quem possa ser cada um deles. Nada de endereço, cep, nome completo, CPF e demais informações, pois ninguém quer estar informando em vários sites os seus dados pessoais.

Existe várias outras funcionalidade que fazem do WordPress uma das melhores plataformas do mundo para blogs. Mas creio que essas informações já ajudarão todos aqueles que estão indecisos sobre qual plataforma escolher para seu blog. Posso dar uma dica? Escolha o WordPress, você não irá se arrepender.

PHP 5.4.1 e PHP 5.3.11 são lançados

Fonte: IMasters

Com informações de The H

Os desenvolvedores do PHP liberaram a primeira atualização para o PHP 5.4, a mais recente versão da linguagem, e uma atualização para o PHP 5.3. Segundo os desenvolvedores, todos os usuários do PHP devem atualizar para as novas versões.

O PHP 5.4.1 traz mais de 20 correções para bugs, incluindo alguns relacionados à segurança. Já o PHP 5.3.11 conserta cerca de 60 bugs, incluindo a correção de uma regressão aplicada anteriormente a uma correção de segurança para magic_quotes_gpc.

Uma lista completa com melhorias e correções de bugs para ambas as versões pode ser encontrada no change log do PHP 5. O PHP 5.4.1 e o PHP 5.3.11 estão disponíveis para download como fonte ou como binários do Windows a partir do site do projeto.

WordPress 3.3.2 – Atualização de Segurança

Fonte: WPtotal

A versão 3.3.2 do WordPress já está disponível e veio corrigir alguns problemas de segurança que a versão anterior apresentava. O anuncio da nova versão foi feita por Andrew Nacin no blog oficial do wordpress.org.

Neste update foram atualizadas 3 bibliotecas externas que tinham alguns bugs:

  • Plupload – usada no o upload de conteúdo,
  • SWFUpload – usanda anteriormente para upload de conteúdo, mas continua a ser usada por alguns plugins,
  • SWFObject – também usada em versões mais antigas do wordpress e ainda usada por alguns plugins e temas.

Além das bibliotecas, foram corrigidos os seguintes problemas:

  • Vulnerabilidade XSS ao fazer com que os links sejam clicáveis,
  • Vulnerabilidade também cross-site scripting no redireccionamento depois de fazer um comentário usando browsers mais antigos,
  • Escalação de privilégios limitados, onde um administrador de site pode descativar plugins em toda a rede ao executar uma rede de WordPress em circunstâncias especiais.

As restantes correções podem ser encontradas no change log.
A atualização para esta nova versão é recomendada e não deve de criar problemas de incompatibilidade com temas ou plugins.

A atualização pode ser feita através do painel de administração do wordpress ou se preferir pode atualizar manualmente. Os links para o download da nova versão são os seguintes:

Nota: No momento em que escrevemos este post, a versão brasileira ainda não está disponível.

WordPress 3.4 Beta 3

No mesmo artigo foi anunciado que a versão Beta 3 do WordPress 3.4 já está disponível.

Esta versão está agora mais próxima da versão final que está prevista para o dia 9 de Maio, no entanto é uma versão de testes com alguns problemas e por isso é recomendado que seja usada apenas para testes.

Dicas para ter as Redes Sociais a favor do seu Blog!

Fonte: CriarSites

Este é um guest post que foi escrito por Vinicius Horta do blog Dinheiro Web.

Hoje em dia é praticamente obrigatório para o blogueiro estar presente nas redes sociais, e realmente é possível ter um grande retorno tanto em tráfego como também de boas oportunidades profissionais que surgem a todo instante nas redes sociais, mas para que tenha o melhor aproveitamento possível é preciso observar alguns pontos.

Um primeiro passo para iniciar sua divulgação nas redes sociais é relativamente delicado, pois deve estar presente nas redes, porém sem que tome demasiadamente seu tempo, pois se ficar sem tempo não terá conteúdo para divulgar! Uma das estratégias que venho utilizando e que está apresentando bons resultados é no início do dia definir em que horários estarei nas redes sociais e por quanto tempo me dedicarei a elas. Mas nisto tem um “truque” para que não pareça algo demasiadamente profissional:

Estipule horários aleatórios, desta forma não haverá um padrão. A mente humana possui muita facilidade para reconhecer padrões, tudo que é excessivamente padronizado acaba gerando desinteresse.

Nas Redes Sociais, trabalhe, mas seja você mesmo!

Para que tenha bons resultados ao divulgar seu blog nas redes sociais é preciso ter foco de que está ali para divulgar, ou seja está trabalhando, por outro lado não devemos ser muito formais, é importante agir com naturalidade para criar empatia com os seguidores de seu blog.

Se trabalhar excessivamente sério acabará perdendo a grande oportunidade de interagir com seus leitores, esta interação é justamente uma das coisas mais atrativas, pois é através disso que terá um feedback de seu trabalho.

Vez por outra quebre a imagem de uma relação “blogueiro – leitor”, tore-se um contato de rede social, faça uma piada, compartilhe outros conteúdos interessantes, inclusive de outros assuntos, não é porque escrever sobre criação de blogs que não poderá compartilhar uma notícia ou mesmo uma tirinha que seja engraçada.

Quanto mais natural for esta relação entre você e seus contatos maior tende a ser o retorno em um “call to action”, isto ocorre porque as pessoas já estarão acostumadas a de certa forma responder suas solicitações, por exemplo:

  • Você entrou pela manhã e compartilhou uma boa notícia (seu contato leu e curtiu.
  • Entrou após o almoço e compartilho uma tirinha, seu contato gostou e compartilhou.
  • Ao meio da tarde você entrou mais uma vez e fez algum comentário interessantes de forma a fazer com que seu contato concorde com o que disse.

Pronto, o terreno está preparado, pode compartilhar o link de seu post que seus contatos irão ler! Isso porque na verdade esteve ao longo do dia dando sugestões hipnóticas para seus contatos, é uma questão de condicionar a mente, o que está sendo usado aqui é um padrão hipnótico de Milton Erickson, que pode ser utilizada de forma intensa e imediata como também pode ser utilizada ao longo do dia, semanas, meses ou até mesmo anos, mas quanto maior o intervalo de tempo entre cada sugestão maiores terão que ser suas habilidades.

Crédito da imagem de Fotolia
Veja a seguir um trecho retirado de um artigo de Anderson Chipak e publicado aqui mesmo no Criar Sites, que é justamente o trecho que utilizei aqui como exemplo. Para conhecer todos os outros padrões do artigo basta ver em Guia Completo de Hipnose e Marketing.

13 – fato, fato, fato, e…

Essa é uma das sequências mais eficazes da hipnose. Após uma série da afirmações comprovadas, você faz uma sugestão que terá uma chance maior de ser aceita, assim como as demais.

Esteja atento a seus contatos sempre que possível, pois da mesma forma que você está nas redes sociais para ter atenção dos seus contatos curtindo e seguindo seu blog, muitos de seus contatos também estão fazendo exatamente a mesma coisa.

HTML5 – O que vai mudar em seu Blog ou Site?

Fonte: CriarSites

Este é um guest post que foi escrito por Vinicius Horta do blog Dinheiro Web.

O padrão atual do HTML já não era atualizado desde 1999, isso mesmo, o HTML passou mais de 10 ANOS sem ter uma reestruturação. Organizações como a W3C e diversos desenvolvedores estavam mais focados em desenvolver o XML e também em fazer melhorias no RSS Feed, mas enfim chegou a novidade, que certamente ainda trará muitas outras.

Entre diversos ganhos que se tem com o HTML5 vale ressaltar o ganho real com a semântica, visto que muitos sites são publicados sem nem ao menos as devidas classes (class) e ids para as divs, o que resulta em maior dificuldade para que seu conteúdo seja devidamente indexado.

Com o HTML5 há Maior Clareza sobre o Código

Antigamente era mais complexo de “mostrar” para o buscador e também para o navegador o que era o que dentro de um site, mas isto agora vai mudar devido a novas tags do HTML5, como por exemplo <header> <footer> <article>, que são facilmente compreendidas pelos buscadores, assim dando a devida importância para cada área.

Também há outras novidades com APIs gráficas através da novidade <canvas>, que é algo interessante para imagens 2D, pois embora ainda não plenamente desenvolvido talvez futuramente seja a solução para a correta indexação de imagens.

Ainda falando em indexação, sabemos que o Google segue os links do menu, para isso o HTML5 também já possui seu elemento específico que é <nav>, vale lembrar que quanto melhor seu blog “falar a língua do buscador” melhor ele tende a ser indexado.

Outro grande dilema no desenvolvimento também era o momento de distribuir as tags H1 até H6, pois a repetição de determinada tag poderia enfraquecer o “poder” da próxima entre outros problemas, mas isso também estará resolvido com <section>, que são marcadores para “partes” distintas do site ou blog. Desta forma poderá estruturar seu código de forma a uma área não interferira em outra!

O que Significam estes novos Elementos do HTML5?

Mesmo a nomenclatura já sendo bastante sugestiva de para que serve cada um dos elementos, segue aqui uma breve lista com os principais elementos com os quais vai começar a se deparar pela web e também a usar em seus blogs e sites.

  • Header <header>: Este elemento define o cabeçalho de seu site em HTML5.
  • Nav <nav>: este elemento define a área de navegação, com menus e links importantes do site.
  • Article <article>: é o conteúdo propriamente dito que deverá ir nesta área, como os posts do blog por exemplo.
  • Section <section>: irá definir uma seção do layout, que trabalha de certa forma de maneira independente, podendo até mesmo conter um header e um footer.
  • Aside <aside>: este é outro interessante elemento que serve para envolver conteúdos que sejam diretamente ligados ao conteúdo do blog, como por exemplo a sidebar ou mesmo um menu lateral.

Entendendo o Poder da <section>

Para ficar mais claro como se pode utilizar a <section> de forma a distribuir melhor a autoridade de cada elemento em separado dentro do blog fiz esta imagem:

Repare que são estrutura independentes para o código, ou seja, o H1 do título do blog não irá interferir no H1 do título do post, assim cada qual terá seu grau de relevância correto para os buscadores.

Ainda falando em section poderia por exemplo ter um footer no section do post, desta forma poderia até inserir elementos de certa relevância como artigos relacionados. (o que também pode ser feito com aside).

HTML5 Grátis no WIX!

A Wix é uma empresa que vem crescendo a passos largos, antigamente fazia apenas sites gratuitos em flash, mas a grande novidade é que agora é perfeitamente possível fazer um site de ótima qualidade em HTML5 na Wix sem saber nada de HTML. Tudo é feito com recursos extremamente simples de arrastar e soltar.

Também vale citar que poderá fazer a otimização SEO para cada página do site de forma independente, isso também ajuda bastante! Para saber mais detalhes sobre os sites em HTML5 da Wix poderá ver em Criar um Site Grátis em HTML5 é com a Wix!

Introdução aos “decorators” do Python

Fonte: IMasters

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

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!

Threads em Python

Fonte: IMasters

artigo publicado originalmente no developerWorks Brasil, por Breno Leitão

Breno Leitão é engenheiro de software pela IBM onde atua como kernel hacker.


Python é uma linguagem bem genérica e fácil de ser utilizada. Qualquer usuário pode aprender a programar em Python de uma maneira bem fácil, principalmente porque a linguagem encapsula conceitos difíceis em implementações fáceis.

Neste artigo vamos tratar da utilização de threads em Python. Threads são fluxos de programas que executam em paralelo dentro de uma aplicação, isto é, uma ramificação de uma parte da aplicação que é executada de forma independente e escalonada independentemente do fluxo inicial da aplicação.

Imaginemos, por exemplo, uma aplicação que mede, de tempos em tempos, a condição de determinados sensores. Supondo que cada sensor precisa ser medido com uma frequência diferente, isto é, um a cada 30 segundos, outro a cada 45 segundos e, por fim, um terceiro a cada 75 segundos.

Implementar isto de maneira sequencial é trabalhoso. Um jeito fácil, porém, é a implementação de uma thread independente para a leitura em cada um dos sensores. Desta forma a thread espera o tempo determinado para a leitura do sensor a que ela está ligada, sem se preocupar, ou mesmo saber, sobre os outros sensores.

Assim, neste caso, bastaria fazer uma classe por tipo de sensor, sendo que cada classe seria uma thread. Para transformar uma classe em thread, são necessárias duas modificações na classe:

  • A classe em questão estender à classe Thread do pacote threading
  • Implementar o método run(), que será chamado quando a thread iniciar

Em Python, o pacote que providencia as funcionalidades de thread é chamado threading, e deve ser importado no começo do seu programa: from threading import Thread.

Segue um exemplo básico, de uma classe chamada Th que implementa Thread e o método run(). O conteúdo do método run será executado em uma thread separada sempre que o método start, definido na classe Thread e herdado pela classe Th no nosso exemplo, for chamado:

from threading import Thread

class Th(Thread):

def __init__ (self, num):
Thread.__init__(self)
self.num = num

def run(self):

print "Hello "
print self.num

a = Th(1)
a.start()

Apesar de, no exemplo acima, o conteúdo do método run ser executado em uma thread separada, não é possível comprovar isto apenas pela saída do programa.

Afim de comprovarmos que cada thread é executada de forma independente e escalonada independentemente do fluxo inicial da aplicação, vamos analisar o próximo exemplo. Nele criamos várias threads simples Th, como as do exemplo acima, porém ao invés de simplesmente imprimirmos uma mensagem na thread ela vai executar um número definido de vezes COUNTDOWN antes de finalizar sua execução:

from threading import Thread
import sys

COUNTDOWN = 5

class Th(Thread):

def __init__ (self, num):
sys.stdout.write("Making thread number " + str(num) + "n")
sys.stdout.flush()
Thread.__init__(self)
self.num = num
self.countdown = COUNTDOWN

def run(self):

while (self.countdown):
sys.stdout.write("Thread " + str(self.num) +
" (" + str(self.countdown) + ")n")
sys.stdout.flush()
self.countdown -= 1

for thread_number in range (5):

                    thread = Th(thread_number)
                    thread.start()


Uma das possíveis saídas para o programa acima é a seguinte:

Making thread number 0
Thread 0 (5)
Thread 0 (4)
Thread 0 (3)
Thread 0 (2)
Thread 0 (1)
Making thread number 1
Thread 1 (5)
Making thread number 2
Making thread number 3
Thread 2 (5)
Thread 1 (4)
Thread 1 (3)
Thread 2 (4)
Thread 1 (2)
Thread 2 (3)
Thread 1 (1)
Thread 2 (2)
Making thread number 4
Thread 2 (1)
Thread 3 (5)
Thread 4 (5)
Thread 4 (4)
Thread 3 (4)
Thread 4 (3)
Thread 3 (3)
Thread 4 (2)
Thread 3 (2)
Thread 4 (1)
Thread 3 (1)

Caso você rode o programa acima, a saída não necessariamente será igual a esta, já que a alocação das threads para execução no processador não é um processo determinado. Mesmo rodando múltiplas vezes, o mesmo programa em um mesmo computador as saídas irão variar de uma execução para outra.

Um ponto interessante de se notar no exemplo acima é que, em vez de usarmos print para imprimir na saída padrão, utilizamos sys.stdout.write seguido de uma chamada a sys.stdout.flush.

Isto foi feito para garantir que as mensagems fossem impressas em ordem, já que chamadas a print por diversas threads simultaneamente não garantem a ordem de impressão dos caracteres.

Sincronização de threads

Nos exemplos citados anteriormente, usou-se threads para efetuar processamento paralelos distintos e sem ligação entre si. No entanto, no mundo real muitas vezes as diversas linhas de execução representada pelas threads de um programa precisam, eventualmente, comunicar-se entre si.

Uma forma simples de comunicação é aquela que precisa ocorrer no final do processamento das threads. Exemplos típicos deste tipo de necessidade são programas que processam dados em vetores ou matrizes.

Se estes vetores ou matrizes forem muito grandes e os cálculos efetuados em cada elemento relativamente demorados e independentes até certo ponto, a utilização de threads pode acelerar bastante este tipo de cálculo, já que o trabalho é de alguma forma dividido entre as diversas threads.

Ao final do processo, basta realizarmos um cálculo mais simples que agrega os sub-totais calculados pelas threads. Este tipo de sincronização no final da execução de uma thread pode ser feito através do método join da classe Thread.

Por exemplo, imaginemos um programa que soma os valores de um vetor de inteiros com 1000 elementos cujos valores variam de 0 a 100. Para fins deste exemplo, este vetor será criado com valores randômicos.

Serão criadas quatro threads que calcularão a soma de 250 elementos cada uma. Ao fim do processamento, os sub-totais gerados pelas quatro threads serão somados para gerar um único valor total referente à soma de todos os elementos do vetor.

from threading import Thread
import random
import sys

NUM_VALUES = 1000
values = []
sequential_total = 0
threaded_total = 0
threads = []
NUM_THREADS = 4

class Th(Thread):
subtotal = 0

def __init__ (self, num):
sys.stdout.write("Making thread number " + str(num) + "n")
sys.stdout.flush()
Thread.__init__(self)
self.num = num

def run(self):

range_start = self.num * NUM_VALUES / NUM_THREADS
range_end = ((self.num + 1) * NUM_VALUES / NUM_THREADS) - 1

for i in range(range_start, range_end):
self.subtotal += values[i]
sys.stdout.write("Subtotal for thread " + str(self.num) +
": " + str(self.subtotal)
+ " (from " + str(range_start)

+ " to " + str(range_end) + ")n");

sys.stdout.flush()

def get_subtotal(self):
return self.subtotal

#### O programa comeca aqui #####

for i in range(NUM_VALUES):
values.append(random.randint(0,100))

for i in range(NUM_VALUES):
sequential_total += values[i]

print("Sequential total: " + str(sequential_total))

for thread_number in range(NUM_THREADS):
threads.insert(thread_number, Th(thread_number))
threads[thread_number].start()

for thread_number in range(NUM_THREADS):
threads[thread_number].join()
threaded_total += threads[thread_number].get_subtotal()

print("Threaded total: " + str(threaded_total))

Um exemplo de saída para o programa acima seria o seguinte:

Sequential total: 49313
Making thread number 0
Making thread number 1
Subtotal for thread 0: 12365 (from 0 to 249)
Making thread number 2
Subtotal for thread 1: 12568 (from 250 to 499)
Making thread number 3
Subtotal for thread 2: 11742 (from 500 to 749)
Subtotal for thread 3: 12638 (from 750 to 999)
Threaded total: 4931

Note que o valor total calculado pela versão sequencial da soma dos elementos do vetor é igual à soma calculada através das quatro threads criadas no programa para fazer o mesmo trabalho de forma dividida.

Uma outra forma de sincronização pode ser necessária quando há necessidade de se acessar variáveis cujos valores são compartilhados por várias threads rodando simultaneamente. Para isso, é necessário lançar mão da utilização de locks (threading.Lock) ou semáforos (threading.Semaphore). Um artigo a parte descreverá os locks e semáforos, é só aguardar pelo próximo post.

Conclusão

Este artigo fez uma introdução a programação com Thread em python, mostrando o que é uma thread, com deve ser construida classes que tornam-se thread e como sincronizar o fim das threads.

Recursos

Sites usando HTML5 e CSS3

Fonte: James Leme/cssextremo

O uso do HTML5, em combinação com CSS3, está realmente começando a decolar. Safari, Chrome e Mozilla estão dando mais suporte a cada nova versão de seus navegadores.

A melhor maneira de aprender novas técnicas é tentando. Atualmente você já pode começar a usar HTML5 apenas mudando o tipo de documento.

<! DOCTYPE HTML>

Ele vai validar com o seu código atual, mesmo se você estiver usando XHTML ou HTML.

Para você se inspirar e começar a usar HTML5 e CSS3, listei alguns dos melhores sites usando essas tecnologias.

Edgar Leijs

Vaullt

Ella Design

Como ser um Blogueiro mais produtivo?

Fonte: CriarSites

Este é um guest post que foi escrito por Vinicius Horta do blog Dinheiro Web.

Como em qualquer profissão ser produtivo é fundamental para ganhar dinheiro, para nós blogueiros isto não é diferente, quanto mais produtivo for maiores são suas chances de ganhos financeiros, porém a grande questão é como ser mais produtivo com um mesmo espaço de tempo?

Não importa o quanto tempo tem disponível para blogar, afinal isto tende a não ser alterado por certo tempo, a menos que já esteja na hora de sair do emprego e viver apenas de seus blogs (o que requer cautela), fora isto o tempo que terá para blogar será exatamente o mesmo, isto também se aplica a quem já trabalha integralmente com blogs, afinal o dia não deixará de ter 24hs rsrsr

Já que sabemos que não adianta buscar por mais tempo para blogar o melhor a fazer é otimizar o tempo que temos, isso ajuda a aumentar a produtividade, existem algumas coisas muito simples e que podem representar um aumento considerável na produtividade, veja algumas coisas que podem fazer uma boa diferença em seu dia a dia:

Para Escrever os Artigos do Blog de forma mais Produtiva

É natural que façamos algumas pesquisas antes de iniciar o artigo, algumas vezes acabamos escrevendo o artigo em paralelo a estas pesquisas, isto acaba nos tomando mais tempo, pois entre uma consulta e uma escrita temos que reler o texto para retomar a escrita.

Pesquise tudo de uma só vez, faça as anotações que julgar necessário. Após isto feche todas as abas do navegador e aí sim passará para a escrita, que fluirá muito bem, afinal está com a mente repleta de informações.

Ainda seguindo este método de fazer o artigo em etapas, apenas após terminar o artigo é que deverá pensar em imagens, pois este é outro erro frequente, o que nos leva a ter que reler para continuar escrevendo, afinal além do tempo de busca da imagem também há o tempo em que estará otimizando ela.

Esteja na Internet, Mas não Esteja online!

Grandes desperdiçadores de tempo são as redes sócias e o MSN, a cada vez que alguém entra em uma rede social e começa a conversar com um amigo lá se vai embora no mínimo uma hora do seu dia de trabalho no blog.

Uma hora é bastante coisa até para quem trabalha em tempo integral com o blog, o que dirá para quem tem pouco tempo!

Poderá estar nas redes sociais (afinal é preciso), mas esteja como Offline, o mesmo para o MSN, assim evitará perder tempo ou ter que ser indelicado com algum de seus contatos, até porque infelizmente uma minoria de pessoas respeita o status “ocupado” rsrsr

E você, o que faz para ser mais produtivo no blog?